Este artículo ha participado en el evento "Ceremonia de creación de recién llegados" para comenzar juntos el camino de la creación de oro.
El aprendizaje y los materiales relacionados de todos los cursos son de los programadores de Dark Horse de la estación B. Gracias a los programadores de Dark Horse por su ayuda desinteresada a nuestros novatos, ¡gracias! ! ! Programador de Dark Horse-----yyds
@ [toc]
1. Consumidores de servicios y proveedores de servicios
Antes de comenzar, debemos comprender dos conceptos relativamente simples. Supongamos que hay tres servicios, a saber, el servicio A, el servicio B y el servicio C.
1. Decimos que los servicios que proporcionan interfaces para otros servicios se denominan proveedores de servicios. 2. Los servicios que utilizan otras interfaces de servicios se denominan consumidores de servicios. 3. Si un servicio es un consumidor o un proveedor es relativo a otro servicio.
Tome un ejemplo simple
Ahora hay una cadena de servicios: el servicio A llama al servicio B y el servicio B llama al servicio C. Entonces se puede concluir claramente que
- El servicio A es el consumidor del servicio.
- El servicio C es el proveedor de servicios.
- El servicio B es un proveedor de servicios en relación con el servicio A, y el servicio B es un consumidor de servicios en relación con el servicio C
2. Introducción y principio de Eureka
2.1 Problemas causados por la invocación remota de servicios
Recuerde lo que dije en la última nota, se puede ver que todos los mapeos de URL se implementan mediante codificación dura, es decir, cada URL debe escribirse en el código por parte del programador, y el servicio es menos aceptable, pero si el servicio está llegando a un entorno de clúster aterrador, depender solo de la mano de obra ya es una carga de trabajo muy grande y no es fácil de mantener, que también es uno de los problemas causados por las llamadas remotas.
Y la codificación dura también conducirá a otro. Dijimos que un microservicio no necesariamente tiene una sola instancia, al igual que una clase no puede tener solo una instancia, entonces algunas personas pueden preguntar, ¿no es una instancia muy buena? ¿No es más problemático de mantener?
Pero piénselo, ¿qué pasa si esta instancia de servicio se bloquea? ¿No significa que este servicio no puede proporcionar interfaces de servicio para otros servicios y luego dejar que los programadores emitan anuncios de actualización y esperen hasta la noche para reparar el servidor?
No bromees, ¿no es esto más agotador? Y la experiencia del usuario es extremadamente mala. Y múltiples instancias pueden prevenir tales emergencias para nosotros. Si la instancia 1 del servicio A se bloquea, pero todavía tenemos la instancia 2, aún podemos continuar. En este momento, podemos reparar la instancia cuando queramos. Además, varias instancias también pueden cumplir las condiciones del equilibrio de carga, lo que evita que una instancia esté sujeta a un exceso de solicitudes simultáneas y mejora la velocidad de respuesta.
Volviendo a nuestro tema, ¿qué tiene esto que ver con la codificación? Echemos un vistazo al código que escribimos.
你会发现我们把端口写死了，如果8081端口的实例挂了怎么办，我们又要去修改代码？我们又怎么做到多实例端口的读取呢？我们又要怎么监控知道哪个端口实例挂了？我们要怎么做到实例切换和负载均衡呢？
所有的这些问题，SpringCloud为我们提供了一个组件——Eureka，我们习惯地称它为注册中心。
2.2、Eureka的原理
1、首先我们要明白，Eureka是分为两种环境的，也就是Eureka-server（服务端），和 Eureka-client（客户端）
2、Eureka-server的作用：记录和管理这些服务及其实例
在SpringCloud里面引入了Eureka组件后，当user-service的每一个实例启动的时候，就会做一件事情：将自己的信息注册到Eureka-server上，Eureka记录名字和相关IP和端口
当然Eureka-server也会记录服务消费者的每一个实例信息，因为只要是微服务，都有可能在未来成为服务提供者。
那么这个时候，相对于服务消费者而言，现在我要获取服务提供者的相关IP和端口信息，那么这个时候，服务消费者就不会直接去找服务提供者索要，而是将请求信息发送给Eureka-server，问问它有没有我所需要的服务信息。如果Eureka-server上存在相关的服务实例信息，则将服务状态健康的发送给服务消费者。
那如果服务消费者发现Eureka-server给它的实例有多个，那它该挑哪一个进行访问呢？这个时候就需要用到负载均衡的原理来进行访问（轮询？随机？...）
那可能这个时候又有人问了，我访问的服务实会不会是已经挂掉的？ 其实并不会，因为对于每个属于Eureka-client的微服务实例而言，每一个实例都会隔一定的周期向Eureka-server发送心跳包（一般是30秒），以确保我自己还活着。
对于哪些已经挂掉的服务实例，那么Eureka就会将它从列表中剔除，这个时候服务消费者再次向Eureka-server拉取服务实例列表的时候，就不会获取到哪些已经挂掉的服务实例了。
最后，我们将上面遗留的问题解决一下：
三、Eureka服务环境搭建
在原有的大项目上再创建一个module项目，这个项目名字就叫eureka-server
找到我们新创建的eureka-server项目，点击里面的pom.xml 我们引入eureka-server的相关maven依赖
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
</dependencies>
复制代码第一次下载可能有点慢，耐心稍等一下。
创建相关包、文件和类
在==EurekaApplication.java==文件下写入如下代码，作为启动类
package cn.itcast.eureka;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
// 添加 @EnableEurekaServer 作为Eureka-server的开关
@EnableEurekaServer
@SpringBootApplication
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class,args);
}
}
复制代码在==eureka-server==的==application.yml==文件内加入下面内容
server:
port: 10086 # 服务的端口
spring:
application:
name: eurekaserver # 服务名称，也就是微服务的名称
freemarker:
prefer-file-system-access: false
eureka:
client:
fetch-registry: false # 是否从eureka-server上拉取服务信息
register-with-eureka: false # 是否将自己注册到eureka-server上，默认是true，为true是为了以后的eureka集群
service-url:
defaultZone: http://localhost:10086/eureka
复制代码好，那现在就可以启动我们的eureka-server服务了。
启动的eureka-server服务成功
接着在浏览器里面输入：localhost:10086 回车，我们就可以看到eureka的主页面了。
我们可以看到注册到eureka的实例是空列表，这个时候我们可以试试将eureka-server自己配置上去
修改下面的结果为true后重新运行，刷新页面就可以看到结果了
四、Eureka服务注册
服务注册和上面的eureka的注册功能类似，我们可以尝试将user-service与order-service注册上去
user-service的注册
进入它的==pom.xml==文件里面，加入下面的依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
复制代码进入它的==application.yml==文件，我们加入下面的信息
然后进入==UserApplication.java==文件
Lo mismo es cierto para la configuración de order-service, excepto que el nombre en el archivo application.yml en order-service debe cambiarse a: orderservcie
Actualice la lista de instancias de eureka y descubra que se ha registrado
Cinco, descubrimiento de servicios de Eureka
Queremos que el servicio de pedidos obtenga una lista de todas las instancias relevantes según el nombre de la aplicación del servicio de usuario.
Necesitamos configurar el contenido del servicio de usuario, que puede ejecutarse en múltiples instancias
Actualice el navegador para ver dos instancias
Ahora, el servicio de pedidos necesita acceder a los servicios de usuario de varias instancias, así que configure el equilibrio de carga para el servicio de pedidos , de la siguiente manera
Finalmente, necesitamos modificar la IP y el puerto que escribimos hasta la muerte, porque ahora todo el proceso lo toma eureka, solo necesitamos escribir el nombre del servicio registrado en eureka, el siguiente archivo
Vuelva a ejecutar el proyecto de servicio de pedidos
Abrimos un navegador, ahora volvemos a visitar la URL que anteriormente solicitaba los datos del pedido
Probemos un poco más
Del 101 al 106 vemos que los resultados son normales
De hecho, al observar los registros de acceso de estas seis veces, se puede ver que se ha accedido a cada instancia tres veces, por lo que se puede adivinar que el modo de equilibrio de carga predeterminado en springCloud es el sondeo.
Qué es exactamente lo que se debe mirar en el código fuente más adelante
Las notas eureka de este número están escritas aquí para animarnos unos a otros.
No es mucho dar tres seguidos, gracias~