1. ¿Qué es Spring Cloud Eureka?
Spring Cloud Eureka es parte de la suite de microservicios Spring Cloud Netflix, está encapsulado dos veces basado en Netflix Eureka y es el principal responsable de implementar la función de gobierno de servicios en la arquitectura de microservicios.
Spring Cloud Eureka es un servicio basado en REST y proporciona componentes de cliente basados en Java, que pueden registrar fácilmente servicios en Spring Cloud Eureka para una gestión unificada.
2. ¿Cuál es el principio de aplicación de Spring Cloud Eureka?
Para ilustrar con ejemplos de nuestras vidas :
En primer lugar, el sitio web de 12306 es como un centro de registro, y los clientes (consumo del servicio) son como el cliente que llama. Cuando necesiten tomar un tren, iniciarán sesión en el sitio web de 12306 para verificar los boletos restantes y podrán comprar boletos si los tienen, y luego obtener el número de trenes, tiempo, etc., y finalmente partir.
Lo mismo ocurre con el programa. Cuando necesite llamar a un servicio, primero irá a Eureka para obtener la lista de servicios, verificar si el servicio al que está llamando está en ella y, si lo está, obtener la dirección del servicio, el puerto y otra información, y luego llamarlo.
La ventaja del centro de registro es que no necesita saber cuántos proveedores hay, solo debe prestar atención al centro de registro, al igual que a los clientes no les debe importar cuántos trenes están circulando, solo deben ir a el sitio web 12306 para ver si hay boletos.
3. Sobre la versión Eureka y la versión SpringBoot en SpringCloud.
Nota : ¡La versión utilizada aquí debe ser la misma, la versión de Eureka a la izquierda es la versión de springboot a la derecha! ! !
4. Implementación del código
Estructura del proyecto : proyecto principal maven + 3 proyectos de submódulos de arranque de primavera
(1) Use Eureka para escribir un servicio de registro:
Paso 1: cree un proyecto Springboot vacío (sin importar ninguna dependencia predeterminada) y asígnele el nombreeureka-server .
Paso 2: importar dependencias.
<!-- springboot 版本2.0.6.RELEASE -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!-- eureka注册中心服务 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
<!-- Spring Cloud Eureka 版本 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Finchley.SR2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
Paso 3: Configure las propiedades de la aplicación.
spring.application.name=eureka-server
server.port=8761
# 由于该应用为注册中心, 所以设置为false, 代表不向注册中心注册自己,(生产者配置为true)
eureka.client.register-with-eureka=false
# 由于注册中心的职责就是维护服务实例, 它并不需要去检索服务, 所以也设置为 false(消费者配置为true)
eureka.client.fetch-registry=false
Paso 4: Inicie la clase para agregar @EnableEurekaServeranotaciones .
@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServerApplication.class, args);
}
}
Paso 5: Inicie el servicio de registro.
Use un navegador para acceder: http://localhost:8761El número de puerto aquí se configura en el archivo de configuración en el tercer paso.
Aparece la imagen de arriba, lo que indica que la configuración del centro de registro se ha realizado correctamente.
(2) Escriba un servicio de productor usando Eureka:
Paso 1: Cree un proyecto Springboot vacío y asígnele el nombreeureka-client-user-service .
Paso 2: importar dependencias.
<!-- springboot 版本2.0.6.RELEASE -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!-- springboot web依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- eureka客户端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!-- Spring Cloud Eureka 版本 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Finchley.SR2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
Paso 3: Configure las propiedades de la aplicación.
spring.application.name= eureka-client-user-service
server.port=8085
#eureka.client.serviceUrl.defaultZone 的地址就是我们之前启动的 Eureka 服务的地址，
# 在启动的时候需要将自身的信息注册到 Eureka 中去。
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/
# 采用IP注册
eureka.instance.preferIpAddress=true
# 定义实例ID格式
eureka.instance.instance-id=${
spring.application.name}:${
spring.cloud.client.ip-address}:${
server.port}
Paso 4: Comience la clase para agregar @EnableEurekaServeranotaciones.
package com.hdit.eurekaclientuserservice;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@SpringBootApplication
@EnableDiscoveryClient
public class EurekaClientUserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaClientUserServiceApplication.class, args);
}
}
Paso 5: escribir pruebas de controlador.
package com.hdit.eurekaclientuserservice.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class UserController {
@GetMapping("/user/hello")
public String hello() {
return "hello，我是生产服务!!!!";
}
}
Paso 6: Inicie la clase de prueba, use el navegador para acceder al servicio del productor, ¡pruebehttp://localhost:8085/user/hello !
El resultado es el siguiente:
En este momento visitamos la página de administración Web que viene con Eureka, la cual nos conviene para consultar la información de la instancia registrada anteriormente, y podemos ver un cliente más.
¡El servicio del productor se ha escrito con éxito hasta ahora!
(3) Escriba un servicio al consumidor usando Eureka:
Paso 1: Cree un proyecto Springboot vacío y asígnele el nombreeureka-client-article-service .
Paso 2: importar dependencias.
<!-- springboot 版本2.0.6.RELEASE -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!-- springboot web依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- eureka客户端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<!-- Spring Cloud Eureka 版本 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Finchley.SR2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
Paso 3: Configure las propiedades de la aplicación.
spring.application.name=eureka-client-article-service
server.port=8086
Paso 4: Cree una clase de configuración para instanciar unorestTemplate .
package com.hdit.eurekaclientarticleservice.config;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class BeanConfiguration {
@Bean
@LoadBalanced
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}
Paso 5: escribir pruebas de controlador.
package com.hdit.eurekaclientarticleservice.controller;
import com.netflix.discovery.converters.Auto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
@RestController
public class ArticleController {
//注入配置的restTemplate
@Autowired
private RestTemplate restTemplate;
//服务消费者
@GetMapping("/article/callHello")
public String callHello() {
// 1）直接调用接口
return restTemplate.getForObject("http://localhost:8085/user/hello", String.class);
}
//服务消费者
@GetMapping("/article/callHello2")
public String callHello2() {
// 2）通过 Eureka 来消费接口,restTemplate配置类前面需要添加 @LoadBalanced
return restTemplate.getForObject("http://eureka-client-user-service/user/hello", String.class);
}
}
Paso 6: Inicie la clase de prueba, use el navegador para acceder al servicio al consumidor, ¡pruebe http://localhost:8086/article/callHello2!
El resultado es el siguiente: ¡El
servicio al consumidor se ha escrito con éxito!
Mirando de nuevo el registro de servicios de Eureka, encontrará dos clientes más, ¡un consumidor de servicios y un productor de servicios!
