SpringCloud (5) -Cinta

Introducción a la cinta

Spring Cloud Ribbon es un conjunto de herramientas de equilibrio de carga del cliente basadas en Netflix Ribbon .
En pocas palabras, Ribbon es un proyecto de código abierto lanzado por Netflix, cuya función principal es proporcionar un algoritmo de equilibrio de carga de software para los clientes y conectar los servicios de nivel medio de Netflix. El componente cliente de Ribbon proporciona una serie de elementos de configuración completos como: tiempo de espera de conexión, reintento, etc. En pocas palabras, es para enumerar todas las máquinas detrás de LoadBalancer (abreviado como LB: equilibrio de carga) en el archivo de configuración. Ribbon lo ayudará automáticamente a conectar estas máquinas en función de ciertas reglas (como sondeo simple, conexión aleatoria, etc.). ¡También somos muy fáciles de usar Ribbon para implementar un algoritmo de equilibrio de carga personalizado!

Balance de carga

LB, o Load Balance, es una aplicación de uso frecuente en microservicios o clústeres distribuidos.
El equilibrio de carga simplemente significa que la solicitud del usuario se distribuye uniformemente a múltiples servicios, a fin de lograr la HA (alta disponibilidad) del sistema.
El software de equilibrio de carga común incluye Nginx, Lvs, etc.
Dubbo y SpringCloud nos proporcionan equilibrio de carga, y el algoritmo de equilibrio de carga de SpringCloud se puede personalizar.
Clasificación simple de equilibrio de carga:
1. LB centralizado
¡Es utilizar una instalación de LB independiente entre el consumidor y el proveedor del servicio, como Nginx (servidor proxy inverso), que es responsable de reenviar la solicitud de acceso al proveedor del servicio a través de una determinada estrategia!
1. LB progresivo
Integre la lógica LB en el consumidor, el consumidor sabe qué direcciones están disponibles en el centro de registro de servicios y luego elige un servidor adecuado de estas direcciones. Ribbon pertenece al proceso LB, es solo una biblioteca de clase, integrada en el proceso del consumidor, ¡el consumidor obtiene la dirección del proveedor de servicios a través de él!

Integrar cinta

Agregue la dependencia de la cinta de opciones y la dependencia de Eureka al archivo pom del proyecto original del cliente springcloud-consumer-dept-80

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

Configure Eureka en application.yml

eureka:
  instance:
    hostname: localhost #eureka服务端实例名称
  client:
    register-with-eureka: false #表示是否向eureka注册自己
    fetch-registry: false #如果为false表示自己为注册中心
    service-url:  #监控页面
      defaultZone: http://127.0.0.1:7001/eureka/,http://127.0.0.1:7002/eureka/,http://127.0.0.1:7003/eureka/

Inicie EurekaClient en la clase de inicio principal

@EnableEurekaClient
@SpringBootApplication
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

Modificar el BeanConfig original

//配置负载均衡实现RestTemplate
@Bean
@LoadBalanced //Ribbon
public RestTemplate restTemplate(){
    return new RestTemplate();
}

Modifique el REST_PATH_PREFIX original en DeptConsumerController al nombre de la aplicación y visite en función del nombre del servicio. ¡El cliente no necesita preocuparse por la dirección IP y el número de puerto del proveedor de servicios! (Originalmente: Private static final String REST_PATH_PREFIX = " http: // localhost: 8001 ")

private static final String REST_PATH_PREFIX="http://springcloud-provider-dept";

Inicie el proyecto, visite http: // localhost / consumer / dept / all para probar:

Cinta para lograr el equilibrio de carga

Cree dos nuevas bases de datos sc02, sc03, los datos son los mismos que sc01 excepto db_source.
Cree dos nuevos proyectos Maven springcloud-provider-dept-8002 y springcloud-provider-dept-8003. Copie todo en el proyecto springcloud-provider-dept-8001.
Modifique el número de puerto en springcloud-provider-dept-8002, springcloud-provider-dept-8003 application.yml, el nombre de la base de datos conectada y la información de descripción predeterminada de Eureka.
Asegúrese de que los nombres de las aplicaciones de los tres proveedores de servicios sean los mismos.

spring:
  application:
    name: springcloud-provider-dept

Recuerde modificar la tabla de departamento en el asignador para consultar la base de datos correspondiente.
Escribe la clase de inicio correspondiente.
Inicie el proyecto y visite http: // localhost: 7001 /:

Visite http: // localhost / consumer / dept / all, actualice la página muchas veces y descubra que se consultan diferentes bases de datos (el algoritmo predeterminado es un sondeo simple):

Algoritmo de equilibrio de carga personalizado

Seleccione el servicio consumidor springcloud-consumer-dept-80, cree un nuevo paquete myrule en el paquete com.yinrz y escriba una clase de algoritmo de equilibrio de carga personalizado MyRule:

//自定义负载均衡算法：一个服务连续访问5次后，换下一个服务
public class MyRule extends AbstractLoadBalancerRule {
    public MyRule(){
    }
    private int total=0;
    private int current=0;

    @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {



        if (lb == null) {
            return null;
        } else {
            Server server = null;

            while(server == null) {
                if (Thread.interrupted()) {
                    return null;
                }

                List<Server> upList = lb.getReachableServers(); //活着的服务
                List<Server> allList = lb.getAllServers();      //所有服务
                int serverCount = allList.size();
                if (serverCount == 0) {
                    return null;
                }

//========================核心算法开始==============================
                System.out.println(111);
                if(total<=5){
                    server = upList.get(current);
                    total++;
                }else {
                    total=0;
                    current++;
                    if (current>=upList.size()){
                        current=0;
                    }
                    server = upList.get(current);
                }

//========================核心算法结束==============================


                if (server == null) {
                    Thread.yield();
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();
                }
            }

            return server;
        }
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    @Override
    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    @Override
    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }

}

Escriba una clase de configuración MyRuleConfig debajo del paquete myrule:

@Configuration
public class MyRuleConfig {

    @Bean
    public IRule myRule(){
        return new MyRule();
    }
}

Agregue una anotación @RibbonClient en la clase de inicio principal:

@EnableEurekaClient
@SpringBootApplication
@RibbonClient(name = "springcloud-provider-dept",configuration = MyRuleConfig.class)//在微服务启动的时候就能加载我们自定义的Ribbon类
public class DeptConsumer_80 {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_80.class,args);
    }
}

Ejecute 3 proveedores de servicios, servidor Eureka, proyecto de consumidor de servicios, visite http: // localhost / consumer / dept / all para probar.

SpringCloud (5) -Cinta

SpringCloud (5) -Cinta

Supongo que te gusta