微服务框架

[TOC]

一、SpringCloud介绍

1.1 微服务架构

https://martinfowler.com/articles/microservices.html

微服务架构提出者:马丁福勒

简而言之,微服务体系结构[样式 1]是一种将单个应用程序开发为一组小型服务的方法,每个应用程序在自己的进程中运行,并与轻量级机制(通常是 HTTP 资源 API)通信。这些服务围绕业务功能构建,可通过全自动部署机制独立部署。这些服务的集中管理最少,可能以不同的编程语言编写,并使用不同的数据存储技术。

1.2 SpringCloud介绍

SpringCloud是微服务架构落地的一套技术栈

SpringCloud中的大多数技术都是基于Netflix公司的技术进行第二次开发。

1、SpringCloud的中文社区网站:http://springcloud.cn/

2、SpringCloud的中文网 :http://springcloud.cc/

八个技术点:

1、Eureka - 服务的注册与发现

2、Robbn - 服务之间的负载均衡

3、Feign - 服务之间的通讯

4、Hystrix - 服务的线程隔离及其熔断器

5、Zuul - 服务网关

6、Stream - 实现MQ的使用

7、Config - 动态配置

8、 Sleuth - 服务追踪

二、服务的注册与发现-Eureka

2.1 引言

Eureka就是帮助我们维护所有服务的信息,以便服务之间的相互调用

1605019839175

2.2 Eureka的快速入门

2.2.1 创建EurekaServer

1、创建一个父工程,并且在父工程中指定SpringCloud版本,并且将packaing修改为pom

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<packaging>pom</packaging>

<properties>
<java.version>1.8</java.version>
<spring.cloud-version>Hoxton.SR8</spring.cloud-version>
</properties>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring.cloud-version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

2、创建eureka的server,创建springboot工程,并且导入依赖,再启动类中添@EnableEurekaServer注解和编写yml文件

2.1、导入依赖

1
2
3
4
5
6
7
8
9
10
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
</dependencies>

2.2、启动类添加注解

1
2
3
4
5
6
7
@EnableEurekaServer
@SpringBootApplication
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class,args);
}
}

2.3 编写yml配置文件

1
2
3
4
5
6
7
8
9
10
11
12
server:
port: 8761

eureka:
instance:
hostname: localhost
client:
#当前的eureka是单机版的
registerWithEureka: false
fetchRegistry: false
serviceUrl:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

2.2.2 创建EurekaClient

1、创建Maven工程,修改为SpringBoot

2、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

3、在启动类上添加注解@EnableEurekaClient

1
2
3
4
5
6
7
@EnableEurekaClient
@SpringBootApplication
public class CustomerApplication {
public static void main(String[] args) {
SpringApplication.run(CustomerApplication.class,args);
}
}

4、编写配置文件

1
2
3
4
5
6
7
8
9
10
#指定Eureka服务地址
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka

#指定服务名称
spring:
application:
name: CUSTOMER

image-20201111095518705

2.2.3 测试Eureka

1、创建了一个Search搜索模块,并且注册到Eureka

2、使用EurekaClient的对象获取服务信息

1
2
@Autowired
private EurekaClient eurekaClient;

3、创建RestTemplate

1
2
3
4
5
6
7
8
@Configuration
public class RestTemplateConfig {

@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
}

4、使用RestTemplate调用

1
2
3
4
5
6
7
8
9
10
11
12
@GetMapping("/customer")
public String customer() {
//1. 通过eurekaClient 获取到SEARCH服务的信息
InstanceInfo info = eurekaClient.getNextServerFromEureka("SEARCH", false);
//2. 获取到访问的地址
String url = info.getHomePageUrl();
System.out.println(url);
//3. 通过restTemplate访问
String result = restTemplate.getForObject(url + "/search", String.class);
//4. 返回
return result;
}

2.3 Eureka的安全性

实现Eureka认证

1、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>

2、编写配置类

1
2
3
4
5
6
7
8
9
10
@EnableWebSecurity
class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Override
protected void configure(HttpSecurity http) throws Exception {
//忽略掉/eureka/**路径
http.csrf().ignoringAntMatchers("/eureka/**");
super.configure(http);
}
}

3、编写配置文件,配置用户密码

1
2
3
4
5
6
#指定用户名密码
spring:
security:
user:
name: root
password: root

4、其他服务想注册到Eureka上需要添加用户名密码

1
2
3
4
5
#指定Eureka服务地址
eureka:
client:
service-url:
defaultZone: http://用户名:密码@localhost:8761/eureka

2.4 Eureka的高可用性

如果程序正在运行,突然Eureka宕机了

1、如果调用方访问过一次被调用方,Eureka的宕机就不会影响到功能

2、如果调用方没有访问过被调用方,Eureka的宕机就会造成当前功能的不可用到功能

搭建Eureka高可用

image-20201111110217411

1、准备多态Eureka

采用了复制的方式,删除iml和target文件,并且修改pom.xml中的项目名称,再给负公差添加module

2、让服务注册到多台Eureka上

1
2
3
4
5
6
7
server:
port: 8761

eureka:
client:
serviceUrl:
defaultZone: http://root:root@localhost:8762/eureka/
1
2
3
4
5
6
7
server:
port: 8762

eureka:
client:
serviceUrl:
defaultZone: http://root:root@localhost:8761/eureka/

3、让多台Eureka之间相互通讯

1
2
3
4
5
6
7
eureka:
client:
#当前的eureka是单机版的 false单机版 true集群
registerWithEureka: true
fetchRegistry: true
serviceUrl:
defaultZone: http://root:root@localhost:8761/eureka/

2.5 Eureka的细节

1、EurekaClient启动时,讲自己的信息注册到EurekaServer上,EurekaServer就会储存EurekaClient的注册信息。

2、当EurekaClient调用服务时,本地没有注册信息的缓存时,去EurekaServer中获取注册信息

3、EurekaClient会通过心跳的方式去和EurekaServer进行连接。(默认30s EurekaClient就会发送一次心跳请求,如果超过了90s还没有发送心跳信息的话,EurekaSevrer就认为你宕机了,将当前的EurekaClient从注册表中移除)

1
2
3
4
eureka:
instance:
lease-renewal-interval-in-seconds: 30 #心跳间隔
lease-expiration-duration-in-seconds: 90 #多久没法送,就认为你宕机了

4、EurekaClient会每个30s去EurekaServer中去更新本地的注册表

1
2
3
4
eureka:
client:
#每隔多久去更新一下本地的注册表缓存信息
registry-fetch-interval-seconds: 30

5、Eureka的自我保护机制,统计15分钟内,如果一个服务的心跳发送比例低于85%,EurekaServer就会开启自我保护机制

​ 1、不会从EurekaServer中去移除长时间没有收到心跳的服务

​ 2、EurekaServer还是可以正常提供服务的

​ 3、网络稳定时,EurekaServer才会开始将自己的信息被其他节点同步过去

image-20201111132523595

1
2
3
4
5
eureka:
# Eureka保护机制配置
server:
#true 开启 false关闭
enable-self-preservation: true

6、CAP定理,C-一致性 A-可用性 P-分区容错性,这三个特新在分布是环境下,只能满足2个,而且分区容错性在分布式环境下,时必须要满足的。只能在AC之间进行权衡。

1、如果选择CP,保证了一致性,可能会造成你系统在一定时间内是不可以的,如果你同步数据的时间比较长,造成的损失就越大。

2、如果选择AP的效果,高可用的集群,Eureka集群是无中心,Eureka即便宕机几个也不会影响系统的使用,不需要重新去枚举一个master,也会导致一定时间内数据是不一致。

三、服务间的负载均衡-Robbin

3.1 引言

Robbin是帮助我们实现服务和服务负载均衡

客户端负载均衡:customer客户端模块,将2个Search模块信息全部拉取到本地的缓存,在customer中自己做一个负载均衡的策略,选中某一个服务。

服务端负载均衡:在注册中心中,直接根据你指定的负载均衡策略,帮你选中一个指定的服务器信息,并返回。

image-20201111134022333

3.2 Robbin的快速入门

1、启动两个Search模块

2、在customer导入robbin依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

3、配置整合RestTemplate和Robbin

1
2
3
4
5
6
7
8
9
@Configuration
public class RestTemplateConfig {

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate();
}
}

4、在customer中去访问Search

1
2
3
4
5
6
@GetMapping("/customer")
public String customer() {
String result = restTemplate.getForObject("http://SEARCH/search", String.class);
//4. 返回
return result;
}

3.3 Robbin配置负载均衡策略

1、负载均衡策略

  1. RandomRule:随机策略
  2. RoundRobbinRule:轮询策略
  3. WeightedResponseTimeRule:默认会采用轮询的策略,后续会根据服务的响应时间,自动给你分配权重
  4. BestAvailableRule:根据被调用方并发数最小的去分配

2、采用注解的形式

1
2
3
4
@Bean
public IRule robbinRule() {
return new RandomRule();
}

3、配置文件去指定负载均衡的策略(推荐)

1
2
3
4
#指定具体服务的负载均衡策略
SEARCH: #编写服务名称
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule #具体负载均衡使用的类

四、服务间的调用-Feign

4.1 引言

Feign可以帮助我们实现面向接口编程,就直接调用其他服务,简化开发。

4.2 Feign的快速入门

1、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2、添加一个注解@EnableFeignClients

1
2
3
4
5
6
7
8
@EnableEurekaClient
@SpringBootApplication
@EnableFeignClients
public class CustomerApplication {
public static void main(String[] args) {
SpringApplication.run(CustomerApplication.class,args);
}
}

3、创建一个接口,并且和search模块做映射

1
2
3
4
5
6
7
8
//指定服务名称
@FeignClient("SEARCH")
public interface SearchClient {

//value -> 目标服务的请求路径,method -> 映射请求方式
@RequestMapping(value = "/search",method = RequestMethod.GET)
public String search();
}

4、测试使用

1
2
3
4
5
6
7
8
@Autowired
private SearchClient searchClient;

@GetMapping("/customer")
public String customer() {
String result = searchClient.search();
return result;
}

4.3 Feign的传递参数方式

1、注意事项

  1. 如果你传递的参数,比较复杂时,默认会采用POST的请求方式。
  2. 传递单个参数时,推荐使用@PathVariable,如果传递的单个参数比较多,这里也可以采用@RequestParam,不要省略value属性
  3. 传递对象信息时,统一采用json的方式,添加@RequestBody
  4. Client接口必须采用@RequestMapping

2、在Search模块下准备三个接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@GetMapping("/search/{id}")
public Customer findById(@PathVariable Integer id) {
return new Customer(1, "zhangsan", 23);
}

@GetMapping("/getCustomer")
public Customer getcustomer(@RequestParam Integer id, @RequestParam String name) {
return new Customer(id, name, 23);
}

@PostMapping("save")
public Customer save(@RequestBody Customer customer) {
return customer;
}

3、封装Customer模块的Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@GetMapping("/customer/{id}")
public Customer findById(@PathVariable Integer id) {
return searchClient.findById(id);
}

@GetMapping("/getCustomer")
public Customer getcustomer(@RequestParam Integer id, @RequestParam String name) {
return searchClient.getcustomer(id,name);
}

@GetMapping("save")
public Customer save(Customer customer) {
return searchClient.save(customer);
}

4、再封装Client接口

1
2
3
4
5
6
7
8
@RequestMapping(value = "/search/{id}",method = RequestMethod.GET)
Customer findById(@PathVariable(value = "id") Integer id);

@RequestMapping(value = "/getCustomer",method = RequestMethod.GET)
Customer getcustomer(@RequestParam(value = "id") Integer id, @RequestParam(value = "name") String name);

@RequestMapping(value = "save",method = RequestMethod.GET) //会自动转化成POST请求 405
Customer save(@RequestBody Customer customer);

5、测试

image-20201111155409030

4.4 Feign的Fallback

Fallback可以帮助我们在使用Feign去调用另一个服务时,如果出现了问题,走服务降级,返回一个错误的数据,避免功能因为一个服务出现问题,全部失效

1、创建一个POJO类,实现Client接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Component
public class SearchClientFallBack implements SearchClient {
@Override
public String search() {
return "出现问题了";
}

@Override
public Customer findById(Integer id) {
return null;
}

@Override
public Customer getcustomer(Integer id, String name) {
return null;
}

@Override
public Customer save(Customer customer) {
return null;
}
}

2、修改Client接口中的注解,添加一个属性

1
@FeignClient(value = "SEARCH",fallback = SearchClientFallBack.class)

3、添加一个配置文件。

1
2
3
4
#feign和hystrix主件整合
feign:
hystrix:
enabled: true

调用方无法知道具体的错误信息是什么,通过FallBackFactory的方式去实现这个功能

1、FallBackFactory基于fallback

2、创建一个POJO类,实现FallBackFactory

1
2
3
4
5
6
7
8
9
10
11
@Component
public class SearchClientFallBackFactory implements FallbackFactory<SearchClient> {

@Autowired
private SearchClientFallBack searchClientFallBack;
@Override
public SearchClient create(Throwable throwable) {
throwable.printStackTrace();
return searchClientFallBack;
}
}

3、修改Client接口中的属性

1
2
3
@FeignClient(value = "SEARCH",
fallbackFactory = SearchClientFallBackFactory.class
)

五、服务的隔离及熔断器-Hystrix

5.1 引言

image-20201111162630381

5.2 降级机制实现

1、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

2、添加一个注解@EnableCircuitBreaker

1
2
3
4
5
6
7
8
@EnableEurekaClient
@SpringBootApplication
@EnableCircuitBreaker
public class CustomerApplication {
public static void main(String[] args) {
SpringApplication.run(CustomerApplication.class,args);
}
}

3、针对某一个接口去编写他的降级方法

1
2
3
4
5
6
7
8
9
10
11
@GetMapping("/customer/{id}")
@HystrixCommand(fallbackMethod ="findByIdFallBack" )
public Customer findById(@PathVariable Integer id) {
int i = 1/0;
return searchClient.findById(id);
}

//findById的降级方法,方法描述要与接口一致
public Customer findByIdFallBack(Integer id) {
return new Customer(-1,"",0);
}

4、在接口上添加注解

1
@HystrixCommand(fallbackMethod ="findByIdFallBack" )

5、测试

image-20201111164239591

5.3 线程隔离

如果使用Tomcat的线程池去接收用户的请求,使用当前线程去执行其他服务的功能,如果某一个服务出现了故障,导致tomcat的线程大量的堆积,导致tomcat无法处理其他业务功能。

1、Hystrix线程池(默认),接收用户请求采用tomcat的线程池,执行业务代码,调用其他服务时,采用Hystrix的线程池。

2、信号量,使用的还是Tomcat的线程池,帮助我们取关了Tomcat的线程池

1、Hystrix的线程池的配置(具体的配置属性需要去查看HystrixCommandProperties类) wiki

  1. 线程隔离策略:name = hystrix.command.default.execution.isolation.strategy,value=THREAD,SEMAPHORE
  2. 指定超时时间(针对线程池):name= hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds ,value =1000
  3. 是否开启超时时间配置:name=hystrix.command.default.execution.timeout.enabled,value=true
  4. 超时之后是否中断线程:name=hystrix.command.default.execution.isolation.thread.interruptOnTimeout,value=true
  5. 取消任务之后是否中断线程:name=hystrix.command.default.execution.isolation.thread.interruptOnCancel,value=false

2、信号量配置信息

  1. 线程隔离策略:name = hystrix.command.default.execution.isolation.strategy,value=THREAD,SEMAPHORE
  2. 指定信号量的最大并发请求数:name=hystrix.command.default.execution.isolation.semaphore.maxConcurrentRequests,value=10

5.4 断路器

5.4.1 断路器介绍

如果调用指定服务时,如果说这个服务的失败率达到你输入的阈值麻将断路器从closed状态,转变为open状态,指定服务时无法被访问的,如果你访问就直接走fallback方法,在一定时间内,open状态会再次转变为half open状态,允许一个请求发送到我指定服务,如果成功,则转变为closed,如果失败,服务再次转变为open状态,会再次循环到hald open,直到专路器回到一个closed状态。

image-20201111181650929

5.4.2 配置断路器的监控界面

1、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

2、在启动类中添加注解@EnableHystrixDashboard

1
2
3
4
5
6
7
8
9
10
11
@EnableEurekaClient
@SpringBootApplication
@EnableFeignClients
@EnableCircuitBreaker
@EnableHystrixDashboard
@ServletComponentScan("cn.zyjblogs.servlet")
public class CustomerApplication {
public static void main(String[] args) {
SpringApplication.run(CustomerApplication.class,args);
}
}

3、配置一个Servlet路径,指定上Hystrix的Servlet

1
2
3
@WebServlet("/hystrix.stream")
public class HystrixServlet extends HystrixMetricsStreamServlet {
}

4、在启动类上添加扫描Servlet的注解@ServletComponentScan("cn.zyjblogs.servlet")

5、配置文件

1
2
3
hystrix:
dashboard:
proxy-stream-allow-list: localhost

6、测试

直接访问: http://host:port/hystrix.stream

1605103421256

在当前位置输入映射好的servlet路径

1605103436874

5.4.3 配置断路器的属性

断路器的属性(10秒之内)

  1. 断路器的开关:name=hystrix.command.default.circuitBreaker.enabled,value=true
  2. 失败阈值的总请求数:name=hystrix.command.default.circuitBreaker.requestVolumeThreshold,value=20
  3. 请求总数失败率达到%多少时打开断路器:name=hystrix.command.default.circuitBreaker.errorThresholdPercentage,value=50
  4. 断路器open状态后,多少秒是拒绝请求的:name=hystrix.command.default.circuitBreaker.sleepWindowInMillisecondsvalue=5000
  5. 强制让服务拒绝请求:name=hystrix.command.default.circuitBreaker.forceOpen,value=false
  6. 强制让服务接收请求:name=hystrix.command.default.circuitBreaker.forceClosed,value=false

具体配置方式

1
2
3
4
5
6
7
@GetMapping("/customer/{id}")
@HystrixCommand(fallbackMethod ="findByIdFallBack",commandProperties = {
@HystrixProperty(name = "circuitBreaker.enabled",value="true"),
@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value="10"),
@HystrixProperty(name = "circuitBreaker.errorThresholdPercentage",value="70"),
@HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value="5000")
})

5.5 请求缓存

5.5.1 请求缓存的介绍

1、请求缓存的声明周期是一次请求

2、请求缓存是缓存当前线程中的一个方法,将方法参数作为key,方法的返回结果作为value

3、在一次请求中,目标方法被调用过一次以后就都会被缓存

1605104987931

5.5.2 请求缓存的实现

1、创建一个Service,在Service中调用Search服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Service
public class CustomerService {

@Autowired
private SearchClient searchClient;

@CacheResult
@HystrixCommand(commandKey = "findById")
public Customer findById(@CacheKey Integer id) throws InterruptedException {
return searchClient.findById(id);
}

@CacheRemove(commandKey = "findById")
@HystrixCommand
public void clearFindById(@CacheKey Integer id) {
System.out.println("findById缓存被清空");
}

}

2、使用请求缓存的注解@CacheResult CacheRemove

  1. @CacheResult:帮助我们缓存当前方法的返回结果(必须配合@HystrixCommand使用)
  2. @CacheRemove:帮助我们清除某一个缓存信息(基于commandKey)
  3. @CacheKey:指定那个方法参数作为缓存标识

3、修改Search模块的结果返回值

1
return new Customer(id, name, (int) (Math.random() * 100000));

4、编写Filter,去构建HystrixRequestContext

1
2
3
4
5
6
7
8
@WebFilter("/*")
public class HystrixRequestContextFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HystrixRequestContext.initializeContext();
filterChain.doFilter(servletRequest,servletResponse);
}
}

5、修改Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@Autowired
private CustomerService customerService;

@GetMapping("/customer/{id}")
@HystrixCommand(
fallbackMethod = "findByIdFallBack",
commandProperties = {
@HystrixProperty(name = "circuitBreaker.enabled", value = "true"),
@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
@HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "70"),
@HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000"),
})
public Customer findById(@PathVariable Integer id) throws InterruptedException {
System.out.println(Thread.currentThread().getName());
if (id == 1) {
int i = 1 / 0;
}
//一下为添加内容
System.out.println(customerService.findById(id));
System.out.println(customerService.findById(id));
customerService.clearFindById(id);
System.out.println(customerService.findById(id));
System.out.println(customerService.findById(id));
customerService.clearFindById(id);

return searchClient.findById(id);
}

6、测试

1605106759891

六、服务的网关-Zuul

6.1 引言

1、客户端维护大量的ip和port信息,直接访问指定服务

2、认证和授权操作,需要在每一个模块中添加认证和授权操作

3、项目迭代,服务拆分,服务要合并,需要客户端镜像大量的变化

4、统一的把安全性校验都放在Zuul中

网关

6.2 Zuul的快速入门

1、创建Maven项目,修改SpringBoot

2、导入依赖

1
2
3
4
5
6
7
8
9
10
11
12
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

3、添加注解@EnableZuulProxy @EnableEurekaClient

1
2
3
4
5
6
7
8
@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy
public class ZuulApplication {
public static void main(String[] args) {
SpringApplication.run(ZuulApplication.class,args);
}
}

4、编写配置文件

1
2
3
4
5
6
7
8
9
10
11
12
server:
port: 80
#指定Eureka服务地址
eureka:
client:
service-url:
defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

#指定服务名称
spring:
application:
name: ZUUL

5、测试

image-20201112113609523

6.3 Zuul常用配置信息

6.3.1 Zuul的监控界面

1、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2、编写配置文件

1
2
3
4
5
6
#查看zuul的监考界面(开发时,配置为*,上线,不要配置)
management:
endpoints:
web:
exposure:
include: "*"

3、直接访问:http://localhost/actuator/routes

image-20201112132217601

6.3.2 忽略服务设置

1
2
3
4
5
6
# zuul的配置
zuul:
#基于服务名忽略服务,无法查看,如果要忽略全部的服务,"*",默认配置的全部路径都会被忽略掉(自定义服务配置,通过这种方式是无法忽略的)
ignored-services: eureka
#监考界面依然可以查看,在访问的时候,404无法访问
ignored-patterns: /**/search/**

6.3.3 自定义服务配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# zuul的配置
zuul:
#基于服务名忽略服务,无法查看,如果要忽略全部的服务,"*",默认配置的全部路径都会被忽略掉(自定义服务配置,通过这种方式是无法忽略的)
ignored-services: "*"
#监考界面依然可以查看,在访问的时候,404无法访问
ignored-patterns: /**/search/**
# 指定自定义服务(方式一,key(服务名):value(路径))
# routes:
# search: /ss/**
# customer: /cc/**
# 指定自定义服务(方式二)
routes:
kehu: #自定义名称
path: /cc/** # 映射路径
serviceId: customer

6.3.4 灰度发布

1、添加一个配置类

1
2
3
4
5
6
7
8
9
10
11
@Configuration
public class ZuulConfig {
@Bean
public PatternServiceRouteMapper serviceRouteMapper() {
return new PatternServiceRouteMapper(
"(?<name>^.+)-(?<version>v.+$)",
"${version}/${name}");
//服务名-v版本
// /v版本/路径
}
}

2、准备一个服务,提供2个版本

1
2
3
4
5
6
version: v1

#指定服务名称
spring:
application:
name: CUSTOMER-${version}

3、修改Zuul的配置

1
2
3
zuul:
#基于服务名忽略服务,无法查看,如果需要用到-v的方式,一定要忽略掉
# ignored-services: "*"

4、修改CustomerController

1
2
3
4
5
6
7
@Value("${version}")
private String version;

@GetMapping("/version")
public String version() {
return version;
}

5、测试

image-20201112135410803

image-20201112135429409

6.4 Zuul的过滤器执行流程

客户端请求发送到Zuul服务商,首先通过PreFilter,如果正常放行,会把请求再次转发给RoutingFilter,请求转发到一个指定的服务,在指定的服务响应一个结果之后,再次走一个PostFilter的过滤器链,最终将响应信息返回给客户端。

image-20201112140312697

6.5 Zuul过滤器入门

1、创建POJO类,继承ZuulFilter

1
2
3
4
@Component
public class ZuulFilterTest extends ZuulFilter {

}

2、指定当前过滤器的类型

1
2
3
4
@Override
public String filterType() {
return FilterConstants.PRE_TYPE;
}

3、指定过滤器的执行顺序

1
2
3
4
@Override
public int filterOrder() {
return FilterConstants.PRE_DECORATION_FILTER_ORDER -1;
}

4、配置是否启用

1
2
3
4
5
@Override
public boolean shouldFilter() {
//开启当前过滤器
return true;
}

5、指定过滤器中的具体业务代码

1
2
3
4
5
@Override
public Object run() throws ZuulException {
System.out.println("prefix过滤器已经执行~~~");
return null;
}

6、测试

image-20201112141523371

6.6 PreFilter实现token校验

1、准备访问路径,请求参数专递token

http://localhost/v1/customer/version?token=123

2、创建AuthenticationFilter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Component
public class AuthenticationFilter extends ZuulFilter{
@Override
public String filterType() {
return FilterConstants.PRE_TYPE;
}

@Override
public int filterOrder() {
return FilterConstants.PRE_DECORATION_FILTER_ORDER - 2;
}

@Override
public boolean shouldFilter() {
return true;
}

@Override
public Object run() throws ZuulException {
//...
return null;
}
}

3、在run方法中编写具体的业务逻辑代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Override
public Object run() throws ZuulException {
System.out.println("AuthenticationFilter执行了");
//1. 获取Request对象
RequestContext requestContext = RequestContext.getCurrentContext();
HttpServletRequest request = requestContext.getRequest();
//2. 获取token参数
String token = request.getParameter("token");
//3.对比token
if (token == null || !"123".equalsIgnoreCase(token)) {
System.out.println("token校验失败");
//4. token校验失败,直接响应数据
requestContext.setSendZuulResponse(false);
requestContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
}
return null;
}

4、测试

image-20201112145449105

6.7 Zuul的降级

1、创建POJO类,实现接口FallbackProvider

1
2
3
4
@Component
public class ZuulFallBack implements FallbackProvider {

}

2、重写两个方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@Override
public String getRoute() {
//代表指定全部出现问题的服务,都走这个降级方法
return "*";
}

@Override
public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
System.out.println("降级的服务"+route);
cause.printStackTrace();
return new ClientHttpResponse() {
@Override
public HttpHeaders getHeaders() {
//指定响应头信息
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
return headers;
}

@Override
public InputStream getBody() throws IOException {
//给用户响应的信息
String msg = "当前服务" + route + "出现问题!!!";
return new ByteArrayInputStream(msg.getBytes());
}

@Override
public HttpStatus getStatusCode() throws IOException {
//指定具体的HttpStatus
return HttpStatus.INTERNAL_SERVER_ERROR;
}

@Override
public int getRawStatusCode() throws IOException {
//返回状态码
return HttpStatus.INTERNAL_SERVER_ERROR.value();
}

@Override
public String getStatusText() throws IOException {
//指定错误信息
return HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase();
}

@Override
public void close() {

}
};
}

3、测试

image-20201112151632111

6.8 Zuul动态路由

1、创建一个过滤器

1
2
3
4
@Component
public class DynamicRoutingFilter extends ZuulFilter{

}

2、在run方法中编辑业务逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
@Override
public String filterType() {
return FilterConstants.PRE_TYPE;
}

@Override
public int filterOrder() {
return FilterConstants.PRE_DECORATION_FILTER_ORDER +3;
}

@Override
public boolean shouldFilter() {
return true;
}

@Override
public Object run() throws ZuulException {
System.out.println("DynamicRoutingFilter执行了");
//1、获取Request对象
RequestContext context = RequestContext.getCurrentContext();
HttpServletRequest request = context.getRequest();

//2、获取参数,redisKey
String redisKey = request.getParameter("redisKey");

//3、直接判断
if (redisKey != null && redisKey.equalsIgnoreCase("customer")) {
System.out.println("DynamicRoutingFilter执行了路由到了/customer");
//http://localhost:8080/customer
context.put(FilterConstants.SERVICE_ID_KEY,"customer-v1");
context.put(FilterConstants.REQUEST_URI_KEY,"/customer");
} else if (redisKey != null && redisKey.equalsIgnoreCase("search")) {
System.out.println("DynamicRoutingFilter执行了路由到了/search/1");
//http://localhost:8081/search
context.put(FilterConstants.SERVICE_ID_KEY,"search");
context.put(FilterConstants.REQUEST_URI_KEY,"/search/1");
}
return null;
}

3、测试

image-20201112155707148

image-20201112155652269

七、多语言支持-Sidecar

7.1 引言

在SpringCloud的项目中,需要接入一些非java程序,第三方接口,无法接入eureka,hystrix,feign等组件。启动一个代理的微服务,代理微服务去和非java的程序或第三方接口交流,通过代理的非服务去计入SpringCloud的相关组件。

image-20201112160258956

7.2 Sidecar实现

1、创建一个第三方的服务

创建一个SpringBoot工程,并且添加一个Controller

2、创建Maven工程,修改为SpringBoot

2、导入以来

1
2
3
4
5
6
7
8
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-netflix-sidecar</artifactId>
</dependency>

4、添加注解@EnableSidecar

5、编写配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
server:
port: 81

eureka:
client:
service-url:
defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

#指定服务名称
spring:
application:
name: OTHER-SERVICE #other-service

# 指定代理的第三方服务
sidecar:
port: 7001

6、通过customer通过Feign的方式调用第三方服务

image-20201112165325023

八、服务间消息传递-Stream

8.1 引言

用于构建消息驱动微服务的框架(在下面方便起见也叫它Stream框架),该框架在Spring Boot的基础上整合了Spring Integration来连接消息代理中间件(RabbitMQ,Kafka等)。它支持多个消息中间件的自定义配置,同时吸收了这些消息中间件的部分概念,例如持久化订阅、消费者分组,和分区等概念。使用Stream框架,我们不必关系如何连接各个消息代理中间件,也不必关系消息的发送与接收,只需要进行简单的配置就可以实现这些功能了,可以让我们更敏捷的进行开发主体业务逻辑了。

Spring Cloud Stream框架的组成部分:

  1. Stream框架自己的应用模型;
  2. 绑定器抽象层,可以与消息代理中间件进行绑定,通过绑定器的API,可实现插件式的绑定器。
  3. 持久化订阅的支持。
  4. 消费者组的支持。
  5. Topic分区的支持。

image-20201112165641574

8.2 Stream快速入门

1、启动RabbitMQ

2、消费者-导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>

3、消费者-配置文件

1
2
3
4
5
6
spring:
rabbitmq:
port: 5672
username: test
password: test
virtual-host: /test

4、消费者-监听的队列

1
2
3
4
public interface StreamClient {
@Input("myMessage")
SubscribableChannel input();
}
1
2
3
4
5
6
7
8
@Component
@EnableBinding(StreamClient.class)
public class StreamReceiver {
@StreamListener("myMessage")
public void msg(Object msg) {
System.out.println("接收到消息" + msg);
}
}

5、启动类添加注解@EnableBinding(StreamClient.class)

6、生产者-导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>

7、生产者-配置文件

1
2
3
4
5
6
spring:
rabbitmq:
port: 5672
username: test
password: test
virtual-host: /test

8、生产者-发布消息

1
2
3
4
public interface StreamClient {
@Output("myMessage")
MessageChannel output();
}
1
2
3
4
5
6
7
8
9
10
@RestController
public class MessageController {
@Autowired
private StreamClient streamClient;
@GetMapping("/send")
public String send() {
streamClient.output().send(MessageBuilder.withPayload("Hello Stream").build());
return "消息发送成功!!";
}
}

9、启动类添加注解@EnableBinding(StreamClient.class)

10、测试访问http://localhost:8080/send

image-20201113093057704

image-20201112173342142

8.3 Stream重复消费问题

只需要添加一个配置,指定消费者组

1
2
3
4
5
6
spring:
cloud:
stream:
binders:
myMessage: #队列名称
group: customer #消费者组

8.4 Stream的消费者手动ack

1、编写配置

1
2
3
4
5
6
7
8
9
10
#指定服务名称
spring:
cloud:
stream:
#实现手动ack
rabbit:
bindings:
myMessage:
consumer:
acknowledgeMode: MANUAL

2、修改消费端方法

1
2
3
4
5
6
7
8
9
10
11
@Component
@EnableBinding(StreamClient.class)
public class StreamReceiver {
@StreamListener("myMessage")
public void msg(Object msg,
@Header(name = AmqpHeaders.CHANNEL) Channel channel,
@Header(name = AmqpHeaders.DELIVERY_TAG) Long deliveryTag) throws IOException {
System.out.println("接收到消息" + msg);
channel.basicAck(deliveryTag,false);
}
}

九、服务的动态配置-Config

9.1 引言

1、配置文件分散在不同项目中的,不方便去维护。

2、配置文件的安全问题。

3、修改配置文件,无法立即生效。

image-20201112180552221

9.2 搭建Config-Server

1、创建Maven工程,修改SpringBoot

2、导入依赖

1
2
3
4
5
6
7
8
<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>

3、添加注解@EnableConfigServer

1
2
3
4
5
6
7
@SpringBootApplication
@EnableConfigServer
public class ConfigApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigApplication.class,args);
}
}

4、编写配置文件(git)

1
2
3
4
5
6
7
8
9
spring:
cloud:
config:
server:
git:
basedir: E:\config # 本地仓库地址
username: xxxxxx@xxxx.com #远程仓库的用户名
password: xxxxxxxx #远程仓库的密码
uri: https://gitee.com/zyjblog/config-resp.git

5、测试(例子:http://localhost:82/master/customer-xxx.yml (master可以省略))

访问方式如下:

/{application}/{profile}[/{label}]
/{application}-{profile}.yml
/{label}/{application}-{profile}.yml

/{application}-{profile}.properties
/{label}/{application}-{profile}.properties

image-20201113094055276

9.3、修改Customer连接Config

1、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-client</artifactId>
</dependency>

2、修改配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#指定Eureka服务地址
eureka:
client:
service-url:
defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka

version: v1
#指定服务名称
spring:
application:
name: CUSTOMER-${version}
cloud:
config:
discovery:
enabled: true
service-id: CONFIG
profile: dev

3、修改配置文件名称application.yml改为bootstrap.yml

4、测试测试发布消息到RabbMQ

image-20201113102316294

9.4 实现动态配置

9.4.1 实现原理

image-20201113103152115

9.4.2 服务连接RabbitMQ

1、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>

2、编写配置文件

1
2
3
4
5
6
7
spring:
rabbitmq:
virtual-host: /test
host: localhost
username: test
password: test
port: 5672

3、测试

image-20201113104134210

9.4.3 实现手动刷新

1、导入依赖(两个服务config和customer均添加)

1
2
3
4
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

2、编写配置文件(两个服务config和customer均添加)

1
2
3
4
5
management:
endpoints:
web:
exposure:
include: "*"

3、为customer添加一个controller,添加注解@RefreshScope

1
2
3
4
5
6
7
8
9
10
11
12
@RestController
@RefreshScope
public class CustomerController {

@Value("${env}")
private String env;

@GetMapping("/env")
public String env() {
return env;
}
}

4、测试

  1. CONFIG在gitee修改之后,自动拉取最新的配置信息。
  2. 其他模块需要更新的话,手动发送一个POST请求:http://localhost:10000/actuator/bus-refresh ,不重启项目,即可获取最新的配置信息

9.4.4 内网穿透

1、内网穿透官网:http://www.ngrok.cc/

2、注册登录

3、购买免费隧道,并配置

image-20201113113814310

4、下载客户端,并复制隧道id,点击运行客户端,复制到客户端中

image-20201113114050201

5、测试访问是否成功

image-20201113114131931

9.4.5 实现自动刷新配置

1、配置Gitee中的WebHooks

image-20201113120733998

2、给Config添加一个过滤器UrlFilter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@WebFilter("/*")
public class UrlFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest httpServletRequest= (HttpServletRequest) servletRequest;
String url=httpServletRequest.getRequestURI();
System.out.println(url);
if(!url.endsWith("/actuator/bus-refresh")){
filterChain.doFilter(servletRequest,servletResponse);
return;
}
String body=(httpServletRequest).toString();
System.out.println("original body: "+ body);
RequestWrapper requestWrapper=new RequestWrapper(httpServletRequest);
filterChain.doFilter(requestWrapper,servletResponse);
}
private class RequestWrapper extends HttpServletRequestWrapper {
public RequestWrapper(HttpServletRequest request) {
super(request);
}

@Override
public ServletInputStream getInputStream() throws IOException {
byte[] bytes = new byte[0];
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
ServletInputStream servletInputStream = new ServletInputStream() {
@Override
public int read() throws IOException {
return byteArrayInputStream.read();
}

@Override
public boolean isFinished() {
return byteArrayInputStream.read() == -1 ? true : false;
}

@Override
public boolean isReady() {
return false;
}

@Override
public void setReadListener(ReadListener listener) {

}
};
return servletInputStream;
}
}
}

3、添加注解@ServletComponentScan("cn.zyjblogs.filter")

1
2
3
4
5
6
7
8
@SpringBootApplication
@EnableConfigServer
@ServletComponentScan("cn.zyjblogs.filter")
public class ConfigApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigApplication.class,args);
}
}

3、测试

image-20201113121035781

十、服务的追踪-Sleuth

10.1 引言

在整个微服务架构中,微服务很多,一个请求可能需要调用很多很多的服务,最终才能完成一个功能,如果说,整个功能出现了问题,在这么多的服务中,如何区定位到问题的所在点,出现问题的原因是什么。

1、Sleuth可以获取得到整个服务链路的信息

2、Zipkin通过图形化界面去看到信息。

3、Sleuth将日志信息存储到数据库中

image-20201113131325996

10.2 Sleuth使用

1、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

2、编写配置文件

1
2
3
logging:
level:
org.springframework.web.servlet.DispatcherServlet: DEBUG

3、测试

SEARCH:服务名称

012 总链路id

b0e:当前服务的链路id

false:不会将当前的日志信息,输出到其他系统中

image-20201113133658258

image-20201113133713872

image-20201113133745985

10.3 Zipkin的使用

1、搭建Zipkin的web工程 https://zipkin.io/pages/quickstart

  1. docker安装Zipkin

1、使用docker pull拉取

1
docker pull openzipkin/zipkin

2、使用docker-compose

1
2
3
4
5
6
7
8
version: "3.1"
services:
zipkin:
image: daocloud.io/daocloud/zipkin:latest
restart: always
container_name: zipkin
ports:
- 9411:9411
1
2
docker-compose up -d  #启动
docker-compose down #关闭

2、导入依赖

1
2
3
4
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

3、编写配置文件

1
2
3
4
5
6
spring:
sleuth:
sampler:
probability: 1 #百分之多少的sleuth信息需要输出到zipkin
zipkin:
base-url: http://127.0.0.1:9411/ #指定zipkin的地址

4、测试

image-20201113153443738

10.4 整合RabbitMQ

1、导入RabbitMQ依赖(zipkin中已经依赖了RabbitMQ了)

2、修改配置文件

1
2
3
4
spring:
zipkin:
sender:
type: rabbit

3、修改Zipkin信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
version: "3.1"
services:
zipkin:
image: daocloud.io/daocloud/zipkin:latest
#image: docker.io/openzipkin/zipkin:latest
restart: always
container_name: zipkin
ports:
- 9411:9411
environment:
- RABBIT_ADDRESSES=10.27.10.123:5672 #本地ipv4地址:端口
- RABBIT_USER=test
- RABBIT_PASSWORD=test
- RABBIT_VIRTUAL_HOST=/test

3、测试

image-20201113160658535

image-20201113160724897

10.5 Zipkin存储数据到ES

1、重新修改zipkin的文件yml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
version: "3.1"
services:
zipkin:
image: daocloud.io/daocloud/zipkin:latest
#image: docker.io/openzipkin/zipkin:latest
restart: always
container_name: zipkin
ports:
- 9411:9411
environment:
- RABBIT_ADDRESSES=10.27.10.123:5672
- RABBIT_USER=test
- RABBIT_PASSWORD=test
- RABBIT_VIRTUAL_HOST=/test
- STORAGE_TYPE=elasticsearch
- ES_HOSTS=http://10.27.10.123:9200

2、安装Es

1
2
3
4
5
6
7
8
9
10
11
 #拉取镜像
docker pull elasticsearch
#启动参数
docker run --name es1_6.6.0 \
-p 9200:9200 \
-p 9300:9300 \
-e ES_JAVA_OPTS="-Xms256m -Xmx256m" \
-v /d/elasticsearch/config/es1.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /d/elasticsearch/data/es1:/usr/share/elasticsearch/data \
-v /d/elasticsearch/logs/es1:/usr/share/elasticsearch/logs \
-d 13aa43015aa1

3、安装kibana

1
2
3
4
#拉取kibana
docker pull kibana
#启动参数
docker run --name kibana6.6.0 -e ELASTICSEARCH_URL=http://10.27.10.123:9200 -p 5601:5601 -d dfc685453eaa

创建索引

image-20201113164636525

4、重启zipkin后数据未丢失

1
docker-compose restart

5、测试

image-20201113164930192

十一、完整SpringCloud架构图

image-20201113165759501