Spring Cloud入门学习

一、springcloud介绍

spring cloud 是一系列框架的集合。SpringCloud是基于SpringBoot基础之上开发的微服务框架，SpringCloud是一套目前非常完整的微服务解决方案框架，其内容包含服务治理、注册中心、配置管理、断路器、智能路由、微代理、控制总线、全局锁、分布式会话等，都可以用 spring boot 的开发风格做到一键启动和部署。spring cloud 并没有重复制造轮子，它只是将目前各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过 spring boot 风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。
使用 spring cloud 一站式解决方案能在从容应对业务发展的同时大大减少开发成本。

springcloud组件

SpringCloud netflix 核心组件：

1. Eureka服务治理：注册中心，服务注册和发现
2. Ribbon客户端负载均衡：负载均衡、请求重试
3. Hystrix断路器：服务保护框架，服务降级、熔断
4. Feign：基于ribbon和hystrix集成的声明式、模板化的HTTP客户端
5. Zuul服务网关：在云平台上提供动态路由,监控,弹性,安全等边缘服务的框架。提供微服务的统一入口，并提供统一的权限验证。

SpringCloud config 分布式配置中心

hystrix dashboard 和 turbine： hystrix 微服务监控

bus：消息总线, 配置刷新

sleuth+zipkin：链路跟踪

微服务架构为什么选择使用springcloud?

• SpringCloud提供了一整套微服务解决方案(全家桶)
• 如果学习其他微服务框架(dubbo),需要整合其他框架帮你解决微服务问题。

分布式、微服务、云架构图

JAVA语言开发、跨平台、高性能、高可用、安全、服务化、模块化、组件化、驱动式开发模式

本文SpringCloud版本选用当前最新版

• SpringBoot：2.2.1.RELEASE
• SpringCloud：Hoxton.RC2

---

二、Eureka 服务治理

服务治理

在传统rpc远程调用中，服务与服务依赖关系，管理比较复杂，所以需要使用服务治理，管理服务与服务之间依赖关系，可以实现服务调用、负载均衡、容错等，实现服务发现与注册。

服务注册与发现

• 在服务注册与发现中，有注册中心
• 当服务器启动的时候，会把当前自己服务器的通讯地址等以别名方式注册到注册中心上。
• 另一方（消费者|服务提供者），以该别名的方式去注册中心上获取到实际的服务通讯地址，然后在实现rpc调用。
• 服务每30秒发送一次心跳数据；服务每30秒重新从eureka拉取注册表
• eureka连续三次收不到心跳数据,会认为微服务挂了
• 一个服务不可用时,eureka会进入保护模式,不删除该服务的注册信息

RPC远程调用框架核心设计思想:在于注册中心,因为使用注册中心管理每个服务与服务之间的一个依赖关系(服务治理概念)。

服务提供者：提供服务接口的

服务消费者：调用别人接口进行使用的

注册中心概念：存放服务地址相关信息(接口地址)

服务注册：将服务信息注册到注册中心上

服务发现：从注册中心上获取服务信息。

实现服务注册与发现的过程：

1. 首先启动注册中心
2. 再启动服务
3. 服务启动,会把当前服务基本信息比如服务地址和端口以别名方式注册到注册中心上(首先会缓存在JVM中,默认情况Eureka没隔30秒更新一次服务调用地址)
4. 消费者在调用接口的时候,是用服务别名去注册中心上获取实际rpc远程调用地址，每30秒重新从eureka拉取注册表
5. 获取实际rpc远程调用到地址之后,在使用本地HTTPClient技术实现调用

Eureka与Zookeeper的区别

1. 分布式原则：A:可用性；C：一致性。两个只能保证一个
   • Eureka是AP，强调可用性
   • Zookeeper是CP，强调一致性
2. 集群：
   • Eureka集群：对等结构
   • Zookeeper集群：主从结构

Springcloud中支持以下三种注册中心：Eureka、Consul（GO编写）、Zookeeper
Dubbo常用：Redis、zookeeper

搭建Eureka注册中心

1. 创建eureka模块

2. 配置依赖 pom.xml ：eureka-server

   
   <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   	<modelVersion>4.0.0modelVersion>
   	<parent>
   		<groupId>org.springframework.bootgroupId>
   		<artifactId>spring-boot-starter-parentartifactId>
   		<version>2.2.1.RELEASEversion>
   		<relativePath/> 
   	parent>
   	<groupId>com.jtgroupId>
   	<artifactId>eurekaartifactId>
   	<version>0.0.1-SNAPSHOTversion>
   	<name>eurekaname>
   	<description>Demo project for Spring Bootdescription>
   
   	<properties>
   		<java.version>1.8java.version>
   		<spring-cloud.version>Hoxton.RC2spring-cloud.version>
   	properties>
   
   	<dependencies>
   		<dependency>
   			<groupId>org.springframework.cloudgroupId>
   			<artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
   		dependency>
   
   		<dependency>
   			<groupId>org.springframework.bootgroupId>
   			<artifactId>spring-boot-starter-testartifactId>
   			<scope>testscope>
   			<exclusions>
   				<exclusion>
   					<groupId>org.junit.vintagegroupId>
   					<artifactId>junit-vintage-engineartifactId>
   				exclusion>
   			exclusions>
   		dependency>
   	dependencies>
   
   	<dependencyManagement>
   		<dependencies>
   			<dependency>
   				<groupId>org.springframework.cloudgroupId>
   				<artifactId>spring-cloud-dependenciesartifactId>
   				<version>${spring-cloud.version}version>
   				<type>pomtype>
   				<scope>importscope>
   			dependency>
   		dependencies>
   	dependencyManagement>
   
   	<build>
   		<plugins>
   			<plugin>
   				<groupId>org.springframework.bootgroupId>
   				<artifactId>spring-boot-maven-pluginartifactId>
   			plugin>
   		plugins>
   	build>
   
   	<repositories>
   		<repository>
   			<id>spring-milestonesid>
   			<name>Spring Milestonesname>
   			<url>https://repo.spring.io/milestoneurl>
   		repository>
   	repositories>
   project>
   

3. 配置 application.yml：详细配置看下面的高可用集群

   • spring.application.name：配置服务名
   • server.port：服务端口号
   • spring.profiles：特定的配置文件名
   • eureka.instance.hostname 区分eureka 集群服务器
   • eureka.server.enable-self-preservation：eureka 的自我保护状态：心跳失败的比例，在15分钟内是否低于85%,如果出现了低于的情况，Eureka Server会将当前的实例注册信息保护起来，同时提示一个警告，一旦进入保护模式，Eureka Server将会尝试保护其服务注册表中的信息，不再删除服务注册表中的数据。也就是不会注销任何微服务
   • eureka.client.register-with-eureka=false：不向自身注册，默认为true
   • eureka.client.fetch-registry=false：不从自身拉取注册信息，默认为true
   • eureka.instance.lease-expiration-duration-in-seconds：最后一次心跳后，间隔多久认定微服务不可用，默认90秒

4. 修改 hosts 文件，添加 eureka 域名映射

5. 主程序启用 eureka 服务器：添加@EnableEurekaServer注解

6. 启动，访问测试

搭建Eureka注册中心集群-高可用

在微服务中，注册中心非常核心，可以实现服务治理，如果一旦注册出现故障的时候，可能会导致整个微服务无法访问，在这时候就需要对注册中心实现高可用集群模式。

原理：

Eureka高可用实际上将自己作为服务向其他服务注册中心注册自己，这样就可以形成一组相互注册的服务注册中心，从而实现服务清单的互相同步，达到高可用效果。

1. application.yml：使用spring.profiles属性配置不同的配置

spring:
  application:
    name: eureka-server

eureka:
  server:
    enable-self-preservation: false

---
spring:
  profiles: eureka1
server:
  port: 2001
eureka:
  instance:
    hostname: eureka1
  client:
    service-url:
      defaultZone: http://eureka2:2002/eureka
---
spring:
  profiles: eureka2
server:
  port: 2002

eureka:
  instance:
    hostname: eureka2
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka

2. 配置启动参数：–spring.profiles.active

   配置Program arguments：–spring.profiles.active=eureka1

   将eureka启动项 复制，再配置启动参数：–spring.profiles.active=eureka2

   本次只演示两个注册中心集群，依次类推，搭建集群最好三个以上！！！

搭建服务提供者

1. 创建服务

2. pom.xml 添加eureka 客户端依赖

   <dependency>
   	<groupId>org.springframework.cloudgroupId>
   	<artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
   dependency>
   

3. application.yml 添加eureka注册配置

   • eureka.instance.lease-renewal-interval-in-seconds： 心跳间隔时间，默认 30 秒
   • eureka.client.registry-fetch-interval-seconds： 拉取注册信息间隔时间，默认 30 秒
   • defaultZone ： 表示 eureka 注册中心的部署位置

   eureka:
     client:
       service-url:
         defaultZone: http://eureka1:2001/eureka,http://eureka2:2002/eureka
   

4. 主程序启用eureka客户端：添加 @EnableDiscoveryClient注解

5. 启动服务，在eureka中查看注册信息

---

三、ribbon客户端负载均衡

用于服务消费者，ribbon 提供了负载均衡和重试功能

ribbon在RestTemplate对象上切入了代码,添加负载均衡和重试的代码

pom.xml ：eureka-client 中已经包含 ribbon 依赖

负载均衡

1. 在主程序里 ：创建RestTemplate实例

   RestTemplate 是用来调用其他微服务的工具类，封装了远程调用代码，提供了一组用于远程调用的模板方法，例如：getForObject()、postForObject()等

2. 在RestTemplate上设置@LoadBalanced注解

   @LoadBalanced 负载均衡注解，会对 RestTemplate 实例进行封装，创建动态代理对象，并切入（AOP）负载均衡代码，把请求分散分发到集群中的服务器

   @EnableDiscoveryClient
   @SpringBootApplication
   public class ribbonApplication {
   	
   	@LoadBalanced //负载均衡注解
   	@Bean
   	public RestTemplate getRestTemplate() {
   		return new RestTemplate();
   	}
   
   	public static void main(String[] args) {
   		SpringApplication.run(ribbonApplication.class, args);
   	}
   
   }
   

3. 在Controller中使用RestTemplate实例的getForObject()方法，进行RPC

   访问路径设置为服务id，getForObject(url,class)

   @Controller
   public class RibbonController {
       @Autowired
       private RestTemplate rt;
       
       @RequestMapping("testRPC")
       public String test() {
           return rt.getForObject("http://服务名称（spring.application.name）：端口", String.class);
       }
   }
   

重试

调用后台服务时失败,可以自动重试调用

当超时，ribbon 会重试请求集群中其他服务器

ribbon的重试机制，在 feign 和 zuul 中进一步进行了封装，后续可以使用feign或zuul的重试机制

1. pom.xml 添加 spring-retry依赖

   <dependency>
   	<groupId>org.springframework.retrygroupId>
   	<artifactId>spring-retryartifactId>
   dependency>
   

2. application.yml 配置 ribbon 重试

   • ribbon.MaxAutoRetriesNextServer： 向后重试几台服务器
   • ribbon.MaxAutoRetries ： 当前实例重试次数，尝试失败会更换下一个实例
   • OkToRetryOnAllOperations=true ： 对连接超时、读取（get\post）超时都进行重试 , 默认false,只对get请求重试

3. 主程序设置 RestTemplate 的请求工厂的超时属性： 要写java代码来设置下面两个参数

   ConnectionTimeout： 连接超时

   ReadTimeout： 接收响应超时

   RestTemplate 中默认的 Factory 实例中，两个超时属性默认是 -1

   未启用超时，也不会触发重试

   @EnableDiscoveryClient
   @SpringBootApplication
   public class ribbonApplication {
   
   	@LoadBalanced
   	@Bean
   	public RestTemplate getRestTemplate() {
   		SimpleClientHttpRequestFactory f = new SimpleClientHttpRequestFactory();
   		f.setConnectTimeout(1000); //1秒
   		f.setReadTimeout(1000);    //1秒
   		return new RestTemplate(f);
   	}
   
   	public static void main(String[] args) {
   		SpringApplication.run(ribbonApplication.class, args);
   	}
   
   }
   

---

四、hystrix 断路器

官方文档：https://github.com/Netflix/Hystrix/wiki

hystrix 断路器的作用：降级和熔断

降级：超时、出错、不可到达时，对服务降级，返回错误信息或者是缓存数据 。

熔断：当服务压力过大，错误比例过多时，熔断所有请求，所有请求直接降级 。

整个链路达到一定的阈值，默认情况下，10秒内产生超过20次请求，则符合第一个条件。 满足第一个条件的情况下，如果请求的错误百分比大于阈值，则会打开断路器，默认为50%。

Hystrix的逻辑，先判断是否满足第一个条件，再判断第二个条件，如果两个条件都满足，则会开启断路器。

断路器打开 5 秒后，会处于半开状态，会尝试转发请求，如果仍然失败，保持打开状态，如果成功，则关闭断路器 。

案例：

1. pom.xml：添加 hystrix 起步依赖

   <dependency>
   	<groupId>org.springframework.cloudgroupId>
   	<artifactId>spring-cloud-starter-netflix-hystrixartifactId>
   dependency>
   

2. 主程序添加@EnableCircuitBreaker 注解

   可以使用 @SpringCloudApplication 注解代替三个注解：

   @EnableCircuitBreaker 作用：启动hystrix断路器

   @EnableDiscoveryClient 作用：发现服务

   @SpringBootApplication 作用：标记springboot启动类

3. Controller 中的方法上添加降级方法

   添加 @HystrixCommand 注解，指定降级方法名

   @Controller
   public class RibbonController {
       @Autowired
       private RestTemplate rt;
       
       @RequestMapping("testRPC")
       @HystrixCommand(fallbackMethod = "testHystrix") //指定降级方法的方法名
       public String test() {
           return rt.getForObject("http://服务名称（spring.application.name）：端口", String.class);
       }
       
       public String testHystrix() {
           return "获取失败";
       }
   }
   

4. hystrix 短路超时设置，编辑application.yml

   hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds： 请求超时时间，超时后触发失败降级

   此设置一般应大于 ribbon 的重试超时时长，例如 10 秒

   为了测试可以，讲等待超时设置的很小 （500毫秒）

   hystrix:
     command:
       default:
         execution:
           isolation:
             thread:
               timeoutInMilliseconds: 500
   

hystrix 配置

配置详细： https://github.com/Netflix/Hystrix/wiki/Configuration

hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds： 请求超时时间，超时后触发失败降级

hystrix.command.default.circuitBreaker.requestVolumeThreshold： 10秒内请求数量，默认20，如果没有达到该数量，即使请求全部失败，也不会触发断路器打开

hystrix.command.default.circuitBreaker.errorThresholdPercentage： 失败请求百分比，达到该比例则触发断路器打开

hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds： 断路器打开多长时间后，再次允许尝试访问（半开），仍失败则继续保持打开状态，如成功访问则关闭断路器，默认 5000

hystrix dashboard 断路器仪表盘

仪表盘项目是一个独立的项目,不需要向Eureka注册信息

hystrix 对请求的熔断和断路处理，可以产生监控信息，hystrix dashboard可以实时的进行监控 。

添加 actuator，暴露 hystrix 监控端点

1. 添加actuator 依赖

   <dependency>
   	<groupId>org.springframework.bootgroupId>
   	<artifactId>spring-boot-starter-actuatorartifactId>
   dependency>
   

2. 配置application.yml ,暴露hystrix 监控端点

   management:
     endpoints:
       web:
         exposure:
           include: hystrix.stream
   

3. 添加hystrix-dashboard依赖

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

4. 主程序添加 @EnableHystrixDashboard注解

5. 访问 hystrix dashboard： http://localhost:8080/hystrix

6. 填入 hystrix 的监控端点，开启监控： http://localhost:8080/actuator/hystrix.stream

断路器状态为 Open，所有请求会被短路，直接降级执行 fallback 方法

---

七、Zuul服务网关

网关作用

• 反向路由：很多时候，公司不想让外部人员看到我们公司的内部，就需要网关来进行反向路由。即将外部请求转换成内部具体服务调用。
• 安全认证：网络中会有很多恶意访问，譬如爬虫，譬如黑客攻击，网关维护安全功能。
• 限流熔断：当请求很多服务不堪重负，会让我们的服务自动关闭，导致不能用服务。限流熔断可以有效的避免这类问题。
• 日志监控：所有的外面的请求都会经过网关，这样我们就可以使用网关来记录日志信息。
• 灰度发布，蓝绿部署：是指能够平滑过渡的一种发布方式。在其上可以进行 A/B testing。

Zuul API 网关，为微服务应用提供统一的对外访问接口。

Zuul 还提供过滤器，对所有微服务提供统一的请求校验。

Zuul自带ribbon和hystrix以及 actuator

ribbon :

• 默认启用负载均衡
• 重试 :添加 spring-retry 依赖 ;yml配置zuul.retryable=true;

hystrix :

• 降级 : 继承 FallbackProvider, 在子类中, 来设置项客户端返回的响应数据

  getRoute() 方法中指定应用此降级类的服务id，星号或null值可以通配所有服务

• 熔断：暴露的监控端点 ，使用 turbine 聚合 或者 hystrix-dashboard进行查看

Zuul的过滤器：

• 做权限验证
• 只在api网关编写权限判断代码,后台服务中不必做权限判断
• 继承 ZuulFilter 父类,来实现过滤代码

网关 Zuul 架构：

Zuul 网关核心其实是一个 Servlet，所有请求都会经过 Zuul Servlet 传到 ZuulFilter Runner，然后分发到三种过滤器。
左半部分分别是使用 Groovy 实现的前置路由过滤器，路由过滤器，后置路由过滤器。
右半部分，是 Zuul 网关设计的自定义过滤器加载机制。
网关内部会有生产者消费者模型，自动的将过滤器脚本发布到 Zuul 网关读取加载运行。

1. 创建Zuul项目,pom.xml添加zuul依赖

   
   <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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0modelVersion>
       <parent>
           <groupId>org.springframework.bootgroupId>
           <artifactId>spring-boot-starter-parentartifactId>
           <version>2.2.1.RELEASEversion>
           <relativePath/> 
       parent>
       <groupId>com.jtgroupId>
       <artifactId>zuulartifactId>
       <version>0.0.1-SNAPSHOTversion>
       <name>zuulname>
       <description>Demo project for Spring Bootdescription>
   
       <properties>
           <java.version>1.8java.version>
           <spring-cloud.version>Hoxton.RELEASEspring-cloud.version>
       properties>
   
       <dependencies>
           <dependency>
               <groupId>org.springframework.cloudgroupId>
               <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
           dependency>
           <dependency>
               <groupId>org.springframework.cloudgroupId>
               <artifactId>spring-cloud-starter-netflix-zuulartifactId>
           dependency>
           <dependency>
               <groupId>org.springframework.retrygroupId>
               <artifactId>spring-retryartifactId>
           dependency>
           <dependency>
               <groupId>org.springframework.bootgroupId>
               <artifactId>spring-boot-starter-testartifactId>
               <scope>testscope>
               <exclusions>
                   <exclusion>
                       <groupId>org.junit.vintagegroupId>
                       <artifactId>junit-vintage-engineartifactId>
                   exclusion>
               exclusions>
           dependency>
       dependencies>
   
       <dependencyManagement>
           <dependencies>
               <dependency>
                   <groupId>org.springframework.cloudgroupId>
                   <artifactId>spring-cloud-dependenciesartifactId>
                   <version>${spring-cloud.version}version>
                   <type>pomtype>
                   <scope>importscope>
               dependency>
           dependencies>
       dependencyManagement>
   
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.bootgroupId>
                   <artifactId>spring-boot-maven-pluginartifactId>
               plugin>
           plugins>
       build>
   
   project>
   
   

2. applicatoin.yml： zuul 路由配置可以省略，缺省以服务 id 作为访问路径

   开启重试和暴露监控端点

   spring:
     application:
       name: zuul
   
   server:
     port: 3001
   eureka:
     client:
       service-url:
         defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
   zuul:
     retryable: true
   management:
     endpoints:
       web:
         exposure:
           include: hystrix.stream
   
   

3. 主程序添加：@EnableZuulProxy 注解

   @EnableDiscoveryClient
   @EnableZuulProxy
   @SpringBootApplication
   public class Sp11ZuulApplication {
       public static void main(String[] args) {
           SpringApplication.run(Sp11ZuulApplication.class, args);
       }
   }
   
   

4. 创建降级类：

   • 继承 FallbackProvider, 在子类中, 来设置项客户端返回的响应数据
   • 在类上加上@Component注解,交给spring容器管理

5. zuul 请求过滤：

定义过滤器，继承 ZuulFilter

注意：实现权限拦截；在重写filterOrder方法时， 该过滤器顺序要 > 5，才能得到 serviceid

Zuul 和 Feign的区别

• Feign 用来在微服务之间调用
• Zuul 在最前面,作为统一的入口

---

随手笔记

1.注解@EnableDiscoveryClient和@EnableEurekaClient的区别

1. @EnableDiscoveryClient 注解是基于 spring-cloud-commons 依赖，并且在classpath中实现；
2. @EnableEurekaClient 注解是基于 spring-cloud-netflix 依赖，只能为eureka作用；

如果在classpath中添加了eureka，则它们的作用是一样的。

2.actuator监控工具

actuator 是 spring boot 提供的服务监控工具，提供了各种监控信息的监控端点

1. pom.xml 添加 actuator 依赖

   <dependency>
   	<groupId>org.springframework.bootgroupId>
   	<artifactId>spring-boot-starter-actuatorartifactId>
   dependency>
   

2. application.yml 配置,暴露所有监控断点

   management:
     endpoints:
       web:
         exposure:
           include: "*"  #暴露所有监控断点
   

3. 访问 actuator 路径，查看监控端点

   http://localhost:8080/actuator

3.apache 的并发访问测试工具 ab

下载: http://httpd.apache.org/docs/current/platform/windows.html#down

使用方式 :

例如:用 ab 工具，每次以并发50次，来发送20000个请求

1. 在D:\httpd-2.4.39-o102r-x86-vc14\Apache24\bin目录中运行CMD
2. 执行:ab -n 20000 -c 50 http://localhost:8080/item-service/

4.Spring Boot配置特定属性spring.profiles

1. 配置yml文件

   使用---分开不同的配置信息

   #公用的配置
   spring:
     application:
       name: test-spring-profiles
   ---
   spring:
     profiles: p1 #配置文件名，后面配置启动参数的时候用
   ---
   spring:
     profiles: p2 
   

2. 修改启动参数：--spring.profiles.active

   例：配置Program arguments：--spring.profiles.active=p1

---

八、Config 配置中心

集中管理维护配置文件

• 默认 git 存储 （修改公共配置，spring.profiles配置不生效）

• 也可以用本地存储或数据库存储

框架图：

入门案例（git）

1. 创建config项目，将各服务的yml配置文件放入进去，通过git上传到GitHub的config仓库

   命名规则：服务名字+dev(开发环境)\test（测试环境）\prod（生产环境）

config 服务器:

config 配置中心从 git 下载所有配置文件。

微服务启动时，从 config 配置中心获取配置信息。

2. 创建config项目， pom.xml添加config server依赖

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.2.1.RELEASEversion>
        <relativePath/> 
    parent>
    <groupId>com.jtgroupId>
    <artifactId>configartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>configname>
    <description>Demo project for Spring Bootdescription>

    <properties>
        <java.version>1.8java.version>
        <spring-cloud.version>Hoxton.RELEASEspring-cloud.version>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-config-serverartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-bus-amqpartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintagegroupId>
                    <artifactId>junit-vintage-engineartifactId>
                exclusion>
            exclusions>
        dependency>
    dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-dependenciesartifactId>
                <version>${spring-cloud.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>

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

project>

3. 编辑application.yml：配置 git 连接信息

spring:
  application:
    name: config-server

  cloud:
    config:
      server:
        git:
          uri: https://github.com/q850717441/config
          searchPaths: config
          #username: your-username
          #password: your-password
          
server:
  port: 6001

eureka:
  client:
    service-url:
      defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka

management:
  endpoints:
    web:
      exposure:
        include: bus-refresh

4. 主程序添加@EnableConfigServer 和 @EnableDiscoveryClient

config 客户端：服务项目从配置中心获取配置信息

5. pom.xml 添加 config 客户端依赖

   <dependency>
   	<groupId>org.springframework.cloudgroupId>
   	<artifactId>spring-cloud-starter-configartifactId>
   dependency>
   

6. 服务项目中添加bootstrap.yml： 引导配置文件，先于 application.yml加载

   #配置连接配置中心服务器
   spring: 
     cloud:
       config:
         discovery:
           enabled: true
           service-id: config-server
         name: test-service     #下载哪个配置文件
         profile: dev
   
   eureka:
     client:
       service-url:
         defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
   
   

7. 下载的配置文件,会和本地配置文件合并加载 , 配置中心的配置优先级高

配置动态刷新

spring cloud 允许运行时动态刷新配置，可以重新加载本地配置文件 application.yml，或者从配置中心获取新的配置信息

1. 服务项目中 pom.xml 中添加 actuator 依赖

   <dependency>
   	<groupId>org.springframework.bootgroupId>
   	<artifactId>spring-boot-starter-actuatorartifactId>
   dependency>
   

2. 服务项目修改 yml 配置文件：暴露 refresh 端点

  management:
    endpoints:
      web:
        exposure:
          include: refresh

3. 需要注入配置数据的对象,添加 @RefreshScope 注解

只允许对添加了 @RefreshScope 或 @ConfigurationProperties 注解的 Bean 刷新配置，可以将更新的配置数据注入到 Bean 中

4. 修改 github 仓库中的 配置

5. 使用 postman 向刷新端点发送 post 请求 ：http://localhost:端口/actuator/refresh

config 本地文系统

1. 把配置文件保存在配置中心服务的resources 目录下，直接访问本地文件

2. 修改 application.yml 激活 native profile，并指定配置文件目录

   必须配置 spring.profiles.active=native 来激活本地文件系统

   本地路径默认：[classpath:/, classpath:/config, file:./, file:./config]

   spring:
     application:
       name: config-server
     profiles:
       active: native
     cloud:
       config:
         server:
           native:
             search-locations: classpath:/config
   

---

九、config bus + rabbitmq 消息总线配置刷新

post 请求消息总线刷新端点，服务器会向 rabbitmq 发布刷新消息，接收到消息的微服务会向配置服务器请求刷新配置信息

多台服务器的动态刷新 ：

1. 通过一台服务器暴露bus-refresh刷新端点

2. post请求 bus-refresh,会向消息总线发送一条"刷新指令"

3. 消息总线会把"刷新指令"群发给多台服务器

4. 收到指令的服务器,执行刷新操作(连接配置中心,下载新的配置)

架构图：

---

1. 需要动态更新配置的微服务，添加 spring cloud bus 依赖，并yml配置文件中添加 rabbitmq 连接信息

   		<dependency>
               <groupId>org.springframework.bootgroupId>
               <artifactId>spring-boot-starter-amqpartifactId>
           dependency>
           <dependency>
               <groupId>org.springframework.cloudgroupId>
               <artifactId>spring-cloud-busartifactId>
           dependency>
           <dependency>
               <groupId>org.springframework.cloudgroupId>
               <artifactId>spring-cloud-stream-binder-rabbitartifactId>
           dependency>
           <dependency>
               <groupId>org.springframework.amqpgroupId>
               <artifactId>spring-rabbit-testartifactId>
               <scope>testscope>
           dependency>
   

   spring:
     rabbitmq:
        host: 192.168.64.5
        port: 5672
        username: admin
        password: admin
   

2. config-server 添加 spring cloud bus 依赖、配置rabbitmq连接信息，并暴露 bus-refresh 监控端点

   spring:
     application:
       name: config-server
   
     cloud:
       config:
         server:
           git:
             uri: https://github.com/q850717441/config
             searchPaths: config
             #username: your-username
             #password: your-password
     rabbitmq:
       host: 192.168.64.5
       port: 5672
       username: admin
       password: admin
   
   server:
     port: 6001
   
   eureka:
     client:
       service-url:
         defaultZone: http://eureka1:2001/eureka, http://eureka2:2002/eureka
   
   management:
     endpoints:
       web:
         exposure:
           include: bus-refresh
   

---

十、sleuth +zipkin 链路跟踪和分析

spring cloud sleuth 可以跟踪调用链路，分析链路中每个节点的执行情况

zipkin 可以收集链路跟踪数据，提供可视化的链路分析

sleuth 产生链路跟踪数据,并发送到rabbitmq ，zipkin 从rabbitmq 中获取数据

当服务被调用时，可以在控制台查看链路跟踪日志：

[服务id,请求id,span id,是否发送到zipkin]

• 请求id：请求到达第一个微服务时生成一个请求id，该id在调用链路中会一直向后面的微服务传递

• span id：链路中每一步微服务调用，都生成一个新的id

链路数据抽样比例：默认 10% 的链路数据会被发送到 zipkin 服务。在yml中可以配置修改抽样比例

spring:
  sleuth:
    sampler:
      probability: 0.1

下载 zipkin 服务器

https://github.com/openzipkin/zipkin

启动 zipkin 时，连接到 rabbitmq：

java -jar zipkin-server-2.12.9-exec.jar --zipkin.collector.rabbitmq.uri=amqp://admin:[email protected]:5672

zipkin 服务器地址： http://localhost:9411/zipkin

入门案例

1. 服务pom.xml,添加 sleuth、 zipking client

           <dependency>
               <groupId>org.springframework.cloudgroupId>
               <artifactId>spring-cloud-starter-sleuthartifactId>
           dependency>
           <dependency>
               <groupId>org.springframework.cloudgroupId>
               <artifactId>spring-cloud-starter-zipkinartifactId>
           dependency>
   

2. 启动 zipkin 时，连接到 rabbitmq:

java -jar zipkin-server-2.12.9-exec.jar --zipkin.collector.rabbitmq.uri=amqp://admin:[email protected]:5672

3. 访问zipkin服务器： http://localhost:9411/zipkin