1. Introducción a la cinta:
Ribbon es un servicio que proporciona funciones de equilibrio de carga para los clientes. Internamente proporciona una interfaz llamada ILoadBalance para representar las operaciones del equilibrador de carga, como agregar operaciones de servidor, seleccionar operaciones de servidor, obtener todas las listas de servidores y obtener listas de servidores disponibles. Espera
Problemas a resolver:
- ① ¿Cómo no codificar la dirección del servidor Eureka al configurar el centro de registro del cliente Eureka?
- ② Al comunicarse entre diferentes módulos de un microservicio, ¿cómo no codifica la dirección del proveedor de servicios?
- ③ Al implementar múltiples microservicios, ¿cómo lograr el equilibrio de carga a pedido?
¿Qué es la cinta?
En segundo lugar, el caso de entrada de SpringCloud Ribbon
<! - eureka 包含 Ribbon 依赖 jar 包 spring-cloud-netflix-ribbon -> < dependencia > < groupId > org.springframework.cloud </ groupId > < artifactId > spring-cloud-starter-netflix-eureka-client < / artifactId > </ dependency >
② Cómo usar la cinta
@Bean @LoadBalanced public RestTemplate restTemplate () { return new RestTemplate (); }
③ Cómo resolver la codificación dura
Cuando use RestTemplate con la anotación @LoadBalanced para llamar a la interfaz del proveedor de servicios, puede usar la IP virtual en lugar de la dirección IP real . La llamada IP virtual es el valor de la propiedad spring.application.name configurada por el proveedor de servicios en el archivo application.properties o yml . Los ejemplos son los siguientes:
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate; import com.qxj.cloud.entity.User; @RestController public class MovieController { @Autowired private RestTemplate restTemplate; @RequestMapping (valor= "/ película / {id}", method = RequestMethod.GET, produce = "application / json; charset = UTF-8" ) pública del usuario findById (@PathVariable largo id) {
//微服务的虚拟Identificación http: / / provider-user User user = this .restTemplate.getForObject ("http: // provider-user: 7900 / simple /" + id, User. class ); usuario de retorno ; } }
Pequeño resumen: después de la integración de Ribbon y Eureka, el consumidor puede llamar directamente al servicio sin preocuparse por la dirección IP y el número de puerto
Construcción del clúster de microservicios (proveedor de servicios):
Servidor de la máquina 1 :
puerto: 7900
spring:
aplicación:
nombre: proveedor-usuario
#eureka configuración de conexión del cliente
eureka:
cliente:
service-url:
#
Dirección del centro de registro defaultZone: http: // usuario: contraseña123 @ localhost: 8761 /
instancia de eureka :
#Register ip to eureka
prefer-ip-address: true
#Microservice registra eureka con el nombre de instancia $ {spring.cloud.client.ip-address} significa dirección IP
id-instancia: $ {spring.application.name} : $ {spring.cloud.client.ip-address}: $ {spring.application.instance_id: $ {server.port}}
Máquina 2
servidor:
puerto: 7901
spring:
aplicación:
nombre: proveedor-usuario
#eureka Configuración de conexión de cliente
eureka:
cliente:
service-url:
#
Dirección del centro de registro defaultZone: http: // usuario: contraseña123 @ localhost: 8761 /
instancia de eureka : #Register
ip to eureka
prefer-ip-address: true
#Micro service registra el nombre de la instancia con eureka $ {spring.cloud.client.ip-address} indica la dirección IP
id-instancia: $ {spring.application.name}: $ {spring.cloud.client.ip-address}: $ {spring.application.instance_id: $ { server.port))
Máquina 3
servidor:
puerto: 7902
spring:
aplicación:
nombre: proveedor-usuario
#eureka configuración de conexión del cliente
eureka:
cliente:
service-url:
instancia:
Dirección del centro de
defaultZone: http: // user: password123 @ localhost: 8761 / eureka #Register
#Register ip to eureka
prefer-ip-address: true
#Microservice registra eureka con el nombre de instancia $ {spring.cloud.client.ip-address} significa dirección IP
id-instancia: $ {spring.application.name}: $ {spring.cloud.client.ip-address}: $ {spring.application.instance_id: $ {server.port}}
{Spring.application.name} es el mismo y no se puede cambiar.
Tres, componente de cinta IRule
El valor predeterminado es RoundBobinRule (Encuesta)
Cuatro, algoritmo de equilibrio de carga personalizado:
La función principal del llamado Cliente Ribbon personalizado es usar una configuración personalizada para reemplazar la estrategia de equilibrio de carga predeterminada de la Cinta. Nota: El Cliente Ribbon personalizado está dirigido. Generalmente, un Cliente Ribbon personalizado es para un proveedor de servicios (incluyendo Una serie de copias con el mismo nombre de servicio). Se ha personalizado un cliente Ribbon. La estrategia de equilibrio de carga establecida solo es válida para el proveedor de servicios de un nombre de servicio específico, pero no puede afectar la estrategia utilizada por el consumidor de servicios para comunicarse con otros proveedores de servicios. De acuerdo con el significado de la documentación oficial, se recomienda personalizar la clase de configuración fuera del alcance del paquete analizado por el programa principal springboot . De hecho, hay dos formas de personalizar RibbonClient con código puro:
Método 1: defina la clase de configuración fuera del paquete escaneado por el programa principal de springboot y luego agregue la anotación @RibbonClient al programa principal de springboot para introducir la clase de configuración .Importación org.springframework.boot.SpringApplication; Importación org.springframework.boot.autoconfigure.SpringBootApplication; Importación org.springframework.cloud.client.loadbalancer.LoadBalanced; Importación org.springframework.cloud.netflix.eureka.EnableEurekaClient; Importación org.springframework .cloud.netflix.ribbon.RibbonClient; import org.springframework.context.annotation.Bean; import org.springframework.web.client.RestTemplate; import com.qxj.configuration.MySelfRule; @SpringBootApplication // Esta anotación indica que la aplicación es ambas La instancia de eureka es el cliente de eureka y puede descubrir el servicio registrado @EnableEurekaClient //Al iniciar el microservicio , podemos cargar nuestra clase de configuración de Ribbon personalizada, para que la configuración surta efecto @RibbonClient (name = "provider-user", configuration = MySelfRule. Class ) public class ConsumerMovieRibbonApplication { @Bean @LoadBalanced public RestTemplate restTemplate () { return new RestTemplate (); } public static void main (String [] args) { SpringApplication.run (ConsumerMovieRibbonApplication. class , args); } }
archivo de configuración de la regla, la configuración, y no debe estar en el SpringBoot ruta del paquete , por el comentario @RibbonClient carga:
import org.springframework.context.annotation.Bean; importar org.springframework.context.annotation.Configuration; import com.netflix.loadbalancer.IRule; @Configuration public class MySelfRule { @Bean public IRule MyRule () { return new RandomRule_QXJ (); } }
Balance de carga personalizado:
import java.util.List; import com.netflix.client.config.IClientConfig; import com.netflix.loadbalancer.AbstractLoadBalancerRule; import com.netflix.loadbalancer.ILoadBalancer; import com.netflix.loadbalancer.Server; clase pública RandomRule_QXa extiende AbstractLoule { private int total = 0; // El número total de llamadas, actualmente requiere cada llamada 5 veces private int currentIndex = 0; // Número de máquina de servicio proporcionado actualmente / ** * Algoritmo de selección de servicio, requiere cada llamada 5 veces * @param lb * @param key * @return * / public Server choose (ILoadBalancer lb, Object key) { if (lb == null ) { return null ; } Server server = null ; while (server == null ) { // Determine si el hilo actual está interrumpido / / interrupted () es un método estático: la implementación interna se llama isInterrupted () del subproceso actual y restablecerá el estado de interrupción del subproceso actual if (Thread.interrupted ()) { return null ; } // Activa los servicios disponibles List <Server> upList = lb.getReachableServers (); // Todos los servicios List <Server> allList = lb.getAllServers (); int serverCount = allList.size (); if (serverCount == 0 ) { return null ; } if (total <5 ) { server = upList.get (currentIndex); total ++ ; } else { total = 0 ; // Use el siguiente servicio de máquina currentIndex ++ ; // Si la máquina de servicio actual es la última en la colección upList, reutilice el primer servicio de máquina if (currentIndex> = upList.size ()) { currentIndex = 0 ; } } System.out.println ( "currentIndex: "+ currentIndex +" --- total: "+ total); // Al pasar al primer servicio, servidor == nulo, debe volver a adquirir el servidor if (servidor == nulo ) { Thread.yield (); continuar ; } if (server.isAlive ()) { servidor de retorno ; } // Este código no ejecutará realmente server = null ; Thread.yield (); } return server; } @Override public Server choose (Object key) { return choose (getLoadBalancer (), key); } @Override public void initWithNiwsConfig (IClientConfig clientConfig) { } }
Método 2: método de configuración del archivo Application.yml
# @ RibbonClient (nombre = "proveedor-usuario") Igual que el nombre, significa usar reglas de equilibrio de carga personalizadas para este
microservicio
proveedor-usuario:
cinta: NFLoadBalancerRuleClassName: com.qxj.configuration.RandomRule_QXJ
Prioridad configurada
Prioridad del archivo de configuración> Método de configuración del código Java> Método de configuración personalizada de netflix
Declaración de derechos de autor: Este artículo es un artículo original del bloguero de CSDN "Un Xiaoyan dijo que está ocupado", siguiendo el acuerdo de copyright CC 4.0 BY-SA, adjunte el texto original para su reimpresión Enlace de origen y esta declaración.
Enlace original: https://blog.csdn.net/JinXYan/java/article/details/90726707