SpringCloud学习笔记（二）

SpringCloud学习笔记

7、负载均衡ribbon

在实际的应用中，不可能只有一个user-service，往往有非常多的集群，那么eureka中的服务列表就会有多个，那么如何去选择服务呢？这里就使用到了负载均衡算法了。
Eureka已经帮助我们集成好了负载均衡组件：Ribbon
那么如何使用ribbon呢？
首先我们启动两个user-service实例，一个9091，一个9092
在user-service中配置如下端口：

server:
	port: ${port:9091}

启动第一个user-service时不需要添加vm参数，启动第二个user-service需要在VM添加-Dport=9092

启动后就变成了这个样子

我们需要开启负载均衡
直接在RestTemolate的配置方法上添加@LoadBalanced注解：

	@Bean
	@LoadBalanced
	public RestTemplate restTemplate() {
		return new RestTemplate();
	}
	@GetMapping("/{id}")
	public User queryById(@PathVariable("id") Long id) {
	String url = "http://user-service/user/" + id;
	return restTemplate.getForObject(url, User.class);
}

负载均衡策略有两种，一种是随机，一种是轮询

8、Hystrix

Hystrix是Netflix开源的一个延迟和容错库，用于隔离访问远程服务，防止出现级联失败。
当线程出现雪崩问题时，我们就需要使用Hystrix对线程进行隔离，或者服务降级
那么如何对线程进行隔离呢？
Hystrix为每个依赖服务调用分配一个小的线程池，如果线程池已满调用将被立即拒绝，默认不采用排队，加速失败判定时间。
用户的请求将不再直接访问服务，而是通过线程池中的空闲线程来访问服务，如果线程池已满，或者请求超时，则会进行降级处理
服务降级又是什么呢？
用户的请求故障时，不会被阻塞，更不会无休止的等待或者看到系统崩溃，至少可以看到一个执行结果（例如返回友好的提示信息） 。

那么如何使用呢？
先引入依赖。我们需要在消费端consumer-demo端添加

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

开启熔断
在启动类添加注解@EnableCircuitBreaker sping提供了一个组合注解@SpringCloudAppplication，组合注解包括@SpringBootApplication、@EnableDiscoveryClient、@EnableCircuitBreaker。

编写降级逻辑
改造consumer-demo的controller层

@RestController
@RequestMapping("/consumer")
@Slf4j
public class ConsumerController {
	@Autowired
	private RestTemplate restTemplate;
	@Autowired
	private DiscoveryClient discoveryClient;
	@GetMapping("{id}")
	@HystrixCommand(fallbackMethod = "queryByIdFallback")
	public String queryById(@PathVariable Long id) {
		String url = "http://user-service/user/" + id;
		return restTemplate.getForObject(url, String.class);
	}
	public String queryByIdFallback(Long id) {
		log.error("查询用户信息失败。id：{}", id);
		return "对不起，网络太拥挤了！";
	}
}

上面是单独针对一个请求出现的服务降级，还有默认的fallback，对所有的业务都生效

@RestController
@RequestMapping("/consumer")
@Slf4j
@DefaultProperties(defaultFallback = "defaultFallback")
public class ConsumerController {
	@Autowired
	private RestTemplate restTemplate;
	@Autowired
	private DiscoveryClient discoveryClient;
	@GetMapping("{id}")
	//@HystrixCommand(fallbackMethod = "queryByIdFallback")
	@HystrixCommand
	public String queryById(@PathVariable Long id) {
		String url = "http://user-service/user/" + id;
		return restTemplate.getForObject(url, String.class);
	}
	public String queryByIdFallback(Long id) {
		log.error("查询用户信息失败。id：{}", id);
		return "对不起，网络太拥挤了！";
	}
	public String defaultFallback() {
			return "默认提示：对不起，网络太拥挤了！";
		}
	}

Hystrix的默认超时是1秒，可以复制到yml配置文件中，可以直接复制

hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=2000

熔断原理：
在服务请求失败达到一定次数时，熔断器会被打开，默认5秒后回到半开状态，允许部分请求进入，如果请求还是失败，那么熔断器会再度被打开，直至请求成功，熔断器才会完全被关闭。
默认的熔断器触发要求高，休眠时间窗较短，为了测试方便，我们可以通过配置修改熔断策略：

#复制到yml中会自动格式化
hystrix.command.default.circuitBreaker.requestVolumeThreshold=10
hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds=10000
hystrix.command.default.circuitBreaker.errorThresholdPercentage=50
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=2000

9、Fegin

什么Feign
Feign可以把Rest的请求进行隐藏，伪装成类似SpringMVC的Controller一样。你不用再自己拼接url，拼接参数等等操作，一切都交给Feign去做
那么如何使用呢？
导入依赖

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

@FeignClient("user-service")
public interface UserClient {
	//http://user-service/user/123
	@GetMapping("/user/{id}")
	User queryById(@PathVariable("id") Long id);
}

在消费端consumer-demo编写一个接口Feign会通过动态代理，帮我们生成实现类。这点跟Mybatis的mapper很像
@FeignClient ，声明这是一个Feign客户端，同时通过 value 属性指定服务名称
接口中的定义方法，完全采用SpringMVC的注解，Feign会根据注解帮我们生成URL，并访问获取结果
@GetMapping中的/user，请不要忘记；因为Feign需要拼接可访问的地址
编写新的控制器类 ConsumerFeignController ，使用UserClient访问：

@RestController
@RequestMapping("/cf")
public class ConsumerFeignController {
	@Autowired
	private UserClient userClient;
	@GetMapping("/{id}")
	public User queryById(@PathVariable Long id){
		return userClient.queryById(id);
	}
}

开启Feign，在驱动类上添加注解@EnableFeignClient

Feign也支持Hystrix，默认关闭，需要手动开启

feign:
	hystrix:
		enabled: true # 开启Feign的熔断功能

与之前的服务降级不同，我们需要实现之前写的接口的实现类

@Component
public class UserClientFallback implements UserClient {
	@Override
	public User queryById(Long id) {
		User user = new User();
		user.setId(id);
		user.setName("用户异常");
		return user;
	}
}

将刚写好的写进接口

@FeignClient(value = "user-service", fallback = UserFeignClientFallback.class)
public interface UserFeignClient {
@GetMapping("/user/{id}")
	User queryUserById(@PathVariable("id") Long id);
}

10、Spring Cloud GateWay网关

Spring Cloud Gateway是Spring官网基于Spring 5.0、 Spring Boot 2.0、Project Reactor等技术开发的网关
服务。
Spring Cloud Gateway基于Filter链提供网关基本功能：安全、监控／埋点、限流等。
Spring Cloud Gateway为微服务架构提供简单、有效且统一的API路由管理方式。
Spring Cloud Gateway是替代Netflix Zuul的一套解决方案。
Spring Cloud Gateway组件的核心是一系列的过滤器，通过这些过滤器可以将客户端发送的请求转发（路由）到对应的微服务。 Spring Cloud Gateway是加在整个微服务最前沿的防火墙和代理器，隐藏微服务结点IP端口信息，从而加强安全保护。Spring Cloud Gateway本身也是一个微服务，需要注册到Eureka服务注册中心。网关的核心功能是：过滤和路由

首先新建一个module
配置文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="HTTP://maven.apache.org/POM/4.0.0"
xmlns:xsi="HTTP://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="HTTP://maven.apache.org/POM/4.0.0 HTTP://maven.apache.org/xsd/maven4.0.0.xsd">
<parent>
	<artifactId>lxs-springcloud</artifactId>
	<groupId>com.lxs</groupId>
	<version>1.0-SNAPSHOT</version>
</parent>
	<modelVersion>4.0.0</modelVersion>
	<artifactId>lxs-gateway</artifactId>
	<dependencies>
		<dependency>
		<groupId>org.springframework.cloud</groupId>
		<artifactId>spring-cloud-starter-gateway</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
	</dependencies>
</project>

启动类与配置文件一起生成，GateWay也需要注册到Eureka中，需要添加注解@EnableDIscoveryClient

server:
	port: 10010
spring:
	application:
		name: api-gateway
eureka:
	client:
		service-url:
			defaultZone: HTTP://127.0.0.1:10086/eureka
	instance:
		prefer-ip-address: true

GateWay网关参数解析

cloud:
	gateway:
	routes:
# 路由id，可以随意写
	- id: user-service-route
# 代理的服务地址
	uri: HTTP://127.0.0.1:9091
	#可写 uri:lb//user-service 表示使用负载均衡算法进行服务代理
# 路由断言，可以配置映射路径
	predicates:
	  - Path=/user/** #断言表示路径必须有/user/否则无法正确跳转到代理地址
	filters:
		#添加前缀
	  -PrefixPath=/user
	  #添加后缀，表示过滤1个路径，以此类推
	  - StripPrefix=1

网关中还存在一个重要的东西–过滤器
过滤器分为局部过滤器，全局过滤器。
可以在配置文件中配置

# 默认过滤器，对所有路由都生效
default-filters:
- AddResponseHeader=X-Response-Foo, Bar
- AddResponseHeader=abc-myname,xj

自动义的局部过滤器需要注意的是名字的编写规范 XXXGateWayFilterFactory 。如下代码所示

@Component
public class MyParamGatewayFilterFactory extends
AbstractGatewayFilterFactory<MyParamGatewayFilterFactory.Config> {
	static final String PARAM_NAME = "param";
	public MyParamGatewayFilterFactory() {
	super(Config.class);
}
	public List<String> shortcutFieldOrder() {
		return Arrays.asList(PARAM_NAME);
	}
	@Override
	public GatewayFilter apply(Config config) {
		return (exchange, chain) -> {
	// http://localhost:10010/api/user/8?name=lxs config.param ==> name
	//获取请求参数中param对应的参数名 的参数值
	ServerHTTPRequest request = exchange.getRequest();
	if(request.getQueryParams().containsKey(config.param)){
		request.getQueryParams().get(config.param).
		forEach(value -> System.out.printf("------------局部过滤器--------%s = %s-
		-----", config.param, value));
	}
			return chain.filter(exchange);
		};
	}
	public static class Config{
	//对应在配置过滤器的时候指定的参数名
	private String param;
	public String getParam() {
		return param;
	}
	public void setParam(String param) {
		this.param = param;
		}
	}
}

配置配置文件

filters:
# 表示过滤1个路径，2表示两个路径，以此类推
- StripPrefix=1
# 自定义过滤器
- MyParam=name

自定义全局过滤器，只需要实现GlobalFilter, Ordered

@Component
public class MyGlobalFilter implements GlobalFilter, Ordered {
	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		System.out.println("--------------全局过滤器MyGlobalFilter------------------");
		String token = exchange.getRequest().getHeaders().getFirst("token");
		if(StringUtils.isBlank(token)){
	//设置响应状态码为未授权
			exchange.getResponse().setStatusCode(HTTPStatus.UNAUTHORIZED);
			return exchange.getResponse().setComplete();
	}
		return chain.filter(exchange);
	}
	@Override
	public int getOrder() {
	//值越小越先执行
		return 1;
	}
}

微服务中GateWay需要跨域

globalcors:
	corsConfigurations:
	'[/**]':
	#allowedOrigins: * # 这种写法或者下面的都可以，*表示全部
		allowedOrigins:
			- "http://docs.spring.io"
		allowedMethods:
			- GET

11、Spring Cloud Config分布式配置中心

在分布式系统中，由于服务数量非常多，配置文件分散在不同的微服务项目中，管理不方便。为了方便配置文件集中管理，需要分布式配置中心组件。在Spring Cloud中，提供了Spring Cloud Config，它支持配置文件放在配置服务的本地，也支持放在远程Git仓库（GitHub、码云）。
创建仓库：my-config
创建文件user-dev.yml
将原来user-service的yml配置复制到user-dev.yml中
删除项目中的user-service的yml文件，新增一个bootstrap.yml文件

spring:
	cloud:
		config:
# 要与仓库中的配置文件的application保持一致
	name: user
# 要与仓库中的配置文件的profile保持一致
	profile: dev
# 要与仓库中的配置文件所属的版本（分支）一样
	label: master
discovery:
# 使用配置中心
	enabled: true
# 配置中心服务名
	service-id: config-server
eureka:
	client:
		service-url:
			defaultZone: http://127.0.0.1:10086/eureka

并且在user-service添加依赖

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

需要一个配置中心读取的module
添加子module config-server

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven4.0.0.xsd">
<parent>
	<artifactId>lxs-springcloud</artifactId>
	<groupId>com.lxs</groupId>
	<version>1.0-SNAPSHOT</version>
</parent>
	<modelVersion>4.0.0</modelVersion>
	<artifactId>config-server</artifactId>
	<dependencies>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-config-server</artifactId>
		</dependency>	
	</dependencies>
</project>

12、Spring Cloud Bus服务总线

Spring Cloud Bus是用轻量的消息代理将分布式的节点连接起来，可以用于广播配置文件的更改或者服务的监控管理。也就是消息总线可以为微服务做监控，也可以实现应用程序之间相互通信。 Spring Cloud Bus可选的消息代理有RabbitMQ和Kafka。
每次修改了git中配置中心的内容时，我们都需要将其更新。程序必须重新启动才会生效，那么这极其的繁琐，服务总线就能很好的解决这个问题。
只需要在配置module中引入依赖

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-bus</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-stream-binder-rabbit</artifactId>
</dependency>

server:
	port: 12000
spring:
	application:
		name: config-server
cloud:
	config:
		server:
			git:
				uri: https://gitee.com/lxsong77/lxs-config.git
# 配置rabbitmq信息；如果是都与默认值一致则不需要配置
rabbitmq:
	host: localhost
	port: 5672
	username: guest
	password: guest
eureka:
	client:
		service-url:
			defaultZone: http://127.0.0.1:10086/eureka
management:
	endpoints:
		web:
			exposure:
				# 暴露触发消息总线的地址
				include: bus-refresh

改造用户服务

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-bus</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-stream-binder-rabbit</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

添加user-service配置文件内容

# 配置rabbitmq信息；如果是都与默认值一致则不需要配置
rabbitmq:
	host: localhost
	port: 5672
	username: guest
	password: guest

添加user-service的控制层注解@RefreshScope