Tabla de contenido
1. Comprender los microservicios
2. División de servicios y llamadas remotas
2.1 Principios de división de servicios
2.2 Ejemplo de división de servicios
2.2.2 Importar proyecto de demostración
2.3 Realizar el caso de llamada remota
2.4 Proveedores y consumidores
3. Centro de registro de Eureka
3.1 La estructura y función de Eureka
3.2 Construir el servidor eureka
3.2.1 Crear servicio de servidor eureka
3.2.2 Introducir la dependencia de eureka
3.2.3 Clase de inicio de escritura
3.2.4 Escritura de archivos de configuración
3) Iniciar múltiples instancias de servicio de usuario
3.4 Descubrimiento de servicios
3) Servicio de extracción y balanceo de carga
1. Comprender los microservicios
Con el desarrollo de la industria de Internet, los requisitos para los servicios son cada vez más altos, y la arquitectura del servicio ha evolucionado gradualmente de una arquitectura única a la ahora popular arquitectura de microservicios. ¿Cuál es la diferencia entre estas arquitecturas?
1.0 Objetivos de aprendizaje
Comprender los pros y los contras de la arquitectura de microservicios
1.1 Arquitectura monolítica
Arquitectura monolítica : todas las funciones del negocio se desarrollan en un proyecto y se empaquetan en un solo paquete para su implementación.
Las ventajas y desventajas de la arquitectura monolítica son las siguientes:
ventaja:
- estructura simple
- Bajo costo de implementación
defecto:
- Alto grado de acoplamiento (difícil de mantener y actualizar)
1.2 Arquitectura distribuida
Arquitectura distribuida : el sistema se divide según las funciones comerciales y cada módulo de funciones comerciales se desarrolla como un proyecto independiente, denominado servicio.
Ventajas y desventajas de la arquitectura distribuida:
ventaja:
- Reducir el acoplamiento de servicios
- Propicio para la actualización y expansión del servicio
defecto:
- La relación de la llamada de servicio es compleja
Aunque la arquitectura distribuida reduce el acoplamiento de servicios, todavía hay muchos problemas a considerar al dividir los servicios:
- ¿Cómo definir la granularidad de la división del servicio?
- ¿Cómo llamar entre servicios?
- ¿Cómo gestionar la relación de invocación de servicio?
La gente necesita desarrollar un conjunto de estándares efectivos para restringir la arquitectura distribuida.
1.3 Microservicios
Características arquitectónicas de los microservicios:
- Responsabilidad única: la granularidad de la división de microservicios es más pequeña y cada servicio corresponde a una capacidad comercial única, para lograr una responsabilidad única
- Autonomía: equipo independiente, tecnología independiente, datos independientes, implementación y entrega independientes
- Orientado a servicios: los servicios proporcionan una interfaz estándar unificada, independiente del idioma y la tecnología.
- Fuerte aislamiento: las llamadas de servicio son aisladas, tolerantes a fallas y degradadas para evitar problemas en cascada
Las características anteriores de los microservicios en realidad están estableciendo un estándar para la arquitectura distribuida, reduciendo aún más el acoplamiento entre servicios y brindando independencia y flexibilidad a los servicios. Lograr alta cohesión y bajo acoplamiento.
Por lo tanto, los microservicios se pueden considerar como una solución de arquitectura distribuida con una arquitectura bien diseñada .
Pero, ¿cómo se debe implementar el plan? ¿Qué pila tecnológica elegir? Las empresas de Internet de todo el mundo están probando activamente sus propias soluciones de implementación de microservicios.
Entre ellos, el más llamativo en el campo de Java es la solución proporcionada por Spring Cloud.
1.4.SpringCloud
SpringCloud es actualmente el marco de microservicios más utilizado en China. Dirección del sitio web oficial: Spring Cloud .
SpringCloud integra varios componentes funcionales de microservicios y realiza el ensamblaje automático de estos componentes en función de SpringBoot, lo que brinda una buena experiencia lista para usar.
Los componentes comunes incluyen:
Además, la capa inferior de SpringCloud depende de SpringBoot y tiene una relación de compatibilidad de versiones, de la siguiente manera:
1.5 Resumen
- Arquitectura monolítica: simple y conveniente, altamente acoplada, poca escalabilidad, adecuada para proyectos pequeños. Ejemplo: Sistema de Gestión de Estudiantes
- Arquitectura distribuida: débilmente acoplada y escalable, pero compleja y difícil. Adecuado para proyectos de Internet a gran escala, como JD.com y Taobao
- Microservicios: una buena solución de arquitectura distribuida
①Ventajas: granularidad dividida más pequeña, más servicios independientes y menor acoplamiento
②Desventajas: la estructura es muy compleja y aumenta la dificultad de operación y mantenimiento, monitoreo e implementación
- SpringCloud es una solución integral para la arquitectura de microservicios, que integra varios componentes funcionales de microservicios excelentes
2. División de servicios y llamadas remotas
Cualquier arquitectura distribuida es inseparable de la división de servicios, y lo mismo ocurre con los microservicios.
2.1 Principios de división de servicios
Aquí resumo varios principios a la hora de dividir microservicios:
- Diferentes microservicios, no desarrolles el mismo negocio repetidamente
- Los datos del microservicio son independientes, no acceda a la base de datos de otros microservicios
- Los microservicios pueden exponer su negocio como interfaces para que otros microservicios llamen
-
2.2 Ejemplo de división de servicios
Tomando como ejemplo la demostración en la nube del microservicio en los materiales de la clase previa, su estructura es la siguiente:
cloud-demo: proyecto principal, administrar dependencias
- order-service: microservicio de pedidos, responsable del negocio relacionado con los pedidos
- servicio de usuario: microservicio de usuario, responsable del negocio relacionado con el usuario
Requerir:
- Tanto el microservicio de pedidos como el microservicio de usuarios deben tener sus propias bases de datos, independientes entre sí.
- Tanto el servicio de pedidos como el servicio de usuario exponen las interfaces Restful al mundo exterior
- Si el servicio de pedidos necesita consultar la información del usuario, solo puede llamar a la interfaz Restful del servicio del usuario y no puede consultar la base de datos del usuario.
2.2.1 Importar sentencia Sql
Cree la biblioteca de orden cloud_order la biblioteca de usuario cloud_user en mysql respectivamente, e importe cloud-order.sql y cloud-user.sql en mysql:
Los datos iniciales en la tabla de usuarios de la nube son los siguientes:
Los datos iniciales en la tabla de orden de nubes son los siguientes:
La tabla de pedidos en la nube contiene el campo id en la tabla de usuarios en la nube.
2.2.2 Importar proyecto de demostración
Importar demostración con IDEA:
La estructura del proyecto es la siguiente:
Un menú como este se utilizará más adelante:
Puedes usar Alt + 8
Configure el JDK utilizado por los siguientes proyectos:
2.3 Realizar el caso de llamada remota
En el servicio de servicio de pedidos, existe una interfaz para consultar pedidos por id:
Consulta el pedido según el id, y el valor devuelto es un objeto Pedido, como se muestra en la figura:
donde el usuario es nulo
En el servicio de usuario, hay una interfaz para consultar a los usuarios por ID:
El resultado de la consulta se muestra en la figura:
2.3.1 Requisitos del caso:
Modifique el servicio de consulta de pedidos por id en el servicio de pedidos, lo que requiere que la información del usuario se consulte de acuerdo con el ID de usuario contenido en el pedido al consultar el pedido y se devuelvan juntos.
Por lo tanto, debemos iniciar una solicitud http al servicio de usuario en el servicio de pedido y llamar a la interfaz http://localhost:8081/user/ {userId}.
Los pasos aproximados son los siguientes:
- Registre una instancia de RestTemplate en el contenedor Spring
- Modifique el método queryOrderById en la clase OrderService en el servicio de servicio de pedidos y consulte al Usuario de acuerdo con el ID de usuario en el objeto Pedido.
- Complete el Usuario consultado en el objeto Pedido y devuélvalo juntos
2.3.2 Registrar RestTemplate
Primero, registramos la instancia de RestTemplate en la clase de inicio OrderApplication en el servicio de servicio de pedidos:
package cn.itcast.order;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;
@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
}2.3.3 Realizar llamada remota
Modifique el método queryOrderById en la clase OrderService en el paquete cn.itcast.order.service en el servicio de servicio de pedidos:
2.4 Proveedores y consumidores
En la relación de invocación de servicio, hay dos roles diferentes:
Proveedor de servicios : un servicio llamado por otros microservicios en una empresa. (Proporcionar interfaces a otros microservicios)
Consumidor de servicios : un servicio que llama a otros microservicios en una empresa. (interfaces de llamadas proporcionadas por otros microservicios)
Sin embargo, los roles de los proveedores de servicios y los consumidores de servicios no son absolutos, sino relativos al negocio.
Si el servicio A llama al servicio B y el servicio B llama al servicio C, ¿cuál es el papel del servicio B?
- Para el negocio de A llamando a B: A es un consumidor de servicios, B es un proveedor de servicios
- Para el negocio donde B llama a C: B es un consumidor de servicios y C es un proveedor de servicios
Por lo tanto, el servicio B puede ser tanto un proveedor de servicios como un consumidor de servicios.
3. Centro de registro de Eureka
Supongamos que nuestro servicio de usuario del proveedor de servicios implementa varias instancias, como se muestra en la figura:
Pensemos en algunas preguntas:
- Cuando el servicio de pedidos inicia una llamada remota, ¿cómo sabe la dirección IP y el puerto de la instancia de servicio de usuario?
- Hay varias direcciones de instancia de servicio de usuario, ¿cómo elegir al llamar al servicio de pedido?
- ¿Cómo sabe order-service si una determinada instancia de servicio de usuario todavía está en buen estado o no?
3.1 La estructura y función de Eureka
Estos problemas deben resolverse utilizando el centro de registro en SpringCloud.El centro de registro más conocido es Eureka, y su estructura es la siguiente:
Contesta las preguntas anteriores.
Pregunta 1: ¿Cómo sabe order-service la dirección de la instancia de user-service?
El proceso de obtención de la información de la dirección es el siguiente:
- Después de iniciar la instancia de servicio de servicio de usuario, registre su propia información con eureka-server (servidor Eureka). Esto se llama registro de servicio.
- eureka-server guarda la relación de mapeo entre el nombre del servicio y la lista de direcciones de la instancia del servicio
- order-service extrae la lista de direcciones de la instancia según el nombre del servicio. Esto se llama descubrimiento de servicios o extracción de servicios.
Pregunta 2: ¿Cómo selecciona el servicio de pedidos una instancia específica de varias instancias de servicio de usuario?
- order-service selecciona una dirección de instancia de la lista de instancias utilizando el algoritmo de equilibrio de carga
- Iniciar una llamada remota a la dirección de la instancia
Pregunta 3: ¿Cómo sabe el servicio de pedidos si una determinada instancia de servicio de usuario todavía está en buen estado o está inactiva?
- El servicio de usuario iniciará una solicitud al servidor eureka de vez en cuando (predeterminado 30 segundos) para informar su propio estado, que se llama latido del corazón
- Cuando no se envía ningún latido durante más de un cierto período de tiempo, eureka-server considerará que la instancia de microservicio es defectuosa y la eliminará de la lista de servicios.
- Cuando el servicio de pedidos extrae el servicio, se puede descartar la instancia defectuosa
Nota: un microservicio puede ser tanto un proveedor de servicios como un consumidor de servicios, por lo que eureka encapsula funciones como el registro de servicios y el descubrimiento de servicios en el cliente eureka.
Entonces, nuestros próximos pasos prácticos incluyen:
3.2 Construir el servidor eureka
En primer lugar, todos registran el servidor del centro: eureka-server, que debe ser un microservicio independiente
3.2.1 Crear servicio de servidor eureka
En el proyecto principal de demostración en la nube, cree un submódulo:
Complete la información del módulo:
Crear eureka:
3.2.2 Introducir la dependencia de eureka
Presente la dependencia inicial proporcionada por SpringCloud para eureka:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>3.2.3 Clase de inicio de escritura
Para escribir una clase de inicio para el servicio del servidor eureka, asegúrese de agregar una anotación @EnableEurekaServer para habilitar la función del centro de registro de eureka:
package com.itheima;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class, args);
}
}3.2.4 Escritura de archivos de configuración
Escriba un archivo application.yml con el siguiente contenido:
server:
port: 10086
spring:
application:
name: eurekaservice
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka/3.2.5 Iniciar servicio
Inicie el microservicio y luego visítelo en el navegador: http://127.0.0.1:10086
Ver el siguiente resultado debe ser exitoso:
3.3 Registro del Servicio
A continuación, registramos el servicio de usuario en eureka-server.
1) Introducir dependencias
En el archivo pom del servicio de usuario, introduzca las siguientes dependencias del cliente eureka:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>2) archivo de configuración
En el servicio de usuario, modifique el archivo application.yml y agregue el nombre del servicio y la dirección eureka:
spring:
application:
name: userservice
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka3) Iniciar múltiples instancias de servicio de usuario
Para demostrar un escenario en el que un servicio tiene varias instancias, agregamos una configuración de inicio de SpringBoot e iniciamos un servicio de usuario.
Primero, copie la configuración de inicio del servicio de usuario original:
Luego, en la ventana emergente, complete la información:
Ahora, aparecerán dos configuraciones de inicio de servicio de usuario en la ventana de SpringBoot:
Sin embargo, el primero es el puerto 8081 y el segundo es el puerto 8082.
Inicie dos instancias de servicio de usuario:
Ver la página de administración del servidor eureka:
3.4 Descubrimiento de servicios
A continuación, modificamos la lógica del servicio de pedidos: extraiga la información del servicio de usuario del servidor eureka para realizar el descubrimiento del servicio.
1) Introducir dependencias
Como se mencionó anteriormente, el descubrimiento de servicios y el registro de servicios están encapsulados en dependencias de cliente eureka, por lo que este paso es coherente con el registro de servicios.
En el archivo pom de order-service, introduzca las siguientes dependencias de eureka-client:
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>2) archivo de configuración
El descubrimiento de servicios también necesita conocer la dirección eureka, por lo que el segundo paso es coherente con el registro del servicio, que consiste en configurar la información eureka:
En order-service, modifique el archivo application.yml y agregue el nombre del servicio y la dirección eureka:
spring:
application:
name: orderservice
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka3) Servicio de extracción y balanceo de carga
Finalmente, extraeremos la lista de instancias del servicio de servicio de usuario de eureka-server e implementaremos el equilibrio de carga.
Pero no necesitamos hacer estas acciones, solo necesitamos agregar algunas anotaciones.
En OrderApplication de order-service, agregue una anotación @LoadBalanced al Bean RestTemplate:
Modifique el método queryOrderById en la clase OrderService en el paquete cn.itcast.order.service en el servicio de servicio de pedidos. Modifique la ruta de la URL para acceder y use el nombre del servicio en lugar de la ip y el puerto:
@RestController
@RequestMapping("order")
public class OrderController {
@Autowired
private OrderService orderService;
@Autowired
private RestTemplate restTemplate;
@GetMapping("{orderId}")
public Order queryOrderByUserId(@PathVariable("orderId") Long orderId) {
// 根据id查询订单并返回
Order order = orderService.queryOrderById(orderId);
// 根据订单关联的用户id远程查询用户信息
Long userId = order.getUserId(); // 服务名称
User user = restTemplate.getForObject("http://userservice/user/" + userId, User.class);
order.setUser(user);
return order;
}
}Spring nos ayudará automáticamente a obtener la lista de instancias del lado del servidor eureka de acuerdo con el nombre del servicio userservice, y luego completará el equilibrio de carga.