ruban, appel de service d'équilibrage de charge restTemplate

concept de ruban

Le ruban Spring Cloud est un ensemble d'outils d'équilibrage de charge client basés sur le ruban Netflix .
En termes simples, Ribbon est un projet open source publié par Netflix. Sa fonction principale est de fournir des algorithmes et des services d'équilibrage de charge logiciel côté client.
Compléter les éléments de configuration tels que le délai d'expiration de la connexion et les nouvelles tentatives. En termes simples, Load Balancer (en abrégé LB) est répertorié dans le fichier de configuration pour vous aider à vous connecter à ces machines en fonction de certaines règles (telles que l'interrogation simple, la connexion aléatoire, etc.).

Actuellement en mode maintenance, alternative: charge du nuage de printemps.

---

API restTemplate

https://docs.spring.io/spring-framework/docs/5.2.2.RELEASE/javadoc-api/org/springframework/web/client/RestTemplate.html

getObject, getEntity
postObject, postEntity

---

L'équilibrage de charge

Qu'est-ce que l'équilibrage de charge LB?
En termes simples, les demandes de l'utilisateur sont réparties de manière égale vers plusieurs services, de manière à atteindre la haute disponibilité du système.
L'équilibrage de charge commun comprend les logiciels Nginx, LVS, le matériel F5, etc.
Ruban Équilibrage de la charge locale Client vs Équilibrage de la charge du serveur Nginx La différence entre
Nginx est l'équilibrage de la charge du serveur, toutes les demandes des clients seront transmises à nginx, puis nginx transmettra la demande. Autrement dit, l'équilibrage de charge est mis en œuvre par le serveur.
Équilibrage de la charge locale du ruban. Lors de l'appel de l'interface du microservice, elle obtiendra la liste des services d'information enregistrés dans le registre et la mettra en cache localement dans la JVM, implémentant ainsi la technologie d'appel de service distant RPC localement.

Équilibrage de charge + appel RestTemplate.

composant de noyau de ruban IRule

interface d'équilibrage de charge du client ruban et interface de classe d'implémentation
et sous-classes

Implémentation d'algorithme

---

Remplacez l'algorithme d'interrogation par défaut, utilisez aléatoire

package top.bitqian.rule; // 不要同mainBoot一个目录

import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 自定义ribbon 负载均衡规则代替默认轮询规则
 * @author echo lovely
 * @date 2020/12/6 17:34
 */

@Configuration
public class SelfRule {
    
    

    @Bean
    public IRule getIRule() {
    
    

        // 随机
        return new RandomRule();
    }

}

Puis ajouter une annotation @RibbonClient à la classe principale de démarrage .

Imitez le code source pour réécrire l'interrogation

负载均衡算法原理： rest接口的第几次请求数%服务器集群总数量 = 实际服务调用服务器的下标。
每次重启服务后，rest接口从1开始。

interface

package top.bitqian.springcloud.lb;

import org.springframework.cloud.client.ServiceInstance;

import java.util.List;

/**
 * 负载均衡 接口--> 轮询~
 */
public interface LoadBalance {
    
    

    /**
     * 根据可用的服务实例列表 轮询获取某个实例~
     * @param serviceInstanceList 可用服务实例列表
     * @return 轮询后的某个服务实例~
     */
    ServiceInstance getInstance(List<ServiceInstance> serviceInstanceList);

}

---

atteindre

package top.bitqian.springcloud.lb.impl;

import org.springframework.cloud.client.ServiceInstance;
import org.springframework.stereotype.Component;
import top.bitqian.springcloud.lb.LoadBalance;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 仿照源码写轮询算法
 * @author echo lovely
 * @date 2020/12/8 20:37
 */

@Component
public class MyLoadBalance implements LoadBalance {
    
    

    // init 0
    private final AtomicInteger atomicInteger = new AtomicInteger(0);

    public final int getAndIncrease() {
    
    
        int current;
        int next;

        do {
    
    
            current = this.atomicInteger.get();
            next = current >= 2147483647 ? 0 : current + 1;

        } while (!this.atomicInteger.compareAndSet(current, next)); // 期望值，修改值

        System.out.println("the next value -----> " + next);

        return next;
    }

    @Override
    public ServiceInstance getInstance(List<ServiceInstance> serviceInstanceList) {
    
     // 机器列表

        // 得到服务器的下标位置
        int index = getAndIncrease() % serviceInstanceList.size();

        return serviceInstanceList.get(index);
    }
}

---

manette

	// 测试手写的轮询算法~
    @GetMapping("/consumer/payment/lb")
    public String getPaymentByLb() {
    
    

        // 根据服务名获取服务列表
        List<ServiceInstance> serviceInstanceList =
                discoveryClient.getInstances("CLOUD-PAYMENT-SERVICE");

        // 1 2, 1 2, 1 2, 获取服务~
        ServiceInstance instance = myLb.getInstance(serviceInstanceList);

        URI uri = instance.getUri();

        return restTemplate.getForObject(uri + "/payment/lb", String.class);
    }