Estuche de entrada Springcloud

Introducción

Spring Cloud es uno de los proyectos de Spring, dirección del sitio web oficial: http://projects.spring.io/spring-cloud/
Spring es mejor en la integración, tomando el mejor marco del mundo e integrándolo en su propio proyecto.
Spring Cloud es lo mismo. Integra algunas de las tecnologías que ahora son muy populares para lograr como:Gestión de la configuración, descubrimiento de servicios, enrutamiento inteligente, equilibrio de carga, fusibles, bus de control, estado del clústerY así.
Los principales componentes involucrados incluyen:
Netflix

• Eureka: Centro de registro
• Zuul: puerta de enlace de servicio
• Cinta: equilibrio de carga
• Fingir: llamada de servicio
• Hystrix: fusible
• y muchos más

versión

Correspondencia de las versiones Spring Clound y Spring Boot

Tren de lanzamiento	Versión de arranque
Hoxton	2.2.x
Greenwich	2.1.x
Finchley	2.0.x
Edgware	1.5.x
Dalston	1.5.x

Crear proyecto principal

En los microservicios, se deben crear varios proyectos al mismo tiempo. Primero, crea un proyecto principal. Los proyectos posteriores usan este proyecto como principal, mediante la agregación y herencia de Maven. Gestión unificada de la versión y configuración de subproyectos

<!--聚合父工程-->
<packaging>pom</packaging>

<parent> 
	<groupId>org.springframework.boot</groupId> 
	<artifactId>spring-boot-starter-parent</artifactId> 
	<version>2.1.5.RELEASE</version> 
	<packaging>pom</packaging>
	<relativePath/> 
</parent>

<!--这里指定版本信息-->
<properties> 
	<java.version>1.8</java.version> 
	<spring-cloud.version>Greenwich.SR1</spring-cloud.version> 
	<mapper.starter.version>2.1.5</mapper.starter.version> 
	<mysql.version>5.1.46</mysql.version> 
</properties>

<dependencyManagement> 
	<dependencies>
		<!-- springCloud --> 
		<dependency> 
			<groupId>org.springframework.cloud</groupId> 
			<artifactId>spring-cloud-dependencies</artifactId> 
			<version>${spring-cloud.version}</version> 
			<type>pom</type> 
			<!--这里的import一定要记得加上，不然子工程报错-->
			<scope>import</scope> 
		</dependency>
		<!-- 通用Mapper启动器 --> 
		<dependency> 
			<groupId>tk.mybatis</groupId> 
			<artifactId>mapper-spring-boot-starter</artifactId> 
			<version>${mapper.starter.version}</version> 
		</dependency>
		<!-- mysql驱动 --> 
		<dependency> 
			<groupId>mysql</groupId> 
			<artifactId>mysql-connector-java</artifactId> 
			<version>${mysql.version}</version> 
		</dependency>
	</dependencies>
</dependencyManagement>

<!--lombok简化代码-->
<dependencies> 
	<dependency> 
		<groupId>org.projectlombok</groupId> 
		<artifactId>lombok</artifactId> 
	</dependency> 
</dependencies>

<build> 
	<plugins> 
		<plugin> 
			<groupId>org.springframework.boot</groupId> 
			<artifactId>spring-boot-maven-plugin</artifactId> 
		</plugin> 
	</plugins> 
</build>

Subproyecto

El número de versión es administrado por el proyecto principal de manera unificada. No es necesario agregar un número de versión al subproyecto, simplemente introduzca las dependencias

En microservicios, necesitamos productores y consumidores de servicios

Servicio web estilo REST

@RestController// 声明它是一个rest风格的控制器
@RequestMapping("/user")
@RefreshScope// 配置文件改变自动刷新属性
public class UserController {
    
    
	// 注入service层
    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User queryById(@PathVariable Long id){
    
    
        return userService.queryById(id);
    }
}

Iniciador para microservicios

@SpringBootApplication

@SpringBootApplication para marcar esta es una aplicación springboot, la clase marcada es un programa principal, SpringApplication.run (App.class, args); la clase App.class pasada debe ser la clase marcada por @SpringBootApplication. P.ej:

@SpringBootApplication 
public class ConsumerApplication {
    
     

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

@SpringBootApplication es una anotación de combinación, su función es equivalente a la combinación de las siguientes anotaciones:
1. Clase de configuración @SprootbootConfiguration (o @Configuration), correspondiente al archivo de configuración, esencialmente un @Componet, pero más significativo, vea el nombre sabe el significado
2. @EnableAutoConfiguration: active la configuración automática, escanee todas las anotaciones del paquete donde se encuentra la clase de configuración principal y todos los paquetes descendientes debajo de
3. @ComponentScan: Configure el paquete que se escaneará

@SpringBootConfiguration

Esta anotación tiene la misma función que @Configuration, que se usa para declarar que la clase actual es una clase de configuración. Puede generar beans gestionados por contenedores IOC a través de la anotación @Bean. Defina el bean en ConsumerApplication e inyecte ConsumerApplication en UserController
:

@SpringBootApplication
public class ConsumerApplication {
    
    

	public static void  main(String[]args){
    
    
		SpringApplication.run(ConsumerApplication.class,args);
	}
	
	@Bean
    public RestTemplate restTemplate(){
    
    
        return new RestTemplate();
    }
}

UserController:

@RestController
public class UserController {
    
    
	@Autowired
    private RestTemplate restTemplate;
    
    @GetMapping("/{id}")
    public User queryById(@PathVariable Long id){
    
    
		String url = "http://localhost:9091/user/" + id;
		return restTemplate.getForObject(url, User.class);
    }
}

@EnableAutoConfiguration

@EnableAutoConfiguration es la anotación principal para que Springboot realice la configuración automática.A través de esta anotación, los beans requeridos por la aplicación Spring se inyectan en el contenedor. El código fuente @EnableAutoConfiguration inyecta una clase de implementación de ImportSelector AutoConfigurationImportSelector a través de @Import

@Import({
    
    AutoConfigurationImportSelector.class})

AutoConfigurationImportSelector, este ImportSelector finalmente se da cuenta de cargar dinámicamente los beans requeridos de acuerdo con nuestra configuración.
El código fuente de AutoConfigurationImportSelector para completar el método de implementación de carga dinámica es el siguiente:

// annotationMetadata 是@Import所在的注解，这里指定是EnableAutoConfiguration
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    
    
	if (!this.isEnabled(annotationMetadata)) {
    
    
		return NO_IMPORTS;
	} else {
    
    
		try {
    
    
			//加载XXConfiguration的元数据信息（包含了某些类被生成bean条件），继续跟进这个方法调用，就会发现加载的是：spring-boot-autoconfigure　jar包里面META-INF的spring-autoconfigure-metadata.properties
			AutoConfigurationMetadata autoConfigurationMetadata 
				= AutoConfigurationMetadataLoader
						.loadMetadata(this.beanClassLoader);
			 //获取注解里设置的属性，在＠SpringBootApplication设置的exclude,excludeＮame属性值，其实就是设置＠EnableAutoConfiguration的这两个属性值
			AnnotationAttributes attributes 
				= this.getAttributes(annotationMetadata);
			//从spring-boot-autoconfigure　jar包里面META-INF/spring.factories加载配置类的名称，打开这个文件发现里面包含了springboot框架提供的所有配置类
			List<String> configurations 
				= this.getCandidateConfigurations(
						annotationMetadata, 
						attributes);
			//去掉重复项
			configurations = this.removeDuplicates(configurations);
			
			configurations = this.sort(
					configurations, 
					autoConfigurationMetadata);
			//获取自己配置不需要生成bean的class
			Set<String> exclusions = this.getExclusions(
					annotationMetadata, 
					attributes);
			//校验被exclude的类是否都是springboot自动化配置里的类，如果存在抛出异常
			this.checkExcludedClasses(configurations, exclusions);
			//删除被exclude掉的类
			configurations.removeAll(exclusions);
			//过滤刷选，满足OnClassCondition的类
			configurations = this.filter(
					configurations, 
					autoConfigurationMetadata);

			this.fireAutoConfigurationImportEvents(
					configurations, 
					exclusions);
			//返回需要注入的bean的类路径
			return StringUtils.toStringArray(configurations);
		} catch (IOException var6) {
    
    
			throw new IllegalStateException(var6);
		}
	}
}

@ComponenteScan

Aquellos que han utilizado el marco de primavera saben que hay cuatro anotaciones principales en la primavera:

• @Servicio,
• @Repositorio,
• @Componente,
• @Controller se
  usa para definir un bean. La anotación @ComponentScan se usa para escanear automáticamente las clases identificadas por estas anotaciones, y finalmente generar beans en el contenedor ioc. Puede determinar dinámicamente el alcance del análisis automático estableciendo los atributos @ComponentScan basePackages, includeFilters y excludeFilters, y los tipos no se analizan. De forma predeterminada: analiza todos los tipos y el alcance del análisis es la clase del paquete de configuración y los subpaquetes donde se encuentra la anotación @ComponentScan.

Clase de herramienta de plantilla RestTemplate

Spring proporciona una clase de herramienta de plantilla RestTemplate, que encapsula el cliente basado en HTTP y realiza la serialización y deserialización de objetos y json, lo cual es muy conveniente. RestTemplate no limita el tipo de cliente HTTP, pero lo abstrae. Actualmente, se admiten 3 tipos de uso común:

• HTTPClient
• OkHTTP
• URLConnection nativo de JDK (predeterminado)
  ConsumerApplication:

@SpringBootApplication 
public class ConsumerApplication {
    
    

	public static void main(String[] args) {
    
     
		SpringApplication.run(ConsumerApplication.class, args); 
	}
	
	@Bean 
	public RestTemplate restTemplate(){
    
     
		return new RestTemplate(); 
	} 
}

UserController:

@RestController
public class UserController {
    
    
	@Autowired
    private RestTemplate restTemplate;
    
    @GetMapping("/{id}")
    public User queryById(@PathVariable Long id){
    
    
		String url = "http://localhost:9091/user/" + id;
		return restTemplate.getForObject(url, User.class);
    }
}

Registro Eureka

Pensando

El servicio de usuario proporciona servicios externamente y necesita exponer su dirección externamente. El consumidor (persona que llama) debe registrar la dirección del proveedor de servicios. Si la dirección cambia en el futuro, debe actualizarse a tiempo. Esto no parece importar cuando hay menos servicios, pero en el entorno de Internet cada vez más complejo de hoy, un proyecto definitivamente dividirá una docena o incluso docenas de microservicios. En este momento, si aún administra la dirección manualmente, no solo será difícil de desarrollar, sino que será muy problemático probarlo y lanzarlo en el futuro, lo que es contrario a la idea de DevOps.

Diagrama de arquitectura

Eureka: Es el centro de registro de servicios (puede ser un clúster), que expone su
proveedor de direcciones : Después del inicio, registre su información (dirección, qué servicio prestar) con Eureka, que puede ser una aplicación Spring Boot o cualquier otra implementación técnica. Siempre que brinde servicios de estilo REST al mundo exterior.
Consumidor: suscríbase al servicio Eureka, Eureka enviará la lista de direcciones de todos los proveedores del servicio correspondiente al consumidor y la actualizará periódicamente.
Heartbeat (renovación): El proveedor actualiza periódicamente su estado en Eureka a través de HTTP

Construir

Eureka es un centro de registro de servicios, que solo realiza el registro de servicios, no brinda ni consume servicios. Eureka se puede usar para construir un proyecto web, o Spring Boot se puede usar para construirlo.

registro eureka

Servidor

Agregar dependencia

<!-- Eureka服务端 -->
<dependency> 
	<groupId>org.springframework.cloud</groupId> 
	<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> 
</dependency> 

Comenzar la clase

@EnableEurekaServer //声明当前应用时Eureka服务 
@SpringBootApplication 
public class EurekaServerApplication {
    
     
	public static void main(String[] args) {
    
    
		SpringApplication.run(EurekaServerApplication.class, args); 
	} 
}

Archivo de configuración

# 指定端口号
server.port=10086

# 给服务起个名字
spring.application.name=eureka-sevver

# eureka 服务地址，如果是集群的话；需要指定其它集群eureka地址
eureka.client.service-url.defaultZone=http://127.0.0.1:10086/eureka
# 不注册自己
eureka.client.register-with-eureka=false
# 不拉取服务
eureka.client.fetch-registry=false

Registro de cliente

Agregue la dependencia del cliente de Eureka en la demostración del consumidor del proyecto de consumo del servicio; puede usar la clase de herramienta DiscoveryClient para obtener la lista de direcciones del servicio correspondiente según el nombre del servicio.

Agregar dependencia

<!-- Eureka客户端 --> 
<dependency> 
	<groupId>org.springframework.cloud</groupId> 
	<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> 
</dependency>

Comenzar la clase

@SpringBootApplication 
@EnableDiscoveryClient // 开启Eureka客户端 
public class UserConsumerDemoApplication {
    
     

	public static void main(String[] args) {
    
     
		SpringApplication.run(UserConsumerDemoApplication.class, args); 
	}
	
	@Bean 
	public RestTemplate restTemplate() {
    
     
		return new RestTemplate(); 	
	}
	
}

Archivo de configuración

# 给服务起个名字
spring.application.name=consumer-demo

# eureka服务地址
eureka.client.service-url.defaultZone=http://127.0.0.1:10086/eureka

Modifica el código

@RestController
public class UserController {
    
    
	@Autowired
    private RestTemplate restTemplate;
    
    @GetMapping("/{id}")
    public User queryById(@PathVariable Long id){
    
    
		// String url = "http://localhost:9091/user/" + id;
		
		// 拉取注册在eureka注册中心的所有叫user-service的服务
		List<ServiceInstance> serviceInstances = 
			discoveryClient.getInstances("user-service"); 
		// 我们只注册了一个，那么只需要获取0号下标的索引即可
		ServiceInstance serviceInstance = serviceInstances.get(0); 
		// 拼接字符串形成一个url地址
		String url = "http://" + 
				serviceInstance.getHost() + 
				":" + 
				serviceInstance.getPort() + 
				"/user/" + 
				id;
		
		return restTemplate.getForObject(url, User.class);
	}
}

Servidor eureka de alta disponibilidad

Múltiples servidores Eureka también se registrarán como servicios entre sí.Cuando un proveedor de servicios se registra con un nodo en el clúster de Eureka Server, el nodo sincronizará la información del servicio con cada nodo en el clúster para lograr la sincronización de datos. Por lo tanto, independientemente de que el cliente acceda a cualquier nodo del clúster de Eureka Server, puede obtener información completa de la lista de servicios.