Author:Eric
Version:9.0.0
文章目录
一、SpringCloud介绍
1.1 微服务架构
微服务架构的提出者:马丁福勒
https://martinfowler.com/articles/microservices.html
简而言之,微服务架构样式[1]是一种将单个应用程序开发为一组小服务的方法,每个小服务都在自己的进程中运行并与轻量级机制(通常是HTTP资源API)进行通信。这些服务围绕业务功能构建,并且可以由全自动部署机制独立部署。这些服务的集中管理几乎没有,它可以用不同的编程语言编写并使用不同的数据存储技术。
1、 微服务架构只是一个样式,一个风格。
2、 将一个完成的项目,拆分成多个模块去分别开发。
3、 每一个模块都是单独的运行在自己的容器中。
4、 每一个模块都是需要相互通讯的。 Http,RPC,MQ。
5、 每一个模块之间是没有依赖关系的,单独的部署。
6、 可以使用多种语言去开发不同的模块。
7、 使用MySQL数据库,Redis,ES去存储数据,也可以使用多个MySQL数据库。
总结:将复杂臃肿的单体应用进行细粒度的划分,每个拆分出来的服务各自打包部署。
1.2 SpringCloud介绍
SpringCloud是微服务架构落地的一套技术栈。
SpringCloud中的大多数技术都是基于Netflix公司的技术进行二次研发。
SpringCloud的中文社区网站:http://springcloud.cn/
SpringCloud的中文网:http://springcloud.cc/
八个技术点:
- Eureka - 服务的注册与发现
- Robbin - 服务之间的负载均衡
- Feign - 服务之间的通讯
- Hystrix - 服务的线程隔离以及断路器
- Zuul - 服务网关
- Stream - 实现MQ的使用
- Config - 动态配置
- Sleuth - 服务追踪
二、服务的注册与发现-Eureka【重点
】
2.1 引言
Eureka就是帮助我们维护所有服务的信息,以便服务之间的相互调用
Eureka |
---|
2.2 Eureka的快速入门
2.2.1 创建EurekaServer
创建一个父工程,并且在父工程中指定SpringCloud的版本,并且将packaing修改为pom
<packaging>pom</packaging>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Greenwich.SR5</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
创建eureka的server,创建SpringBoot工程,并且导入依赖,在启动类中添加注解,编写yml文件
导入依赖
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
启动类添加注解
@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class,args);
}
}
编写yml配置文件
server:
port: 8761 # 端口号
eureka:
instance:
hostname: localhost # localhost
client:
# 当前的eureka服务是单机版的
registerWithEureka: false
fetchRegistry: false
serviceUrl:
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
2.2.2 创建EurekaClient
创建Maven工程,修改为SpringBoot
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
在启动类上添加注解
@SpringBootApplication
@EnableEurekaClient
public class CustomerApplication {
public static void main(String[] args) {
SpringApplication.run(CustomerApplication.class,args);
}
}
编写配置文件
# 指定Eureka服务地址
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka
#指定服务的名称
spring:
application:
name: CUSTOMER
2.2.3 测试Eureka
创建了一个Search搜索模块,并且注册到Eureka
使用到EurekaClient的对象去获取服务信息
@Autowired
private EurekaClient eurekaClient;
正常RestTemplate调用即可
@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认证
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
编写配置类
加入了安全认证模块后,默认会开启 CSRF 跨站脚本攻击,需要禁用它
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
// 忽略掉/eureka/**
http.csrf().ignoringAntMatchers("/eureka/**");
super.configure(http);
}
}
编写配置文件
# 指定用户名和密码
spring:
security:
user:
name: root
password: root
其他服务想注册到Eureka上需要添加用户名和密码
eureka:
client:
service-url:
defaultZone: http://用户名:密码@localhost:8761/eureka
2.4 Eureka的高可用
如果程序的正在运行,突然Eureka宕机了。
如果调用方访问过一次被调用方了,Eureka的宕机不会影响到功能。
如果调用方没有访问过被调用方,Eureka的宕机就会造成当前功能不可用。
搭建Eureka高可用
准备多台Eureka
让服务注册到多台Eureka
eureka:
client:
service-url:
defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka
让多台Eureka之间相互通讯
eureka:
client:
registerWithEureka: true # 注册到Eureka上
fetchRegistry: true # 从Eureka拉取信息
serviceUrl:
defaultZone: http://root:root@localhost:8762/eureka/
2.5 Eureka的细节
EurekaClient启动时,将自己的信息注册到EurekaServer上,EurekaSever就会存储上EurekaClient的注册信息。
当EurekaClient调用服务时,本地没有注册信息的缓存时,去EurekaServer中去获取注册信息。
EurekaClient会通过心跳的方式去和EurekaServer进行连接。(默认30sEurekaClient会发送一次心跳请求,如果超过了90s还没有发送心跳信息的话,EurekaServer就认为你宕机了,将当前EurekaClient从注册表中移除)
eureka:
instance:
lease-renewal-interval-in-seconds: 30 #心跳的间隔
lease-expiration-duration-in-seconds: 90 # 多久没发送,就认为你宕机了
EurekaClient会每隔30s去EurekaServer中去更新本地的注册表
eureka:
client:
registry-fetch-interval-seconds: 30 # 每隔多久去拉取服务注册信息
Eureka的自我保护机制,统计15分钟内,如果一个服务的心跳发送比例低于85%,EurekaServer就会开启自我保护机制
- 不会从EurekaServer中去移除长时间没有收到心跳的服务。
- EurekaServer还是可以正常提供服务的。
- 网络比较稳定时,EurekaServer才会开始将自己的信息被其他节点同步过去
eureka:
server:
enable-self-preservation: true # 开启自我保护机制
CAP定理,C - 一致性,A-可用性,P-分区容错性,这三个特性在分布式环境下,只能满足2个,而且分区容错性(分区容错性是指系统能够容忍节点之间的网络通信的故障)在分布式环境下,是必须要满足的,只能在AC之间进行权衡。
如果选择CP,保证了一致性,可能会造成你系统在一定时间内是不可用的,如果你同步数据的时间比较长,造成的损失大。
Eureka就是一个AP的效果,高可用的集群,Eureka集群是无中心,Eureka即便宕机几个也不会影响系统的使用,不需要重新的去推举一个master,也会导致一定时间内数据是不一致。
三、服务间的负载均衡-Ribbon【重点
】
3.1 引言
Robbin是帮助我们实现服务和服务负载均衡,Robbin属于客户端负载均衡
客户端负载均衡:customer客户模块,将2个Search模块信息全部拉取到本地的缓存,在customer中自己做一个负载均衡的策略,选中某一个服务。
服务端负载均衡:在注册中心中,直接根据你指定的负载均衡策略,帮你选中一个指定的服务信息,并返回。
Robbin |
---|
3.2 Ribbon的快速入门
启动两个search模块 vm options设置值为-Dserver.port=8082
在customer导入robbin依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>
配置整合RestTemplate和Robbin
@Bean
@LoadBalanced
public RestTemplate restTemplate(){
return new RestTemplate();
}
在customer中去访问search
@GetMapping("/customer")
public String customer(){
String result = restTemplate.getForObject("http://SEARCH/search", String.class);
//4. 返回
return result;
}
3.3 Ribbon配置负载均衡策略
负载均衡策略
- RandomRule:随机策略
- RoundRobbinRule:轮询策略
- WeightedResponseTimeRule:默认会采用轮询的策略,后续会根据服务的响应时间,自动给你分配权重
- BestAvailableRule:根据被调用方并发数最小的去分配
采用注解的形式,所有的服务都采用这个负载均衡策略
@Bean
public IRule robbinRule(){
return new RandomRule();
}
配置文件去指定负载均衡的策略(推荐)
# 指定具体服务的负载均衡策略
SEARCH: # 编写服务名称
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule # 具体负载均衡使用的类
四、服务间的调用-Feign【重点
】
4.1 引言
Feign可以帮助我们实现面向接口编程,就直接调用其他的服务,简化开发。
4.2 Feign的快速入门
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
在启动类中添加一个注解
@EnableFeignClients
创建一个接口,并且和Search模块做映射
@FeignClient("SEARCH") // 指定服务名称
public interface SearchClient {
// value -> 目标服务的请求路径,method -> 映射请求方式
@RequestMapping(value = "/search",method = RequestMethod.GET)
String search();
}
测试使用
@Autowired
private SearchClient searchClient;
@GetMapping("/customer")
public String customer(){
String result = searchClient.search();
return result;
}
fegin底层使用了ribbon作为负载均衡
SEARCH:
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
4.3 Feign的传递参数方式
注意事项
- 如果你传递的参数,比较复杂时,默认会采用POST的请求方式。
- 传递单个参数时,推荐使用@PathVariable,如果传递的单个参数比较多,这里也可以采用@RequestParam,不要省略value属性
- 传递对象信息时,统一采用json的方式,添加@RequestBody
- Client接口必须采用@RequestMapping
在Search模块下准备三个接口
@GetMapping("/search/{id}")
public Customer findById(@PathVariable Integer id){
return new Customer(1,"张三",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;
}
封装Customer模块下的Controller
@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") // 会自动转换为POST请求 405
public Customer save(Customer customer){
return searchClient.save(customer);
}
Customer模块再封装Client接口
@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.POST)
Customer save(@RequestBody Customer customer);
测试
4.4 Feign的Fallback
Fallback可以帮助我们在使用Feign去调用另外一个服务时,如果出现了问题,走服务降级,返回一个错误数据,避免功能因为一个服务出现问题,全部失效。
4.4.1 FallBack方式
创建一个POJO类,实现Client接口。
@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;
}
}
修改CLient接口中的注解,添加一个属性。
@FeignClient(value = "SEARCH",fallback = SearchClientFallBack.class)
添加一个配置文件。
# feign和hystrix组件整合
feign:
hystrix:
enabled: true
4.4.1 FallBackFactory方式
调用方无法知道具体的错误信息是什么,通过FallBackFactory的方式去实现这个功能
FallBackFactory基于Fallback
创建一个POJO类,实现FallBackFactory
@Component
public class SearchClientFallBackFactory implements FallbackFactory<SearchClient> {
@Autowired
private SearchClientFallBack searchClientFallBack;
@Override
public SearchClient create(Throwable throwable) {
throwable.printStackTrace();
return searchClientFallBack;
}
}
修改Client接口中的属性
@FeignClient(value = "SEARCH",fallbackFactory = SearchClientFallBackFactory.class)
4.4.2 feign代码示例
//定义feign接口
@FeignClient("openapi-cache")
public interface CacheFeign {
@PostMapping("/cache/set/{key}/{value}/{expireTime}")
public boolean save2Redis(@PathVariable(value = "key") String key, @PathVariable(value = "value") String value, @PathVariable(value = "expireTime") long expireTime) ;
@GetMapping("/cache/get/{key}")
public String getFromRedis(@PathVariable(value = "key") String key) ;
@PostMapping("/cache/delete/{key}")
public boolean deleteKey(@PathVariable(value = "key") String key) ;
@PostMapping("/cache/expire/{key}/{expireTime}")
public boolean expire(@PathVariable(value = "key") String key,@PathVariable(value = "expireTime") long expireTime) ;
@GetMapping("/cache/getIncrement/{key}")
public Long getAutoIncrementId(@PathVariable(value = "key") String key) ;
}
@Service
@Transactional
//调用feign
public class ApiMappingServiceImpl implements ApiMappingService {
@Autowired
private ApiMappingMapper apiMappingMapper;
private final String GATEWAY_REDIS_KEY = "APINAME:";
@Autowired
private SendAPIRoutingChangeStream stream;
@Autowired
private CacheFeign cacheFeign;
@Override
public void addApiMapping(ApiMapping mapping) {
apiMappingMapper.addApiMapping(mapping);
// cacheService.hmset(GATEWAY_REDIS_KEY + mapping.get("gatewayApiName"), mapping);
//判断当前的数据是否是有效的
if(mapping.getState()==1){
cacheFeign.hMset(SystemParams.METHOD_REDIS_PRE+mapping.getGatewayApiName(),mapping);
//向消费端发送添加的信息
senMessage(SystemParams.METHOD_REDIS_PRE+mapping.getGatewayApiName(),APIRoutingType.ADD);
}
}
}
五、服务的隔离及断路器-Hystrix【重点
】
5.1 引言
Hystrix |
---|
5.2 降级机制实现
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
启动类中添加一个注解
@EnableCircuitBreaker
在CustomerController中针对某一个接口去编写他的降级方法
@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);
}
在controller上添加注解表示采用这个降级策略
@HystrixCommand(fallbackMethod = "findByIdFallBack")
5、 测试一下
效果 |
---|
5.3 线程隔离
在一个基于微服务的应用程序中,您通常需要调用多个微服务完成一个特定任务。这些调用默认是使用相同的线程来执行调用的,这些线程Java容器为处理所有请求预留的。在高并发服务器请求的情况下,一个性能较低的服务会“霸占”java容器中绝大多数线程,而其它性能正常的服务的请求则需要等待线程资源的释放。最后,整个java容器会崩溃。
Hystrix的线程池(默认),当用户请求服务A和服务I的时候,tomcat的线程(图中蓝色箭头标注)会将请求的任务交给服务A和服务I的内部线程池里面的线程(图中橘色箭头标注)来执行,tomcat的线程就可以去干别的事情去了,当服务A和服务I自己线程池里面的线程执行完任务之后,就会将调用的结果返回给tomcat的线程,从而实现资源的隔离,当有大量并发的时候,服务内部的线程池的数量就决定了整个服务的并发度,例如服务A的线程池大小为10个,当同时有12请求时,只会允许10个任务在执行,其他的任务被放在线程池队列中,或者是直接走降级服务,此时,如果服务A挂了,就不会造成大量的tomcat线程被服务A拖死,服务I依然能够提供服务。整个系统不会受太大的影响。
信号量,信号量的资源隔离只是起到一个开关的作用,例如,服务X的信号量大小为10,那么同时只允许10个tomcat的线程(此处是tomcat的线程,而不是服务X的独立线程池里面的线程)来访问服务X,其他的请求就会被拒绝,从而达到限流保护的作用。
Hystrix的线程池的配置(具体配置的name属性要查看HystixCommandProperties类)
配置信息 | name | value |
---|---|---|
线程隔离策略 | execution.isolation.strategy | THREAD |
指定超时时间 | execution.isolation.thread.timeoutInMilliseconds | 1000 |
是否开启超时时间配置 | execution.timeout.enabled | true |
超时之后是否中断线程 | execution.isolation.thread.interruptOnTimeout | true |
取消任务后是否中断线程 | execution.isolation.thread.interruptOnCancel | false |
1 Hystrix的隔离策略有THREAD(线程池)和SEMAPHONE(信号量)两种,默认是THREAD
2 正常情况下,保持默认即可。
3 如果发生找不到上下文的运行时异常,可考虑将隔离策略设置为SEMAPHONE
代码实现
@GetMapping("/customer/{id}")
@HystrixCommand(fallbackMethod = "findByIdFallBack",commandProperties = {
@HystrixProperty(name = "execution.isolation.strategy",value = "THREAD"),
@HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "3000")
})
public Customer findById(@PathVariable Integer id) throws InterruptedException {
System.out.println(Thread.currentThread().getName());
Thread.sleep(3000);
return searchClient.findById(id);
}
信号量的配置信息
配置信息 | name | value |
---|---|---|
线程隔离策略 | execution.isolation.strategy | SEMAPHORE |
指定信号量的最大并发请求数 | execution.isolation.semaphore.maxConcurrentRequests | 10 |
代码实现
@GetMapping("/customer/{id}")
@HystrixCommand(fallbackMethod = "findByIdFallBack",commandProperties = {
@HystrixProperty(name = "execution.isolation.strategy",value = "SEMAPHORE")
})
public Customer findById(@PathVariable Integer id) throws InterruptedException {
System.out.println(Thread.currentThread().getName());
return searchClient.findById(id);
}
5.4 断路器
5.4.1 断路器介绍
马丁福勒断路器论文:https://martinfowler.com/bliki/CircuitBreaker.html
在调用指定服务时,如果说这个服务的失败率达到你输入的一个阈值,将断路器从closed状态,转变为open状态,指定服务时无法被访问的,如果你访问就直接走fallback方法,在一定的时间内,open状态会再次转变为half open状态,允许一个请求发送到我的指定服务,如果成功,转变为closed,如果失败,服务再次转变为open状态,会再次循环到half open,直到断路器回到一个closed状态。
断路器 |
---|
5.4.2 配置断路器的监控界面
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>
在启动类中添加注解
@EnableHystrixDashboard
配置一个Servlet路径,指定上Hystrix的Servlet
@WebServlet("/hystrix.stream")
public class HystrixServlet extends HystrixMetricsStreamServlet {
}
//------------------------------------------------------------
// 在启动类上,添加扫描Servlet的注解
@ServletComponentScan("com.qf.servlet")
测试直接访问http://host:port/hystrix
监控界面 |
---|
在当前位置输入映射好的servlet路径
检测效果 |
---|
5.4.3 配置断路器的属性
断路器的属性(默认10s秒之内请求数)
配置信息 | name | value |
---|---|---|
断路器的开关 | circuitBreaker.enabled | true |
失败阈值的总请求数 | circuitBreaker.requestVolumeThreshold | 20 |
请求总数失败率达到%多少时 | circuitBreaker.errorThresholdPercentage | 50 |
断路器open状态后,多少秒是拒绝请求的 | circuitBreaker.sleepWindowInMilliseconds | 5000 |
强制让服务拒绝请求 | circuitBreaker.forceOpen | false |
强制让服务接收请求 | circuitBreaker.forceClosed | false |
具体配置方式
@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;
}
// Thread.sleep(3000);
// int i=1/0;
return searchClient.findById(id);
}
5.5 请求缓存
5.5.1 请求缓存介绍
请求缓存的生命周期是一次请求
请求缓存是缓存当前线程中的一个方法,将方法参数作为key,方法的返回结果作为value
在一次请求中,目标方法被调用过一次,以后就都会被缓存。
请求缓存 |
---|
5.5.2 请求缓存的实现
创建一个Service,在Service中调用Search服务。
@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被清空");
}
}
使用请求缓存的注解
@CacheResult:帮助我们缓存当前方法的返回结果(必须@HystrixCommand配合使用)
@CacheRemove:帮助我们清除某一个缓存信息(基于commandKey)
@CacheKey:指定哪个方法参数作为缓存的标识
修改Search模块的返回结果
return new Customer(1,"张三",(int)(Math.random() * 100000));
编写Filter,去构建HystrixRequestContext
@WebFilter("/*")
public class HystrixRequestContextInitFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HystrixRequestContext.initializeContext();
filterChain.doFilter(servletRequest,servletResponse);
}
}
Customer项目启动类加上扫描filter包 @ServletComponentScan({“com.qf.customer.servlet”,“com.qf.customer.filter”})
修改Controller
public Customer findById(@PathVariable Integer id) throws InterruptedException {
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));
return searchClient.findById(id);
}
测试结果
六、服务的网关-Zuul【重点
】
6.1 引言
- 客户端维护大量的ip和port信息,直接访问指定服务
- 认证和授权操作,需要在每一个模块中都添加认证和授权的操作
- 项目的迭代,服务要拆分,服务要合并,需要客户端进行大量的变化
- 统一的把安全性校验都放在Zuul中
- Zuul=route+filter
zuul |
---|
6.2 Zuul的快速入门
创建Maven项目,修改为SpringBoot
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
添加一个注解
@EnableEurekaClient
@EnableZuulProxy
编写配置文件
# 指定Eureka服务地址
eureka:
client:
service-url:
defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka
#指定服务的名称
spring:
application:
name: ZUUL
server:
port: 80
直接测试
测试效果 |
---|
6.3 Zuul常用配置信息
6.3.1 Zuul的监控界面
导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
编写配置文件
# 查看zuul的监控界面(开发时,配置为*,上线,不要配置)
management:
endpoints:
web:
exposure:
include: "*"
直接访问localhost/actuator/routes
6.3.2 忽略服务配置
# zuul的配置
zuul:
# 基于服务名忽略服务,无法查看 ,如果要忽略全部的默认服务,ignored-services可以配置"*",但对自定义服务的配置,是无法忽略的
ignored-services: eureka
# 监控界面依然可以查看,在访问的时候,404,地址的忽略方法会忽略自定义的服务配置
# ignored-patterns 对自定义服务的配置,是可以忽略的
ignored-patterns: /**/search/**
测试,访问http://localhost/search/search/2,会报404
6.3.3 自定义服务配置
# zuul的配置
zuul:
# 指定自定义服务(方式一 , key(服务名):value(路径))
# routes:
# search: /ss/**
# customer: /cc/**
# 指定自定义服务(方式二)
routes:
kehu: # 自定义名称
path: /ccc/** # 映射的路径
serviceId: customer # 服务名称
6.3.4 灰度发布
在Zuul的启动类中添加一个配置类
@Bean
public PatternServiceRouteMapper serviceRouteMapper() {
return new PatternServiceRouteMapper(
"(?<name>^.+)-(?<version>v.+$)",
"${version}/${name}");
}
在Customer模块中的application.yml文档编写如下配置
version: v1
#指定服务的名称
spring:
application:
name: CUSTOMER-${version}
再复制一个Customer服务,VM options=-Dversion=v2 -Dserver.port=9001
修改Zuul的配置
# zuul的配置
zuul:
# 基于服务名忽略服务,无法查看, 如果需要用到-v的方式,一定要忽略掉
# ignored-services: "*"
CustomerController代码
@Value("${version}")
private String version;
@GetMapping("/version")
public String version() throws InterruptedException {
return version;
}
测试
测试效果 |
---|
6.4 Zuul的过滤器执行流程 routes filter
客户端请求发送到Zuul服务上,首先通过PreFilter链,如果正常放行,会把请求再次转发给RoutingFilter,请求转发到一个指定的服务,在指定的服务响应一个结果之后,再次走一个PostFilter的过滤器链,最终再将响应信息交给客户端。
过滤器 |
---|
6.5 Zuul过滤器入门
1)pre
可以在请求被路由之前调用。适用于身份认证的场景,认证通过后再继续执行下面的流程。
2)route
在路由请求时被调用。适用于灰度发布场景,在将要路由的时候可以做一些自定义的逻辑。
3)post
在 route 和 error 过滤器之后被调用。这种过滤器将请求路由到达具体的服务之后执行。适用于需要添加响应头,记录响应日志等应用场景。
4)error
处理请求时发生错误时被调用。在执行过程中发送错误时会进入 error 过滤器,可以用来统一记录错误信息。
创建POJO类,继承ZuulFilter抽象类
@Component
public class TestZuulFilter extends ZuulFilter {}
指定当前过滤器的类型
@Override
public String filterType() {
return FilterConstants.PRE_TYPE;
}
指定过滤器的执行顺序
@Override
public int filterOrder() {
return FilterConstants.PRE_DECORATION_FILTER_ORDER - 1;
}
配置是否启用
@Override
public boolean shouldFilter() {
// 开启当前过滤器
return true;
}
指定过滤器中的具体业务代码
@Override
public Object run() throws ZuulException {
System.out.println("prefix过滤器执行~~~");
return null;
}
测试
效果 |
---|
6.6 PreFilter实现token校验
准备访问路径,请求参数传递token
http://localhost/v1/customer/version?token=123
创建AuthenticationFilter
@Component
public class AuthenticationFilter extends ZuulFilter {
@Override
public String filterType() {
return FilterConstants.PRE_TYPE;
}
@Override
public int filterOrder() {
return PRE_DECORATION_FILTER_ORDER - 2;
}
@Override
public boolean shouldFilter() {
return true;
}
@Override
public Object run() throws ZuulException {
//..
}
}
在run方法中编写具体的业务逻辑代码
@Override
public Object run() throws ZuulException {
//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)) {
//4. token校验失败,直接响应数据
requestContext.setSendZuulResponse(false);
//返回状态码/404/500...
requestContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
}
return null;
}
测试
效果 |
---|
6.7 Zuul的降级
创建POJO类,实现接口FallbackProvider
@Component
public class ZuulFallBack implements FallbackProvider {}
重写两个方法
@Override
public String getRoute() {
return "*"; // 代表指定全部出现问题的服务,都走这个降级方法
}
@Override
public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
System.out.println("降级的服务:" + route);
cause.printStackTrace();
return new ClientHttpResponse() {
@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() {
}
@Override
public InputStream getBody() throws IOException {
// 给用户响应的信息
String msg = "当前服务:" + route + "出现问题!!!";
return new ByteArrayInputStream(msg.getBytes());
}
@Override
public HttpHeaders getHeaders() {
// 指定响应头信息
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
return headers;
}
};
}
测试
效果 |
---|
6.8 Zuul动态路由
创建一个过滤器,执行顺序最好放在Pre过滤器的最后面
@Component
public class DynamicRouting 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 {
RequestContext requestContext = RequestContext.getCurrentContext();
HttpServletRequest request = requestContext.getRequest();
String redisKey = request.getParameter("redisKey");
if(redisKey!=null && "customer".equals(redisKey)){
//如果携带的redisKey是customer,则跳转到以下地址
// http://localhost:8080/customer
requestContext.put(FilterConstants.SERVICE_ID_KEY,"customer-v1");
requestContext.put(FilterConstants.REQUEST_URI_KEY,"/customer");
}else if(redisKey!=null && "search".equals(redisKey)){
// http://localhost:8081/search/1
requestContext.put(FilterConstants.SERVICE_ID_KEY,"search");
requestContext.put(FilterConstants.REQUEST_URI_KEY,"/search/1");
}
return null;
}
}
测试
效果 |
---|
七、多语言支持-Sidecar
7.1 引言
在SpringCloud的项目中,需要接入一些非Java的程序,第三方接口,无法接入eureka,hystrix,feign等等组件。启动一个代理的微服务,代理微服务去和非Java的程序或第三方接口交流,通过代理的微服务去接入SpringCloud的相关组件。
sidecar |
---|
7.2 Sidecar实现
7.2.1 创建一个第三方的服务,创建一个SpringBoot工程 other_serivce
在application.properties文件中配置项目的端口号
server.port=7001
编写Controller
@RestController
public class TestController {
@GetMapping("/list")
public String list(){
return "other-service:list";
}
}
7.2.2 创建maven工程06_sidecar,修改为SpringBoot
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-netflix-sidecar</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
添加注解,访注解为复合注解,这个注解包括@EnableCircuitBreaker,@EnableDiscoveryClient,和@EnableZuulProxy
@EnableSidecar
编写配置文件
server:
port: 81
# 指定Eureka服务地址
eureka:
client:
service-url:
defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka
# 指定服务名称
spring:
application:
name: sidecar
# 指定代理的第三方服务
sidecar:
port: 7001
7.3.3 Customer项目中添加Feign和Controller
Feign的编写
@FeignClient("SIDECAR")
public interface OtherSeriviceFeign {
@GetMapping("/list")
String list();
}
Controller中的编写
@Autowired
private OtherSeriviceFeign otherSeriviceFeign;
@GetMapping("/list")
public String list(){
return otherSeriviceFeign.list();
}
通过customer通过feign调用第三方服务
效果 |
---|
八、服务间消息传递-Stream
8.1 引言
Stream就是在消息队列的基础上,对其进行封装,让咱们更方便的去操作MQ消息队列。
效果 |
---|
8.2 Stream快速入门
启动RabbitMQ
在Search项目中添加消费者-导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
消费者-配置文件
spring:
# 连接RabbitMQ
rabbitmq:
host: 192.168.206.142
port: 5672
username: test
password: 123
virtual-host: /test
创建消息通道绑定的接口 @Input接口表示作为消息的消费者,监听的是myMessage的交换机。Spring会自动帮我们创建队列并绑定到交换机上。
public interface StreamClient {
@Input("myMessage")
SubscribableChannel input();
}
# myMessage 交换机名称
监听类来监听队列,获取消息。@EnableBinding注解绑定定义了 @Input注解的接口,以此实现对消息通道(Channel)的绑定。@StreamListener用在方法上,用来监听指定的交换机,因为会默认创建一个队列绑定到交换机,所以监听交换机实际上就是监听队列
@Component
@EnableBinding(StreamClient.class)
public class StreamReceiver {
@StreamListener("myMessage")
public void msg(Object msg){
System.out.println("接收到消息: " + msg);
}
}
生产者-导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>
生产者-配置文件
spring:
# 连接RabbitMQ
rabbitmq:
host: 192.168.199.109
port: 5672
username: test
password: test
virtual-host: /test
创建消息通道绑定的接口 @Output注解表示作为消息的生产者,会将消息发送到名称为myMessage的交换机
public interface StreamClient {
@Output("myMessage")
MessageChannel output();
}
启动类添加注解 ,绑定定义了 @Output注解的接口,以此实现对消息通道(Channel)的绑定
@EnableBinding(StreamClient.class)
Controller的实现
@RestController
public class MessageController {
@Autowired
private StreamClient streamClient;
@GetMapping("/send")
public String send(){
streamClient.output().send(MessageBuilder.withPayload("hello,Stream!!").build());
return "消息发送成功";
}
}
8.3 Stream重复消费问题
在消费方Search项目中需要添加一个配置,指定消费者组
指定消费者组后,只会有一个消费者接收和消费。所以之前会出现重复消费的问题,是由于默认情况下,任何消费者都会产生一个匿名消费组,所以每个消费者实例都会有自己的消费组,从而当有消息发送的时候,就形成了广播的模式。
spring:
cloud:
stream:
bindings:
myMessage: # 队列名称(交换机名称)
group: customer # 消费者组
8.4 Stream的消费者手动ack
在Search项目编写配置
spring:
cloud:
stream:
# 实现手动ACK
rabbit:
bindings:
myMessage:
consumer:
acknowledgeMode: MANUAL
Search项目修改消费端方法
@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 引言
配置文件分散在不同的项目中,不方便维护。
配置文件的安全问题。
修改完配置文件,无法立即生效。
config |
---|
9.2 搭建Config-Server
创建Maven工程,修改为SpringBoot
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
添加注解
@EnableConfigServer
编写配置文件(Git的操作)
spring:
cloud:
config:
server:
git:
basedir: D:\basedir # 本地仓库的地址/这个可以没有
username: chenzetao666 # 远程仓库用户名
password: czt136204 # 远程仓库密码
uri: https://gitee.com/chenzetao666/config_test.git # 远程仓库地址
测试(http://localhost:port/{label}/{application}-{profile}.yml)
效果 |
---|
9.3 搭建Config-Client
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-client</artifactId>
</dependency>
编写配置文件
# 指定Eureka服务地址
eureka:
client:
service-url:
defaultZone: http://root:root@localhost:8761/eureka,http://root:root@localhost:8762/eureka
#指定服务的名称
spring:
application:
name: CUSTOMER-${version}
cloud:
config:
discovery:
enabled: true # 是否启用配置
service-id: CONFIG # config服务名称
profile: dev # 后缀,到时会自动去config远程仓库读取以dev结尾的文件
version: v1
# CONFIG -> CUSTOMER-v1-dev.yml,读取的文件名
修改配置名称
// 提升配置文件的优先级
修改为bootstrap.yml
测试发布消息到RabbitMQ
效果 |
---|
9.4 实现动态配置
9.4.1 实现原理
实现原理 |
---|
9.4.2 服务连接RabbitMQ
Config项目和Customer项目均要导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>
Config项目编写配置文件连接RabbitMQ信息
spring:
rabbitmq:
host: 192.168.206.142
port: 5672
username: test
password: 123
virtual-host: /test
9.4.3 实现手动刷新
Config项目和Customer项目均要导入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
Config项目和Customer项目均要编写配置文件,yml设置开放访问地址,默认情况下都不允许访问
management:
endpoints:
web:
exposure:
include: "*"
为customer添加一个controller,不要忘记加@RefreshScope注解,不要手动刷新无效
@RestController
@RefreshScope
public class CustomerController {
@Value("${env}")
private String env;
@GetMapping("/env")
public String env(){
return env;
}
}
测试,发送请求http://localhost:8888/actuator/bus-refresh,注意是post请求
1. CONFIG在Gitee修改之后,自动拉取最新的配置信息。
2. 其他模块需要更新的话,手动发送一个请求http://ip:port/actuator/bus-refresh,不重启项目,即可获取最新的配置信息
9.5.4 内网穿透
为了能让git webhooks访问本地的http://ip:port/actuator/bus-refresh地址,需要把localhost:8888的地址改为外网地址,因此需要使用内网穿透。内网穿透官网https://natapp.cn/
注册登录
购买一个免费的隧道。
配置隧道 |
---|
下载客户端,并复制config.ini文件,在文件中指定authtoken
netapp软件 |
---|
启动exe文件,并测试使用域名访问config接口
效果 |
---|
9.5.5 实现自动刷新
配置Gitee中的WebHooks
配置Gitee中的WebHooks |
---|
给Config添加一个过滤器,注意要在启动类中放行filter
@ServletComponentScan("com.qf.filter")
测试
测试 |
---|