SpringCloud的使用

太过爱你忘了你带给我的痛 2023-07-04 08:38 22阅读 0赞

***一.相关学习资源***  
官网地址:https://spring.io/projects/spring-cloud  
中文地址:https://springcloud.cc/  
中文社区:http://springcloud.cn/  
***二.SpringBoot和SpringCloud有啥关系?***  
SpringBoot专注于快速方便的开发单个个体微服务。  
SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并管理起来，  
为各个微服务之间提供，配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等集成服务  
SpringBoot可以离开SpringCloud独立使用开发项目，但是SpringCloud离不开SpringBoot，属于依赖的关系.  
SpringBoot专注于快速、方便的开发单个微服务个体，SpringCloud关注全局的服务治理框架。  
***三.版本说明和选择***  
因为Spring Cloud不同其他独立项目，它拥有很多子项目的大项目。所以它是的版本是 版本名+版本号 （如Angel.SR6）。  
版本名：是伦敦的地铁名  
版本号：SR（Service Releases）是固定的 ,大概意思是稳定版本。后面会有一个递增的数字。  
所以 Brixton.SR5就是Brixton的第5个Release版本。  
在这里学习使用的版本为: Greenwich SR1  
相关API文档: https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html  
***四.注册中心***  
微服务应用和机器越来越多，调用方需要知道接口的网络地址，如果靠配置文件的方式去控制网络地址，对于动态新增机器，url地址维护带来很大问题  
注册中心提供服务注册与发现功能，对服务的url地址进行统一管理.  
**SpringCloud Euraka**是SpringCloud集合中一个组件，它是对Euraka的集成，用于服务注册和发现。Eureka是Netflix中的一个开源框架。它和 zookeeper、Consul一样，都是用于服务注册管理的.  
***五.注册中心eureka-server搭建***  
**1.步骤:**  
01.使用Spring Initializr创建SpringBoot项目，选择Cloud Discover->Eureka Server  
02.启动类上贴上@EnableEurekaServer注解  
03.修改application.properties为application.yml文件，添加相关配置信息. https://cloud.spring.io/spring-cloud-netflix/single/spring-cloud-netflix.html\#spring-cloud-eureka-server  
04.运行测试，打开浏览器输入http://localhost:8761  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 2]  
**2.配置application.yml:**

server:
      port: 8761
    eureka:
      instance:
        hostname: localhost
      client:
        registerWithEureka: false
        fetchRegistry: false
        serviceUrl:
          defaultZone: http://${ eureka.instance.hostname}:${ server.port}/eureka/

**3.依赖pom.xml:**

<?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/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.5.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.xxx.cloud</groupId>
        <artifactId>eureka-server</artifactId>
        <version>1.0.0</version>
        <name>eureka-server</name>
        <description>Demo project for Spring Boot</description>
        <properties>
            <java.version>1.8</java.version>
            <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
        </properties>
        <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-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
        <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>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>

客户端的搭建  
一般会将api和真正提供服务的客户端分开,这里已商品服务为例  
1.新建一个项目.作为商品的api,只需要创建实体类即可

@Getter@Setter
    public class Product implements Serializable { 
        private Long id;//商品id
        private String name;//商品名称
        private BigDecimal price;//商品价格
        private int stock;//商品库存
    }

2.新建商品的服务端  
步骤:

01.使用Spring Initializr创建SpringBoot项目，选择Cloud Discover->Eureka Discover 和 Web->Web
    02.把application.properties修改成application.yml，并添加配置信息 ,参考:https://cloud.spring.io/spring-cloud-netflix/single/spring-cloud-netflix.html#netflix-eureka-client-starter
    03.启动测试，会在Eureka注册中心控制台页面中看到product-server实例
    04.启动多个实例，在注册中心管控台页面也可以看到.（在idea启动配置中添加-Dserver.port=8082参数，可以覆盖配置文件中的配置）
    05.添加mapper,service,controller类.

application.yml

server:
      port: 8081
    spring:
      application:
        name: product-server
    eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/

pom.xml文件,需要添加api的依赖

<dependency>
    			<groupId>com.fym.cloud</groupId>
    			<artifactId>product-api</artifactId>
    			<version>0.0.1-SNAPSHOT</version>
    		</dependency>

启动客户端  
![在这里插入图片描述][20200428133425741.png]

**六.SpringCloud Eureka 自我保护机制**  
Eureka Server 在运行期间会去统计心跳失败比例在 15 分钟之内是否低于 85%，如果低于 85%，Eureka Server 会将这些实例保护起来，让这些实例不会过期，但是在保护期内如果服务刚好这个服务提供者非正常下线了，此时服务消费者就会拿到一个无效的服务实例，此时会调用失败，对于这个问题需要服务消费者端要有一些容错机制，如重试，断路器等。

我们在单机测试的时候很容易满足心跳失败比例在 15 分钟之内低于 85%，这个时候就会触发 Eureka 的保护机制，一旦开启了保护机制，则服务注册中心维护的服务实例就不是那么准确了，此时我们可以使用**eureka.server.enable-self-preservation=false**来关闭保护机制，这样可以确保注册中心中不可用的实例被及时的剔除（不推荐）

**七.Eureka 客户端与服务器之间的通信.**  
1.Register（注册）  
Eureka客户端将关于运行实例的信息注册到Eureka服务器。注册发生在第一次心跳  
2. Renew（更新 / 续借)  
Eureka客户端需要更新最新注册信息（续借），通过每30秒发送一次心跳。更新通知是为了告诉Eureka服务器实例仍然存活。如果服务器在90秒内没有看到更新，它会将实例从注册表中删除。建议不要更改更新间隔，因为服务器使用该信息来确定客户机与服务器之间的通信是否存在广泛传播的问题  
3. Fetch Registry（抓取注册信息)  
Eureka客户端从服务器获取注册表信息并在本地缓存。之后，客户端使用这些信息来查找其他服务。通过在上一个获取周期和当前获取周期之间获取增量更新，这些信息会定期更新(每30秒更新一次)。获取的时候可能返回相同的实例。Eureka客户端自动处理重复信息。  
4. Cancel（取消）  
Eureka客户端在关机时向Eureka服务器发送一个取消请求。这将从服务器的实例注册表中删除实例，从而有效地将实例从流量中取出。

## 二.微服务调用方式Ribbon ##

**(一).订单服务order-server搭建**  
**1.步骤:**  
01.使用Spring Initializr创建SpringBoot项目，选择Cloud Discover->Eureka Discover , Web->Web , Cloud Routing->Robbin  
02.在项目的pom.xml文件添加product-api的依赖  
03.添加相关的依赖配置  
04.把创建订单的功能实现(获取商品信息暂先放下)

**(二).application.yml**

server:
      port: 8090
    spring:
      application:
        name: order-server
    eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/

**(三).使用Ribbon来实现远程调用**  
01.在配置文件中添加RestTemplate的bean  
02.使用restTemplate.getObject获取远程接口的信息.

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

Product product = restTemplate.getForObject("http://localhost:8081/product/find?id="+productId,Product.class);

**(四).使用Ribbon实现负载均衡**  
01.请求地址不写具体ip和端口，而是使用远程服务id

Product product = restTemplate.getForObject("http://product-server/product/find?id="+productId,Product.class);

02.在RestTemplate的bean上贴上@LoadBalanced注解

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

**(五).Ribbon负载均衡源码分析**  
参考下面文章  
[https://www.jianshu.com/p/e89c693f19d2][https_www.jianshu.com_p_e89c693f19d2]  
[http://juke.outofmemory.cn/entry/253843][http_juke.outofmemory.cn_entry_253843]

负载均衡策略调整

PRODUCT-SERVER:
      ribbon:
        NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule
    
    注意:服务的名称需要和代码中的服务名称一致，不然是修改不了负载均衡策略.

## 三.微服务调用方式Feign ##

**(一)步骤:**

01.在product-api项目中添加openfeign依赖
    02.在product-api项目中添加ProductFeignApi接口
    03.在product-server项目中添加ProductFeignApi的实现类(本质上就是个Controller),注意要把之前的controller删除掉.
    04.在order-server项目中的启动类上贴上@EnableFeignClients注解
    05.把之前RestTemplate的远程调用替换成Feign方式调用即可 （注意product-api和order-server中包名的问题.）

依赖

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

![在这里插入图片描述][202004281838184.png]

![在这里插入图片描述][20200428183721244.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 3]  
**(二).Feign调用源码分析**  
01.在启动类上贴上@EnableFeignClients会扫描当前包及其子包下贴了@FeignClient的接口并创建jdk动态代理对象.  
02.代理会把请求交给SynchronousMethodHandler处理  
03.底层是通过FeignLoadBalancer来帮我们实现远程调用，本质还是使用了Robbin，我们在配置文件中配置Robbin的负载均衡策略依然是可以生效的.  
04.底层是调用Client.java中的execute方法，最底层就是通过HttpURLConnection把我们发送远程调用请求

**(三).Feign超时时间设置**  
源码中默认options中配置的是6000毫秒，但是Feign默认加入了Hystrix,此时默认是1秒超时.  
我们可以通过修改配置，修改默认超时时间.

feign:
    	client:
    		 config:
    			default:
    				connectTimeout: 2000
    				 readTimeout: 2000

**(三).Feign超时重试次数设置**  
[https://github.com/Netflix/ribbon/wiki/Getting-Started\#the-properties-file-sample-clientproperties][https_github.com_Netflix_ribbon_wiki_Getting-Started_the-properties-file-sample-clientproperties]

# Max number of retries on the same server (excluding the first try)
    sample-client.ribbon.MaxAutoRetries=0
    
    # Max number of next servers to retry (excluding the first server)
    sample-client.ribbon.MaxAutoRetriesNextServer=1

## 四.服务熔断与降级Hystrix ##

**(一).熔断与降价概念讲解**  
1.熔断:类似保险丝. 防止整个系统故障，保护自己和下游服务  
2.降级:抛弃非核心业务，保障核心页面的正常运行.

两者之间的联系  
1.相同点  
a)目的很一致: 都是从可用性可靠性着想，为防止系统的整体缓慢甚至崩溃，采用的技术手段；  
b)最终表现类似: 对于两者来说，最终让用户体验到的是某些功能暂时不可达或不可用；  
2.不同点  
触发原因不太一样:服务熔断一般是某个服务（下游服务）故障引起，而服务降级一般是从整体负荷考虑；

**(二).服务雪崩效应原因和解决思路**  
1.产生的原因  
商品详情展示服务会依赖商品服务， 价格服务，商品评论服务，调用三个依赖服务会共享商品详情服务的线程池，如果其中的商品评论服务不可用（超时，代码异常等等）, 就会出现线程池里所有线程都因等待响应而被阻塞, 从而造成服务雪崩。

概括：大量请求线程同步等待造成的资源耗尽

2.解决方案

1.超时机制
    如果我们加入超时机制，例如2s，那么超过2s就会直接返回了，那么这样就在一定程度上可以抑制消费者资源耗尽的问题
    2.服务限流
    通过线程池+队列的方式或者通过信号量的方式。比如商品评论比较慢，最大能同时处理10个线程，队列待处理5个，那么如果同时20个线程到达的话，其中就有5个线程被限流了，其中10个先被执行，另外5个在队列中
    3.服务熔断
    当依赖的服务有大量超时时，在让新的请求去访问根本没有意义，只会无畏的消耗现有资源，比如我们设置了超时时间为1s，如果短时间内有大量请求在1s内都得不到响应，就意味着这个服务出现了异常，此时就没有必要再让其他的请求去访问这个服务了，这个时候就应该使用熔断器避免资源浪费
    4.服务降级
    有服务熔断，必然要有服务降级。
    所谓降级，就是当某个服务熔断之后，服务将不再被调用，此时客户端可以自己准备一个本地的fallback（回退）回调，返回一个缺省值。 例如：(备用接口/缓存/mock数据)，这样做，虽然服务水平下降，但好歹可用，比直接挂掉要强，当然这也要看适合的业务场景

***(三).Hystrix简介***  
1.是什么?参考下面文档  
[https://github.com/Netflix/Hystrix][https_github.com_Netflix_Hystrix]  
[https://github.com/Netflix/Hystrix/wiki][https_github.com_Netflix_Hystrix_wiki]

2.为啥要用?  
在大中型分布式系统中，通常系统很多依赖(HTTP,hession,Netty,Dubbo等)，在高并发访问下,这些依赖的稳定性与否对系统的影响非常大,但是依赖有很多不可控问题:如网络连接缓慢，资源繁忙，暂时不可用，服务脱机等。  
当依赖阻塞时,大多数服务器的线程池就出现阻塞(BLOCK),影响整个线上服务的稳定性，在复杂的分布式架构的应用程序有很多的依赖，都会不可避免地在某些时候失败。高并发的依赖失败时如果没有隔离措施，当前应用服务就有被拖垮的风险。  
解决问题方案:对依赖做隔离

3.能做啥?  
提供了熔断、隔离、Fallback、cache、监控等功能  
[https://cloud.spring.io/spring-cloud-netflix/single/spring-cloud-netflix.html\#\_circuit\_breaker\_hystrix\_clients][https_cloud.spring.io_spring-cloud-netflix_single_spring-cloud-netflix.html_circuit_breaker_hystrix_clients]

**(四).订单模块集成Hystrix**  
1.步骤:  
01.在order-server中添加hystrix依赖  
02.在启动类中添加@EnableCircuitBreaker注解  
03.在最外层添加熔断降级的处理. 在order-server中的控制器中添加@HystrixCommand(fallbackMethod = “saveFail”)注解 （注意fallbackMethod需要和原方法一样的签名）

2.依赖

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 5]  
日志结果:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 6]  
***(五).Feign集成Hystrix***  
1.步骤:

01.在ProductFeignApi的@FeignClient(name = "PRODUCT-SERVER",fallback = ProductFeignHystrix.class)

![在这里插入图片描述][2020042820270229.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 7]  
2.配置

默认是关闭的，需要手动开启一下
    feign:
    	hystrix:
    		enabled: true

访问结果是正常的,空数据  
![在这里插入图片描述][20200428202744125.png]

***(六).熔断降级服务异常报警通知***  
实际问题:如在项目中,出现问题,需要及时通知运维或者开发人员去解决,可能使用发邮件或者短信的方式通知.  
1.添加reids的依赖

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-data-redis</artifactId>
    		</dependency>

2.实现

public Order saveFallbackMethod(Long userId, Long productId) { 
            log.info("降级方法");
            //发邮件或者短信的方式通知.十分钟后还未处理,则再次发送
            //可以另起线程,也可以使用消息队列的方式
            new Thread(() -> { 
                String redisKey = "order-save";
                String value = stringRedisTemplate.opsForValue().get(redisKey);
                if (StringUtils.isEmpty(value)) { 
                    System.out.println("order下订单服务失败，请查找原因.");
                    stringRedisTemplate.opsForValue().set(redisKey, "save-order-fail", 20, TimeUnit.SECONDS);
                } else { 
                    System.out.println("已经发送过短信");
                }
            }).start();
            return new Order();
        }

3.配置redis服务端口,并启动

***(七).重点属性讲解***  
**1.熔断隔离策略**  
[https://github.com/Netflix/Hystrix/wiki/How-it-Works][https_github.com_Netflix_Hystrix_wiki_How-it-Works]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 8]  
a.线程池(默认)  
服务耗时比较长的建议使用线程池  
b.信号量  
服务响应很快的建议使用信号量.比如访问的缓存服务等.

**2.超时时间调整**

是否开启超时限制 （一定不要禁用）
    hystrix:
    	  command:
    	    default:
    			execution:
    				timeout:
    					enabled: 
    
    超时时间调整
    hystrix:
    	command:
    		default:
    	      execution:
    	        isolation:
    	          thread:
    	            timeoutInMilliseconds: 4000

***(八).断路器Dashboard监控仪表盘***  
**1.步骤:**  
01.添加dashboard和actuator依赖  
02.在启动类上贴@EnableHystrixDashboard  
03.在配置文件中添加开发监控地址配置  
04.访问入口：http://localhost:启动端口/hystrix，然后再地址栏上输入:http://localhost:启动端口/actuator/hystrix.stream

**2.配置**

management:
      endpoints:
        web:
          exposure:
            include: "*"

**3.依赖**

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

参数讲解  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 9]

## 五.微服务网关Zuul ##

***(一).Zuul简介***  
**1.是什么？**  
Zuul网关是系统的唯一对外的入口，介于客户端和服务器端之间的中间层，处理非业务功能 提供路由请求、鉴权、监控、缓存、限流等功能

**2.能干嘛？**

1.验证与安全保障: 识别面向各类资源的验证要求并拒绝那些与要求不符的请求。
    
    2.审查与监控: 在边缘位置追踪有意义数据及统计结果，从而为我们带来准确的生产状态结论。
    
    3.动态路由: 以动态方式根据需要将请求路由至不同后端集群处。
    
    4.压力测试: 逐渐增加指向集群的负载流量，从而计算性能水平。
    
    5.负载分配: 为每一种负载类型分配对应容量，并弃用超出限定值的请求。
    
    6.静态响应处理: 在边缘位置直接建立部分响应，从而避免其流入内部集群。
    
    7.多区域弹性: 跨越AWS区域进行请求路由，旨在实现ELB使用多样化并保证边缘位置与使用者尽可能接近。

**3.主流的网关**

zuul
    Netflix开源的微服务网关，和Eureka,Ribbon,Hystrix等组件配合使用.
    kong
    由Mashape公司开源的，基于Nginx的API gateway
    nginx+lua
    是一个高性能的HTTP和反向代理服务器,lua是脚本语言，让Nginx执行Lua脚本，并且高并发、非阻塞的处理各种请求

***(二).网关项目zuul-server搭建***

**1.步骤:**  
01.使用Spring Initializr创建SpringBoot项目，选择Cloud Discover->Eureka Discover , Cloud Rounting -> Zuul  
02.添加application.yml配置文件并添加相关的配置信息.  
03.在启动类上贴上@EnableZuulProxy注解

**2.application.yml**

server:
      port: 9000
    spring:
      application:
        name: zuul-server
    eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/

***(三).相关配置***

**1.定义路由规则**  
可以自定义路由规则  
可以通过网关实现网络隔离  
配置

zuul:
      routes:
        order-server-route:
          path: /order/** serviceId: order-server product-server-route: path: /product/** serviceId: product-server //禁用之前的访问路径 ignored-patterns: /*-server/**

**2.Cookie请求头的问题**  
默认情况，网关会把Cookie", “Set-Cookie”, "Authorization"这三个请求头过滤掉，下游的服务是获取不到这几个请求头的。  
如果不需要过滤这个请求头，可以修改过滤的集合的值.  
下面这个属性直接设置：  
sensitiveHeaders  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 10]  
***(四).zuul流程分析***  
底层是一个ZuulServlet  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 12]  
过滤器类型  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 13]

(五).自定义Zuul过滤器实现登录鉴权

@Component
    public class AuthZuulFilter extends ZuulFilter { 
        //指定过滤器的类型.四种:pre,post,error,route
        @Override
        public String filterType() { 
            return FilterConstants.PRE_TYPE;
        }
        //指定过滤器的优先级,数值越小,优先级越高
        @Override
        public int filterOrder() { 
            return 1;
        }
        /** * 指定满足过滤的条件 * @return * true:表示满足条件,需要过滤 * false:表示不满足条件,不需要进行过滤 */
        @Override
        public boolean shouldFilter() { 
            RequestContext requestContext = RequestContext.getCurrentContext();
            HttpServletRequest request = requestContext.getRequest();
            if(request.getRequestURI().startsWith("/order-api/")){ 
                return true;
            }
            return false;
        }
        /** * 具体的过滤逻辑 * 这里只做模拟,假设token为空,则表示没有登录信息,就不能去访问订单业务 * @return * @throws ZuulException */
        @Override
        public Object run() throws ZuulException { 
            RequestContext requestContext = RequestContext.getCurrentContext();
            HttpServletRequest request = requestContext.getRequest();
            String token = request.getHeader("token");
            if(StringUtils.isEmpty(token)){ 
                token = request.getParameter("token");
            }
            if(StringUtils.isEmpty(token)){ 
                requestContext.setSendZuulResponse(false);
                requestContext.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
            }
            return null;
        }
    }

## 六.链路追踪组件Sleuth&Zipkin ##

***(一).为什么需要链路追踪***  
微服务架构是一个分布式架构，它按业务划分服务单元，一个分布式系统往往有很多个服务单元。由于服务单元数量众多，业务的复杂性，如果出现了错误和异常，很难去定位。主要体现在，一个请求可能需要调用很多个服务，而内部服务的调用复杂性，决定了问题难以定位。**所以微服务架构中，必须实现分布式链路追踪，去跟进一个请求到底有哪些服务参与，参与的顺序又是怎样的，从而达到每个请求的步骤清晰可见，出了问题，很快定位。**

在微服务系统中，一个来自用户的请求，请求先达到前端A（如前端界面），然后通过远程调用，达到系统的中间件B、C（如负载均衡、网关等），最后达到后端服务D、E，后端经过一系列的业务逻辑计算最后将数据返回给用户。对于这样一个请求，经历了这么多个服务，怎么样将它的请求过程的数据记录下来呢？这就需要用到服务链路追踪。

***(二).什么叫埋点***  
所谓埋点就是在应用中特定的流程收集一些信息，用来跟踪应用使用的状况，后续用来进一步优化产品或是提供运营的数据支撑，包括访问数（Visits），访客数（Visitor），停留时长（Time On Site），页面浏览数（Page Views）和跳出率（Bounce Rate）。这样的信息收集可以大致分为两种：页面统计（track this virtual page view），统计操作行为（track this button by an event）。

***(三).集成链路追踪组件Sleuth***  
Sleuth是一个专门用于记录链路数据的开源组件  
[https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html\#sleuth-adding-project][https_cloud.spring.io_spring-cloud-static_Greenwich.SR1_single_spring-cloud.html_sleuth-adding-project]

**1.步骤:**  
01.在product-server和order-server中添加sleuth依赖  
02.在需要写日志的类上贴@Slf4j,然后再order-server,product-server中打印日志。

**2.添加依赖**

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

![在这里插入图片描述][20200430125224410.png]  
![在这里插入图片描述][20200430125239535.png]  
**3.日志参数讲解**

日志格式:
    [order-server,c323c72e7009c077,fba72d9c65745e60,false] 
    1、第一个值，spring.application.name的值
    2、第二个值，c323c72e7009c077 ，sleuth生成的一个ID，叫Trace ID，用来标识一条请求链路，一条请求链路中包含一个Trace ID，多个Span ID
    3、第三个值，fba72d9c65745e60、spanID 基本的工作单元，获取元数据，如发送一个http
    4、第四个值：false，是否要将该信息输出到zipkin服务中来收集和展示。

***(四).Zipkin***  
zipkin是Twitter基于google的分布式监控系统Dapper（论文）的开发源实现，zipkin用于跟踪分布式服务之间的应用数据链路，分析处理延时，帮助我们改进系统的性能和定位故障。  
[官网][Link 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 14]  
jar包下载地址:  
[https://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/][https_dl.bintray.com_openzipkin_maven_io_zipkin_java_zipkin-server]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 15]  
**1.步骤:**  
01.在微服务项目中添加zipkin依赖(zipkin依赖中已经包含sleuth,所以可以把之前的sleuth依赖删除)  
02.启动zipkin服务,我们直接使用的是jar的方式.  
03.需要在product-server和order-server中的配置文件中添加zipkin地址.

spring:
      zipkin:
        base-url: http://localhost:9411
      sleuth:
        sampler:
          probability: 1

**2.依赖**  
之前引入的sleuth依赖可以不用了

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 16]  
根据tranceId查询  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 17]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 18]

## 七.分布式配置中心Config ##

***(一).配置中心的作用和好处***  
统一管理配置, 快速切换各个环境的配置

在微服务体系中，服务的数量以及配置信息的日益增多，比如各种服务器参数配置、各种数据库访问参数配置、各种环境下配置信息的不同、配置信息修改之后实时生效等等，传统的配置文件方式或者将配置信息存放于数据库中的方式已无法满足开发人员对配置管理的要求，如：

安全性：配置跟随源代码保存在代码库中，容易造成配置泄漏  
时效性：修改配置，需要重启服务才能生效  
局限性：无法支持动态调整：例如日志开关、功能开关  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 19]  
***(二).配置中心工作流程***  
git 上存放我们的远程配置文件  
config-server 连接到 git  
config-client 连接到config-server  
当我们启动config-client 服务的时候，client 会通过连接的 config-server 拿到远程git 上面的配置文件，然后通过 Spring 加载到对象中。

***(三).搭建config-server项目***  
1.步骤:  
01.使用Spring Initializr创建SpringBoot项目，选择Cloud Discover->Eureka Discover , Cloud Config -> Config Server  
02.在启动类中贴上@EnableConfigServer注解  
03.添加application.yml并设置相关的配置

***(四).搭建git+config的分布式配置中心***  
这里的git服务器可以是:gitlab,github,码云等  
[https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html\#\_spring\_cloud\_config\_server][https_cloud.spring.io_spring-cloud-static_Greenwich.SR1_single_spring-cloud.html_spring_cloud_config_server]

**1.步骤:**  
01.去码云中注册账号，创建自己的项目.  
02.在配置文件中增加git服务器的地址  
03.启动测试

**2.配置:**

server:
      port: 9100
    spring:
      application:
        name: config-server
      cloud:
        config:
          server:
            git:
              uri: https://gitee.com/java/cloud-config
              username: xxxxx@xx.com
              password:xxxxxx
    eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/

**3.访问方式**  
/\{name\}-\{profiles\}.properties  
/\{name\}-\{profiles\}.yml  
/\{name\}-\{profiles\}.json  
/\{label\}/\{name\}-\{profiles\}.yml  
name 服务名称  
profile 环境名称，开发、测试、生产  
lable 仓库分支、默认master分支

***(五).分布式配置中心客户端***  
[https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html\#\_spring\_cloud\_config\_client][https_cloud.spring.io_spring-cloud-static_Greenwich.SR1_single_spring-cloud.html_spring_cloud_config_client]

**1.步骤:**  
01.在order-server中添加config-client的依赖  
02.修改对应服务的配置文件,把application.yml 改为 bootstrap.yml  
03.把其他配置都放入到git服务器期中管理

**2.依赖**  
config-client

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

**3.配置**  
bootstrap.yml

spring:
      application:
        name: order-server
      cloud:
        config:
          discovery:
            service-id: config-server
            enabled: true
          label: master
    eureka:
      client:
        serviceUrl:
          defaultZone: http://localhost:8761/eureka/

## 八.消息总线Bus ##

***(一).为什么使用***  
配置更新了，但是其他系统不知道是否更新

***(二).项目集成消息总线Bus***  
[https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html\#\_bus\_refresh\_endpoint][https_cloud.spring.io_spring-cloud-static_Greenwich.SR1_single_spring-cloud.html_bus_refresh_endpoint]

**1.步骤:**

01.在order-server和product-server项目中添加actuactor和bus-amqp依赖.
    02.在order-server.yml和product-server.yml配置文件中增加RabbitMQ依赖
    spring:
    	rabbitmq:
    		host: localhost
    		port: 5672
    		username: guest
    		password: guest
    03.#暴露全部的监控信息
    management:
    	endpoints:
    		web:
    			exposure:
    				include: "*"
    04.需要刷新配置的地方，增加注解@RefreshScope
    05.访问验证 post方式: http://localhost:8090/actuator/bus-refresh

**2.依赖**  
actuator

<dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

bus-amqp

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

***(三).流程***  
当git文件更改的时候，通过pc端用post 向端口为8090的config-client发送请求/bus/refresh／；此时8090端口会发送一个消息，由消息总线向其他服务传递，从而使整个微服务集群都达到更新配置文件。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 20]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200209153632116.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200209154232179.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200209154443366.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[20200428133425741.png]: https://img-blog.csdnimg.cn/20200428133425741.png
[https_www.jianshu.com_p_e89c693f19d2]: https://www.jianshu.com/p/e89c693f19d2
[http_juke.outofmemory.cn_entry_253843]: http://juke.outofmemory.cn/entry/253843
[202004281838184.png]: https://img-blog.csdnimg.cn/202004281838184.png
[20200428183721244.png]: https://img-blog.csdnimg.cn/20200428183721244.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200428183740416.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[https_github.com_Netflix_ribbon_wiki_Getting-Started_the-properties-file-sample-clientproperties]: https://github.com/Netflix/ribbon/wiki/Getting-Started#the-properties-file-sample-clientproperties
[https_github.com_Netflix_Hystrix]: https://github.com/Netflix/Hystrix
[https_github.com_Netflix_Hystrix_wiki]: https://github.com/Netflix/Hystrix/wiki
[https_cloud.spring.io_spring-cloud-netflix_single_spring-cloud-netflix.html_circuit_breaker_hystrix_clients]: https://cloud.spring.io/spring-cloud-netflix/single/spring-cloud-netflix.html#_circuit_breaker_hystrix_clients
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200428200236439.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200428200300145.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200428200341595.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[2020042820270229.png]: https://img-blog.csdnimg.cn/2020042820270229.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200428202718770.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[20200428202744125.png]: https://img-blog.csdnimg.cn/20200428202744125.png
[https_github.com_Netflix_Hystrix_wiki_How-it-Works]: https://github.com/Netflix/Hystrix/wiki/How-it-Works
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200428205439461.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200428210329285.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200429124013226.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200429125404506.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200429125646708.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200429130217868.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[https_cloud.spring.io_spring-cloud-static_Greenwich.SR1_single_spring-cloud.html_sleuth-adding-project]: https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html#sleuth-adding-project
[20200430125224410.png]: https://img-blog.csdnimg.cn/20200430125224410.png
[20200430125239535.png]: https://img-blog.csdnimg.cn/20200430125239535.png
[Link 1]: https://zipkin.io/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/2020043012555513.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[https_dl.bintray.com_openzipkin_maven_io_zipkin_java_zipkin-server]: https://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20200430131121249.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200430132504237.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/2020043013253978.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20200430132607439.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/202004301339133.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70
[https_cloud.spring.io_spring-cloud-static_Greenwich.SR1_single_spring-cloud.html_spring_cloud_config_server]: https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html#_spring_cloud_config_server
[https_cloud.spring.io_spring-cloud-static_Greenwich.SR1_single_spring-cloud.html_spring_cloud_config_client]: https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html#_spring_cloud_config_client
[https_cloud.spring.io_spring-cloud-static_Greenwich.SR1_single_spring-cloud.html_bus_refresh_endpoint]: https://cloud.spring.io/spring-cloud-static/Greenwich.SR1/single/spring-cloud.html#_bus_refresh_endpoint
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/20200430145322688.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU4ODc1MQ==,size_16,color_FFFFFF,t_70