SpringCloud desde la entrada hasta la competencia: combate real

SpringCloud es una herramienta de desarrollo de arquitectura de microservicios basada en Spring Framework, que se ha convertido en una de las principales soluciones para el desarrollo de arquitectura de microservicios actual. En comparación con la arquitectura tradicional, SpringCloud puede resolver mejor problemas como la división empresarial, la escalabilidad, la alta disponibilidad y la multiempresa. Por lo tanto, aprender Spring Cloud se ha convertido en una de las habilidades esenciales para los ingenieros de Java en la actualidad.

Este artículo explicará en detalle el conocimiento relevante de Spring Cloud, que incluye, entre otros:

Introducción a Spring Cloud
Cree una arquitectura de microservicios
Registro de servicios—Eureka
Proveedor de servicios—Proveedor
Consumidores de servicios—Consumidor
Uso de RestTemplate
uso de la cinta
uso de fingir
Uso de Hystrix
1. Uso de Zuul

1. Introducción a Spring Cloud

En primer lugar, debemos saber que SpringCloud no es una tecnología específica, sino un marco de microservicios distribuidos, principalmente basado en Spring Boot, con el propósito de construir rápidamente una colección de soluciones integrales para sistemas distribuidos.

SpringCloud fue propuesto y de código abierto por Netflix. Se basa en el marco Spring Boot e integra muchos componentes de microservicio comunes.

2. Cree una arquitectura de microservicios

La arquitectura de microservicios de SpringCloud incluye múltiples componentes de microservicios, los más utilizados son Eureka, Feign, Hystrix, Zuul, etc. Echemos un vistazo a las funciones y características de estos componentes.

Eureka

Eureka es un componente de descubrimiento y registro de servicios basado en REST cuyo núcleo es desarrollado por Netflix. Proporciona funciones de registro y descubrimiento de servicios, actúa como un registro de servicios e implementa la gobernanza de servicios en la arquitectura de microservicios.

Eureka tiene los siguientes dos roles:

Servidor Eureka: un servidor que proporciona funciones de descubrimiento y registro de servicios
Cliente Eureka: como proveedor de servicios o consumidor de servicios, una aplicación Java registra los servicios que proporciona o consume con el registro cuando se inicia la aplicación

En Eureka, es necesario integrar los componentes de Eureka Client en los proveedores de servicios y los consumidores de servicios, respectivamente, para realizar el registro y descubrimiento de servicios.

Ventajas de Eureka:

Eureka admite múltiples configuraciones de registro
El registro de servicios admite la autoconservación y los controles de estado
Admite métodos de descubrimiento de servicios flexibles

Desventajas de Eureka:

El descubrimiento de servicios es lento
No es compatible con el equilibrio de carga

Fingir

Feign es un cliente REST declarativo que puede definir parámetros de solicitud, contenido de solicitud y devolver valores a través de anotaciones e interfaces, lo que simplifica el costo de desarrollo del uso de la API REST.

Características principales de Fingir:

Realizado en base a la interfaz, realizado a través de la anotación
Integrado con Ribbon para admitir el equilibrio de carga
Soporte a Hystrix para la degradación del servicio

Ventajas de fingir:

La programación de la interfaz simplifica el desarrollo de solicitudes HTTP
Estrechamente integrado con Spring Cloud, más conveniente de usar
Admite múltiples formatos de codificación: como: JSON, XML, etc.
Admite múltiples métodos de solicitud HTTP: GET, POST, PUT, DELETE, etc.

Desventajas de Fingir:

No se admiten solicitudes HTTP complejas
hilo inseguro

Hystrix

Hystrix es una biblioteca de latencia y tolerancia a fallas desarrollada por Netflix que tiene como objetivo hacer que los sistemas distribuidos complejos sean más resistentes al aislar las dependencias (por ejemplo, a través del patrón de interruptor de circuito).

Características clave de Hystrix:

Admite el almacenamiento en caché de solicitudes y el mecanismo de fusión de solicitudes
Soporte de mecanismo de retardo y fusible
Integra Hystrix Dashboard para proporcionar una interfaz de monitoreo amigable

Ventajas de Hystrix:

Mecanismo de almacenamiento en caché de solicitudes de soporte y mecanismo de fusión de solicitudes
Proporcione un mecanismo de protección de fusibles para reducir el riesgo de falla comercial
Admite visualización casi en tiempo real de indicadores de rendimiento e información de configuración
Admite la implementación manual y automática de estrategias de degradación

Desventajas de Hystrix:

El mecanismo de reintento de múltiples solicitudes aumentará la responsabilidad del cliente
Necesidad de proporcionar monitoreo de rendimiento para toda la arquitectura de microservicio

Zuul

Zuul es un enrutador basado en JVM y un equilibrador de carga del lado del servidor desarrollado por Netflix, que proporciona una entrada unificada para las solicitudes de los clientes.

Características clave de Zuul:

Admite filtro global y filtro local
Las solicitudes se pueden enrutar y reenviar
Límite actual de solicitud de soporte y número específico de solicitudes

Ventajas de Zuul:

Basado en la implementación de JVM, mejor rendimiento
Puede proporcionar apoyo para la marginación de los servicios.
Es posible la coincidencia de rutas complejas
Las funciones personalizadas se pueden personalizar para satisfacer las necesidades

Desventajas de Zuul:

Complejidad adicional agregada debido al soporte de borde de servicio

3. Centro de Registro de Servicios—Eureka

A continuación, usaremos un ejemplo simple para comprender cómo implementar el registro y descubrimiento de servicios a través de Eureka.

agregar dependencias

Agregue las siguientes dependencias al archivo pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-eureka-server</artifactId>
    <version>1.5.6.RELEASE</version>
</dependency>

Escribir un archivo de configuración

Agregue la siguiente configuración al archivo application.yml:

# 服务名
spring.application.name=server-center
# 注册中心地址
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/
# 关闭服务自己的注册
eureka.client.register-with-eureka=false
# 关闭服务自己的fetch-registry=false

Inicie el servidor Eureka

Agregue la anotación @EnableEurekaServer a la clase de inicio de SpringBootApplication para indicar que la aplicación actual es una instancia de Eureka Server.

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

Inicie el proveedor de servicios

Agregue la anotación @EnableDiscoveryClient a la clase de inicio del proveedor de servicios para indicar que la aplicación actual es una instancia de Eureka Client.

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

Iniciar el consumidor de servicios

Agregue la anotación @EnableDiscoveryClient a la clase de inicio del consumidor del servicio para indicar que la aplicación actual es una instancia de Eureka Client.

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

Registro y detección de servicios de prueba

Implemente un servicio simple en el proveedor de servicios y regístrelo con Eureka Server, donde la anotación @RestController indica que la clase puede manejar solicitudes REST.

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello World!";
    }
}

Utilice RestTemplate en el consumidor de servicios para llamar al proveedor de servicios, donde la anotación @LoadBalanced indica que se llama a varias instancias de proveedores de servicios mediante el equilibrio de carga.

@RestController
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    @GetMapping("/hello")
    public String hello() {
        return restTemplate.getForObject("http://provider-service/hello", String.class);
    }
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Inicie Eureka Server, proveedor de servicios y consumidor de servicios, y visite http://localhost:8761/ en el navegador, puede ver que el proveedor de servicios y el consumidor se han registrado correctamente en Eureka Server. Al mismo tiempo, el resultado de invocar al proveedor de servicios se puede ver en la consola del consumidor de servicios.

4. Proveedor de servicios—Proveedor

En la arquitectura de microservicios, la función principal del proveedor de servicios es proporcionar la interfaz de servicio e implementarla.

agregar dependencias

Agregue las siguientes dependencias al archivo pom.xml:

<!-- 服务注册到Eureka Server -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

Escribir un archivo de configuración

Agregue la siguiente configuración al archivo application.yml:

# 服务名
spring.application.name=provider-service
# 注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
# 关闭服务自己的注册
eureka.instance.instance-id=${spring.cloud.client.ip-address}:${server.port}
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

Clase de implementación de servicio de escritura

En la clase de implementación del servicio, agregue la anotación @Service para indicar que la clase es un Spring Bean y agregue la anotación @RequestMapping y la anotación @GetMapping a la clase para indicar la ruta de la URL y el método de solicitud de la interfaz del servicio, respectivamente.

@Service
@RequestMapping("/hello")
public class HelloServiceImpl implements HelloService {
    @Override
    @GetMapping
    public String hello() {
        return "Hello World!";
    }
}

servicio de registro

Agregue la anotación @EnableDiscoveryClient a la clase de inicio del servicio para indicar que el servicio es una instancia de Eureka Client y está registrado con Eureka Server.

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

5. Sirviendo a los consumidores—Consumidor

En la arquitectura de microservicios, la función principal del consumidor del servicio es llamar a la interfaz del servicio y procesar el resultado del servicio.

agregar dependencias

Agregue las siguientes dependencias al archivo pom.xml:

<!-- 使用Ribbon进行负载均衡 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
<!-- 使用Feign进行服务调用 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

Escribir un archivo de configuración

Agregue la siguiente configuración al archivo application.yml:

# 服务名
spring.application.name=consumer-service
# 注册中心地址
eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
# 使用Ribbon进行负载均衡
provider-service.ribbon.listOfServers=http://localhost:8081,http://localhost:8082
# 关闭服务自己的注册
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

Use RestTemplate para llamar al servicio

Cuando se llame al servicio, use RestTemplate para realizar una solicitud HTTP y especifique la ruta de URL del servicio.

@RestController
public class ConsumerController {
    @Autowired
    private RestTemplate restTemplate;
    @GetMapping("/hello")
    public String hello() {
        return restTemplate.getForObject("http://provider-service/hello", String.class);
    }
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Entre ellos, la anotación @LoadBalanced indica que se llama a varias instancias de proveedores de servicios mediante el equilibrio de carga.

Llamadas de servicio usando Fingir

Defina una interfaz de servicio y agregue la anotación @GetMapping al método para indicar la ruta de solicitud y el método de solicitud procesado por el método.

@FeignClient(name = "provider-service")
public interface HelloService {
    @GetMapping("/hello")
    String hello();
}

Cuando se llama al servicio, use @Autowire para inyectar la interfaz del servicio y llamar a los métodos que contiene.

@RestController
public class ConsumerController {
    @Autowired
    private HelloService helloService;
    @GetMapping("/hello")
    public String hello() {
        return helloService.hello();
    }
}

Seis, el uso de RestTemplate

RestTemplate es una plantilla de servicio RESTful simple que se puede usar para enviar solicitudes HTTP y procesar los resultados de la respuesta.

agregar dependencias

Agregue las siguientes dependencias al archivo pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

enviar solicitud HTTP

RestTemplate proporciona principalmente los siguientes métodos HTTP:

OBTENER: obtener recursos
POST: crear recurso
PUT: recurso de actualización
ELIMINAR: eliminar recurso

Envíe una solicitud GET y obtenga el resultado de la respuesta:

RestTemplate restTemplate = new RestTemplate();
String result = restTemplate.getForObject(url, String.class);

Envíe una solicitud POST y pase los parámetros:

RestTemplate restTemplate = new RestTemplate();
MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
params.add("name", "张三");
params.add("age", "20");

HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(params, headers);

String result = restTemplate.postForObject(url, requestEntity, String.class);

Manejar el resultado de la respuesta

RestTemplate puede convertir los resultados de las respuestas en varios tipos de objetos, como cadenas, matrices de bytes, flujos de entrada, objetos JSON, documentos XML, etc.

Obtenga la representación de cadena del resultado de la respuesta:

RestTemplate restTemplate = new RestTemplate();
String result = restTemplate.getForObject(url, String.class);

Obtenga la matriz de bytes del resultado de la respuesta:

RestTemplate restTemplate = new RestTemplate();
byte[] result = restTemplate.getForObject(url, byte[].class);

Obtenga el flujo de entrada del resultado de la respuesta:

RestTemplate restTemplate = new RestTemplate();
InputStream result = restTemplate.getForObject(url, InputStream.class);

Obtenga el objeto JSON del resultado de la respuesta:

RestTemplate restTemplate = new RestTemplate();
JSONObject result = restTemplate.getForObject(url, JSONObject.class);

Obtenga el documento XML del resultado de la respuesta:

RestTemplate restTemplate = new RestTemplate();
Document result = restTemplate.getForObject(url, Document.class);

Siete, el uso de la cinta

Ribbon es una biblioteca de interfaz de usuario popular, que proporciona diseños y controles de interfaz de usuario enriquecidos, que pueden ayudarnos a crear rápidamente interfaces modernas. Introduzcamos el uso de Ribbon:

Importar biblioteca de Ribbon: Ribbon se puede usar agregando la biblioteca de dependencias de Ribbon al proyecto. Por ejemplo, si usa Maven, puede agregar las siguientes dependencias en pom.xml:

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>ribbon</artifactId>
    <version>2.0.1</version>
</dependency>

Cree un control de cinta: la cinta contiene una variedad de controles, como botones, etiquetas, cuadros de texto, etc. Créelos agregando el código para el control Ribbon en el archivo de diseño XML. Por ejemplo, el siguiente código crea un control Ribbon con una etiqueta y un botón:

<ribbon:Ribbon>
    <ribbon:RibbonTab>
        <ribbon:RibbonGroup>
            <ribbon:RibbonLabel text="Hello, Ribbon!" />
            <ribbon:RibbonButton text="Click me!" />
        </ribbon:RibbonGroup>
    </ribbon:RibbonTab>
</ribbon:Ribbon>

Establezca el tema de la cinta: la cinta tiene una variedad de temas, puede cambiar la apariencia de la cinta configurando el tema. Por ejemplo, el siguiente código establece el tema de la cinta de opciones en "Office 2016":

<ribbon:Ribbon styleClass="office-2016">
    ...
</ribbon:Ribbon>

Manejo de eventos de la cinta: al igual que otras bibliotecas de la interfaz de usuario, los controles de la cinta también pueden desencadenar eventos. Por ejemplo, cuando se hace clic en un botón, se pueden realizar acciones relacionadas. Aquí hay un ejemplo de manejo de eventos de clic de botón:

RibbonButton button = ...; // 获取RibbonButton控件实例
button.setOnAction(event -> {
    
    
    // 处理按钮点击事件
});

Ocho, el uso de Fingir

Fingir es un cliente HTTP declarativo que facilita la escritura de clientes HTTP. Al usar Feign, solo necesitamos definir una interfaz y agregarle anotaciones, y Feign generará automáticamente la implementación para nosotros.

Estos son los pasos básicos para usar Fingir:

agregar dependencias

Agregue dependencias relacionadas con Fingir al proyecto, de la siguiente manera:

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

Crear interfaz de cliente de Fingir

Antes de usar Fingir, necesitamos crear una interfaz de cliente de Fingir. Agregue anotaciones a esta interfaz @FeignClientpara especificar el nombre del servicio:

@FeignClient(name = "service-name")
public interface ServiceClient {
    
    
    //...
}

En esta interfaz, podemos definir los métodos de interfaz de servicio que deben llamarse.

implementar el método de interfaz

Después de definir la interfaz de cliente de Fingir, debemos implementar los métodos en ella. El cliente de Feign generará una solicitud HTTP de acuerdo con la definición del método de interfaz y convertirá el resultado en el objeto que necesitamos.

@FeignClient(name = "service-name")
public interface ServiceClient {
    
    
    @GetMapping("/user/{id}")
    User getUserById(@PathVariable Long id);
}

En este ejemplo, definimos un getUserByIdmétodo de interfaz llamado , que GETobtiene la información del usuario de la identificación especificada a través de una solicitud HTTP.

Inyectar cliente Fingir

El último paso es inyectar el cliente de Feign en nuestro código para que podamos llamar al servicio a través de él. Mediante @Autowiredanotaciones, podemos inyectar el cliente de Feign en una clase de servicio:

@Service
public class UserService {
    
    
    @Autowired
    private ServiceClient serviceClient;
    
    public User getUserById(Long id) {
    
    
        return serviceClient.getUserById(id);
    }
}

En este ejemplo, inyectamos el cliente Feign en UserService y llamamos getUserByIdal método de interfaz en él.

9. Uso de Hystrix

Hystrix es una biblioteca para el manejo de fallas y latencia en sistemas distribuidos. Al construir un sistema distribuido, se deben considerar varias fallas y escenarios de falla. Hystrix proporciona una forma simple pero poderosa de manejar estos problemas al envolver cada llamada remota en un envoltorio que se puede romper, degradar y almacenar en caché.

Proteger su aplicación de fallas y retrasos es fácil con Hystrix. Proporciona un poderoso mecanismo de control para configurar, monitorear y administrar llamadas a dependencias remotas en la aplicación. Estos son algunos pasos para usar Hystrix:

Configurar Hystrix

Antes de usar Hystrix, se debe configurar Hystrix. Puede configurar Hystrix usando Spring Cloud Hystrix o escribiendo manualmente las clases de configuración de Hystrix.

Definir comandos de Hystrix

Al usar Hystrix, debe definir un comando Hystrix. Un comando Hystrix es un contenedor para realizar llamadas remotas. Puede envolver todas las llamadas remotas en comandos Hystrix.

Usa el comando Hystrix

Usar los comandos de Hystrix es muy simple. Solo necesita llamar al método de ejecución () del comando Hystrix, proporcionando parámetros si es necesario. Hystrix maneja automáticamente las situaciones de falla y latencia y devuelve los resultados apropiados.

Definir fusible Hystrix

Un disyuntor Hystrix es un mecanismo para desconectar automáticamente los servicios defectuosos o retrasados. Puede definir un disyuntor Hystrix para controlar las llamadas a las dependencias remotas. Si el número de llamadas supera un cierto umbral, Hystrix desconectará automáticamente la llamada y activará el fusible.

Monitorear Hystrix

Hystrix proporciona algunas herramientas de monitoreo que pueden ayudarlo a monitorear y administrar su aplicación. Puede usar Hystrix Dashboard para monitorear sus comandos e interruptores automáticos Hystrix y ver información detallada sobre cada comando e interruptor automático.

Capítulo 10 Uso de Zuul

Zuul es un marco de puerta de enlace de microservicios de código abierto de Netflix, que puede manejar una serie de problemas como el enrutamiento de solicitudes, el equilibrio de carga, la degradación del servicio y el interruptor de circuito. En la arquitectura de microservicios, Zuul se puede usar como un servicio de borde para controlar el acceso de los microservicios, y también se puede usar como una plataforma de administración de servicios centralizada para realizar una entrada unificada de servicios.

Al usar Zuul, primero debemos introducir las dependencias de Zuul en pom.xml:

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

@EnableZuulProxyA continuación, debemos usar anotaciones para habilitar la función de proxy de Zuul en la clase de inicio de la aplicación :

@SpringBootApplication
@EnableZuulProxy
public class GatewayApplication {
    
    

    public static void main(String[] args) {
    
    
        SpringApplication.run(GatewayApplication.class, args);
    }

}

Configurar las reglas de enrutamiento de Zuul es muy simple, solo agregue la siguiente configuración al archivo de configuración de la aplicación:

zuul:
  routes:
    service1:
      path: /service1/**
      serviceId: service1
    service2:
      path: /service2/**
      serviceId: service2

En este ejemplo, enrutamos las solicitudes con rutas de solicitud que comienzan con /service1/**y a los servicios denominados y respectivamente. El nombre de este servicio es el nombre registrado en el registro del servicio./service2/**service1service2

Zuul también admite algunas funciones avanzadas, como el equilibrio de carga del servicio, la degradación del servicio y el fusible. Podemos usar Ribbon para lograr el equilibrio de carga de los servicios e Hystrix para lograr la degradación y fusión del servicio. Para conocer el uso específico de estas funciones, consulte la documentación de Spring Cloud.