第七章 SpringCloudConfig解析笔记

向右看齐 2023-07-18 06:47 28阅读 0赞

## **一、分布式配置中心** ##

讲解Zookeeper的时候其实实现过分布式的配置中心，SpringCloudConfig的核心作用其实就是在于对配置进行管理。虽然springcloud使用springboot进行开发，节省了大量的配置文件，但每个服务依然有自己的application.yml配置文件，而且每个服务一般都有负载均衡，所以这种依赖对于配置文件的统一管理就非常有必要了。

下图是SpringCloudConfig总体结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70][]

左边这一块我们很熟悉，最开始有个eureka，它通过配置文件application.yml启动，在这个配置文件里面会指定端口、实例名、注册地址等。对于服务提供商来说，它也需要把相关信息写到application.yml文件中，比如数据库配置、端口、项目名称等，其中最重要的就就是要指定eureka的具体位置。

这是前面反复说过的，但现在是基于SpringCloudConfig的配置中心，最开始启动eureka的时候，eureka的具体配置就不是写死在eureka的application.yml文件中了，这个时候也会有application.yml（bootstrap.yml）配置文件，只是这里的配置指定的时候config的配置中心，在eureka启动的时候读取【配置中心】的配置，并启动。

对于服务提供商也是同样的道理，以产品服务为例，它的application.yml文件也不在指定具体的配置，真实需要访问的数据库，端口等信息也是在启动的时候直接从【配置中心】读取。所以说config配置中心在其中占据非常重要的位置，但config里面的配置从哪来呢？其实是从git服务器里面来的，开发者需要把相关的配置上传到git服务器，这里的git服务器可以自己搭建，也可以直接用github，后面项目为了方便就直接使用github了。

代码Git地址：https://gitee.com/hankin\_chj/springcloud-micro-service.git

### **1、准备github账号** ###

1）[https://github.com/][https_github.com]  注册就不说了（这里使用码云代替），创建一个仓库springcloud-micro-config。

2）获得git的地址https://gitee.com/hankin\_chj/springcloud-micro-config.git

3）把新建的仓库信息下载倒本地：D:\\project\\springcloud\\springcloud-micro-config。

### **2、配置中心搭建** ###

有了git服务器之后，接下来就要准备配置中心了，新建一个配置中心的服务提供模块springcloud-micro-config

**2.1、pom文件如下：**

<**dependencies**> 
    <**dependency**> 
        <**groupId**>org.springframework.cloud</**groupId**> 
        <**artifactId**>spring-cloud-config-server</**artifactId**> 
    </**dependency**> 
    <**dependency**> 
        <**groupId**>com.chj</**groupId**> 
        <**artifactId**>springcloud-micro-security</**artifactId**> 
    </**dependency**> 
</**dependencies**>

引入springcloudserver的同时，这分布式配置中心也不是谁都能访问的，所以增加了安全验证模块。应该还记得这时候的用户名密码为：admin/admin。

**2.2、config模块新增application.yml配置文件，增加git连接配置信息**

**server**:  
  **port**: 7101  
**spring**:  
  **application**:  
    **name**: springcloud-micro-config  
  **cloud**:  
    **config**:  
      **server**:  
        **git**:  
          **uri**: https://gitee.com/hankin\_chj/springcloud-micro-config.git

**2.3、config模块新增启动类**

@SpringBootApplication  
@EnableConfigServer  
**public class** ConfigApp \{   
    **public static void** main(String\[\] args) \{   
        SpringApplication.run(ConfigApp.**class**,args);  
    \}  
\}

这些工作准备完成后，为了测试config模块是能正确运行的，还需要上传个配置文件到github。

**2.4、上传一个application.yml到GitHub**

**spring**:  
  **profiles**:  
    **active**:  
      - dev  
**spring**:  
  **profiles**: dev  
  **application**:  
    **name**: springcloudmicro-config-test-dev  
**spring**:  
  **profiles**: default  
  **application**:  
    **name**: springcloud-micro-config-test-default

**2.5、准备好配置文件后启动config服务**

<table style="margin-left:5.35pt;width:395.6pt;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:36.4pt;"> NO </td> 
 <td style="vertical-align:top;width:136.8pt;"> 访问形式 </td> 
 <td style="vertical-align:top;width:222.4pt;"> 访问路径 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:36.4pt;"> 1 </td> 
 <td style="vertical-align:top;width:136.8pt;"> /{application}-{profile}.yml </td> 
 <td style="vertical-align:top;width:222.4pt;"> <a href="http://localhost:7101/application-dev.yml" rel="nofollow">http://localhost:7101/application-dev.yml</a> <a href="http://localhost:7101/application-default.yml" rel="nofollow">http://localhost:7101/application-default.yml</a> <a href="http://localhost:7101/application-beta.yml" rel="nofollow">http://localhost:7101/application-beta.yml</a>&nbsp;不存在 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:36.4pt;"> 2 </td> 
 <td style="vertical-align:top;width:136.8pt;"> /{application}/{profile}[/{label}] </td> 
 <td style="vertical-align:top;width:222.4pt;"> <a href="http://localhost:7101/application/dev/master" rel="nofollow">http://localhost:7101/application/dev/master</a> http://localhost:7101/application/default/master </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:36.4pt;"> 3 </td> 
 <td style="vertical-align:top;width:136.8pt;"> /{label}/{application}-{profile}.yml </td> 
 <td style="vertical-align:top;width:222.4pt;"> <a href="http://localhost:7101/master/application-default.yml" rel="nofollow">http://localhost:7101/master/application-default.yml</a> http://localhost:7101/master/application-dev.yml </td> 
 </tr> 
 </tbody> 
</table>

访问地址：[http://localhost:7101/application-dev.yml][http_localhost_7101_application-dev.yml]

访问地址：[http://localhost:7101/master/application-dev.yml][http_localhost_7101_master_application-dev.yml]

返回结果：

spring:

application:

name: springcloudmicroconfig-test-dev

profiles:

active:

- dev

### **3、简单的客户端** ###

现在已经成功的搭建好了配置中心，但这个时候如果只通过url的访问形式其实没什么太多的意义，最终还是需要把github相关信息加载到客户端上进行访问。

新增加一个【springcloud-micro-config-client】模块，这模块讲读取github里面的信息，也不做其他的事情，只是显示一下。

**3.1、pom文件如下**

github上传一个新的配置文件springcloud-micro-config-client.yml，后面就通过程序来读取这个配置

**spring**:  
  **profiles**:  
    **active**:  
      - dev  
\---  
**server**:  
  **port**: 8201  
**spring**:  
  **profiles**: dev  
  **application**:  
    **name**: springcloudmicro-test-client  
**eureka**:  
  **client**:  
    **service-url**:  
      **defaultZone**: http://admin:admin@localhost:7001/eureka  
\---  
**server**:  
  **port**: 8102  
**spring**:  
  **profiles**: beta  
  **application**:  
    **name**: springcloudmicro-test-client  
**eureka**:  
  **client**:  
    **service-url**:  
      **defaultZone**: http://admin:admin@localhost:7001/eureka

**3.2、新建bootstrap.yml文件，这文件读取配置中心的配置**

可能有些人奇怪，为什么不直接把相关信息写道application.yml文件之中，其实这是一种规范

“application.yml”：对应的是用户级的资源配置项；

“bootstrap.yml”：对应的是系统级的资源配置，其优先级更高。

**3.3、新建application.yml文件**

这文件只是简单的配置一个应用名称

**spring**:  
  **application**:  
    **name**: springcloud-micro-config-client *\# 编写应用的名称*

**3.4、新建一个controller**

这个controller显示从服务器下载到的配置文件，注意@value里面的值一定要与配置文件里面一致。

@RestController  
**public class** ConfigClientController \{   
    @Value(**"$\{spring.application.name\}"**)  
    **private** String **applicationName**;  
    @Value(**"$\{eureka.client.service-url.defaultZone\}"**)  
    **private** String **eurekaServers**;  
    @RequestMapping(**"/config"**)  
    **public** String getConfig() \{   
        **return** **"ApplicationName = "** \+ **this**.**applicationName** \+ **"、EurekaServers = "**\+ **this**.**eurekaServers**;  
    \}  
\}

**3.5、新建一个启动类**

@SpringBootApplication  
**public class** ConfigClientApp \{   
    **public static void** main(String\[\] args) \{   
        SpringApplication.run(ConfigClientApp.**class**,args);  
    \}  
\}

启动配置中心，访问，确认配置通过url是能正常访问的。

[http://localhost:7101/springcloud-micro-config-client-beta.yml][http_localhost_7101_springcloud-micro-config-client-beta.yml]

eureka:

client:

service-url:

defaultZone: http://admin:admin@localhost:7001/eureka

server:

port: 8102

spring:

application:

name: springcloudmicro-test-client

profiles:

active:

- dev

启动config-client服务发现tomcat启动了，占用的端口就是dev的8201，

访问：[http://localhost:8201/config][http_localhost_8201_config]，返回结果如下：

ApplicationName =springcloudmicro-test-client、EurekaServers=http://admin:admin@localhost:7001/eureka

这个时候简单的客户端已经搭建完成。

### **4、Eureka与服务提供商读取配置** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1][]

有了上面这些基础，接下来就可以完成这个图的功能了，这里依然简化一下，只考虑product产品服务与eureka服务。eureka与product服务的配置信息要求去配置中心获取，所以在正式部署项目之前，先准备两个配置，上传到github之中。

**4.1、上传springcloud-config-eureka-client.yml配置文件**

springcloud-config-eureka-client.yml，这个是eureka的配置文件，这里就没有考虑eureka的高可用了

**spring**:  
  **profiles**:  
    **active**:  
      - dev  
\---  
**server**:  
  **port**: 7001  
**eureka**:  
  **server**:  
    **eviction-interval-timer-in-ms**: 1000   *\#设置清理的间隔时间，而后这个时间使用的是毫秒单位（默认是60秒）*  
*    ***enable-self-preservation**: false *\#设置为false表示关闭保护模式*  
*  ***client**:  
    **fetch-registry**: false  
    **register-with-eureka**: false  
    **service-url**:  
      **defaultZone**: http://admin:admin@localhost:7001/eureka  
  **instance**: *\# eureak实例定义*  
*    ***hostname**: localhost *\# 定义 Eureka 实例所在的主机名称*  
**spring**:  
  **profiles**: dev  
  **security**:  
    **user**:  
      **name**: admin  
      **password**: admin  
  **application**:  
    **name**: springcloud-micro-config-eureka-client  
\---  
**server**:  
  **port**: 7002  
**eureka**:  
  **server**:  
    **eviction-interval-timer-in-ms**: 1000   *\#设置清理的间隔时间，而后这个时间使用的是毫秒单位（默认是60秒）*  
*    ***enable-self-preservation**: false *\#设置为false表示关闭保护模式*  
*  ***client**:  
    **fetch-registry**: false  
    **register-with-eureka**: false  
    **service-url**:  
      **defaultZone**: http://admin:admin@localhost:7002/eureka  
  **instance**: *\# eureak实例定义*  
*    ***hostname**: localhost *\# 定义 Eureka 实例所在的主机名称*  
**spring**:  
  **profiles**: beta  
  **security**:  
    **user**:  
      **name**: admin  
      **password**: admin  
  **application**:  
    **name**: springcloud-micro-config-eureka-client

**4.2、上传springcloud-config-product-client.yml配置文件**

springcloud-config-product-client.yml，这个事对于产品服务这个服务提供商提供者的配置文件

**spring**:  
  **profiles**:  
    **active**:  
      - dev  
\---  
**server**:  
  **port**: 8080  
**mybatis**:  
  **mapper-locations**: *\# 所有的mapper映射文件*  
*    *\- classpath:mapping/\*.xml  
**spring**:  
  **datasource**:  
    **type**: com.alibaba.druid.pool.DruidDataSource *\# 配置当前要使用的数据源的操作类型*  
*    ***driver-class-name**: com.mysql.jdbc.Driver *\# 配置MySQL的驱动程序类*  
*    ***url**: jdbc:mysql://localhost:3306/springcloud?serverTimezone=GMT%2B8 *\# 数据库连接地址*  
*    ***username**: root *\# 数据库用户名*  
*    ***password**: root *\# 数据库连接密码*  
*  ***application**:  
    **name**: springcloud-config-product-client  
  **profiles**: dev  
**logging**:  
  **level**:  
    **com.chj.mapper**: debug  
**eureka**:  
  **client**: *\# 客户端进行Eureka注册的配置*  
*    ***service-url**:  
      **defaultZone**: http://admin:admin@localhost:7001/eureka  
  **instance**:  
    **instance-id**: springcloud-config-product-client  
    **prefer-ip-address**: true  
    **lease-renewal-interval-in-seconds**: 2 *\# 设置心跳的时间间隔（默认是30秒）*  
*    ***lease-expiration-duration-in-seconds**: 5  *\# 如果现在超过了5秒的间隔（默认是90秒）*  
**info**:  
  **app.name**: springcloud-config-product-client  
  **company.name**: hankin  
  **build.artifactId**: $project.artifactId$  
  **build.modelVersion**: $project.modelVersion$  
**management**:  
  **endpoints**:  
    **web**:  
      **exposure**:  
        **include**: **'\*'**  
\---  
**server**:  
  **port**: 8081  
**mybatis**:  
  **mapper-locations**: *\# 所有的mapper映射文件*  
*    *\- classpath:mapping/\*.xml  
**spring**:  
  **datasource**:  
    **type**: com.alibaba.druid.pool.DruidDataSource *\# 配置当前要使用的数据源的操作类型*  
*    ***driver-class-name**: com.mysql.jdbc.Driver *\# 配置MySQL的驱动程序类*  
*    ***url**: jdbc:mysql://localhost:3306/springcloud?serverTimezone=GMT%2B8 *\# 数据库连接地址*  
*    ***username**: root *\# 数据库用户名*  
*    ***password**: root *\# 数据库连接密码*  
*  ***application**:  
    **name**: springcloud-config-product-client  
  **profiles**: beta  
**logging**:  
  **level**:  
    **com.chj.mapper**: debug  
**eureka**:  
  **client**: *\# 客户端进行Eureka注册的配置*  
*    ***service-url**:  
      **defaultZone**: http://admin:admin@localhost:7002/eureka  
  **instance**:  
    **instance-id**: microcloud-config-product-client  
    **prefer-ip-address**: true  
    **lease-renewal-interval-in-seconds**: 2 *\# 设置心跳的时间间隔（默认是30秒）*  
*    ***lease-expiration-duration-in-seconds**: 5  *\# 如果现在超过了5秒的间隔（默认是90秒）*  
**info**:  
  **app.name**: springcloud-config-product-client  
  **company.name**: hankin  
  **build.artifactId**: $project.artifactId$  
  **build.modelVersion**: $project.modelVersion$  
**management**:  
  **endpoints**:  
    **web**:  
      **exposure**:  
        **include**: **'\*'**

有了这两个配置文件，接下来就可以搭建eureka服务和product服务了。

**4.3、创建eureka服务配置**

复制springcloud-micro-eureka一份，修改成为：springcloud-micro-config-eureka-client

springcloud-micro-config-eureka-client修改pom文件如下：

<**dependencies**> 
     <**dependency**> 
         <**groupId**>org.springframework.boot</**groupId**> 
         <**artifactId**>spring-boot-starter-web</**artifactId**> 
     </**dependency**> 
     <**dependency**> 
         <**groupId**>org.springframework.boot</**groupId**> 
         <**artifactId**>spring-boot-starter-test</**artifactId**> 
         <**scope**>test</**scope**> 
     </**dependency**> 
     <**dependency**> 
         <**groupId**>org.springframework.boot</**groupId**> 
         <**artifactId**>spring-boot-devtools</**artifactId**> 
     </**dependency**> 
     <**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-security</**artifactId**> 
     </**dependency**> 
*     *<**dependency**> 
         <**groupId**>org.springframework.cloud</**groupId**> 
         <**artifactId**>spring-cloud-starter-config</**artifactId**> 
     </**dependency**> 
 </**dependencies**>

**4.4、创建bootstrap.yml文件，读取配置中心eureka的配置**

**spring**:  
  **cloud**:  
    **config**:  
      **name**: springcloud-config-eureka-client *\# 定义要读取的资源文件的名称springcloud-config-eureka-client.yml*  
*      ***profile**: beta *\# 定义profile的 名称*  
*      ***label**: master *\# 定义配置文件所在的分支*  
*      ***uri**: http://localhost:7101 *\# SpringCloudConfig的服务地址*  
*      ***username**: admin *\# 连接的用户名*  
*      ***password**: admin *\# 连接的密码*

**4.5、修改application.yml，删除不需要的配置**

**spring**:  
  **application**:  
    **name**: springcloud-micro-config-eureka-client

由于使用的是beta环境，它里面指定的eureka的端口是7002。

重启后访问：localhost:7002，访问成功，说明配置拉取正常。

### **5、product服务配置** ###

复制springcloud-micro-product项目为【springcloud-micro-config-product-client】

**5.1、pom文件添加springcloudconfig配置：**

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

**5.2、新增bootstrap.yml 文件，配置如下：**

**spring**:  
  **cloud**:  
    **config**:  
      **name**: springcloud-config-product-client *\# 定义要读取的资源文件的名称*  
*      ***profile**: beta *\# 定义profile的 名称*  
*      ***label**: master *\# 定义配置文件所在的分支*  
*      ***uri**: http://localhost:7101 *\# SpringCloudConfig的服务地址*  
*      ***username**: admin *\# 连接的用户名*  
*      ***password**: admin *\# 连接的密码*

**5.3、修改application.yml文件**

**spring**:  
  **application**:  
    **name**: springcloud-micro-config-product-client

启动config服务、Eureka-config服务、product-config服务，然后访问eureka，现在产品服务已经添加上去了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2][]

### **6、配置信息的加密** ###

在配置中心中，有些信息是比较敏感的，比如密码信息，在配置密码信息的时候有必要对密码信息加密以免密码信息泄露，springcloud配置中心也支持配置信息加密的，这里一RSA非对称加密举例。

**1****）本地生成秘钥对**

cd到jdk的keytool目录：C:\\Program Files\\Java\\jdk1.8.0\_181\\jre\\bin里面有一个keytool.exe 可执行文件

**2****）执行指令生成秘钥文件**

keytool -genkeypair -alias config-server -keyalg RSA -keystore config-server.keystore -validity 365

指令执行成功后会在bin目录生成一个config-server.keystore文件，把该文件copy到配置中心服务工程中resources目录下。

**3****）服务端工程配置**

Properties配置文件，添加秘钥配置：

\#加密配置

encrypt.key-store.location=config-server.keystore

encrypt.key-store.alias=config-server

encrypt.key-store.password=123456

encrypt.key-store.secret=123456

pom 中添加静态文件扫描，让能够扫描到.keystore 文件

<**resources**> 
    <**resource**> 
        <**directory**>src/main/java</**directory**> 
        <**includes**> 
            <**include**>\*\*/\*.properties</**include**> 
            <**include**>\*\*/\*.xml</**include**> 
        </**includes**> 
        <**filtering**>false</**filtering**> 
    </**resource**> 
    <**resource**> 
        <**directory**>src/main/resources</**directory**> 
        <**includes**> 
            <**include**>\*\*/\*.properties</**include**> 
            <**include**>\*\*/\*.xml</**include**> 
            <**include**>\*\*/\*.txt</**include**> 
            <**include**>\*\*/\*.keystore</**include**> 
        </**includes**> 
        <**filtering**>false</**filtering**> 
    </**resource**> 
</**resources**>

**4）密码加密和解密接口**

在服务端中有提供对信息加密和解密接口的

加密接口：http://localhost:7101/encrypt?data=123456，post 请求

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3][]

解密接口：http://localhost:7101/decrypt，post 请求

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4][]

代码仓库密文配置：

![20200325000555517.png][]

密文前面一定要加上\{cipher\}标识这个是密文配置，需要服务端来解密的

### **7、客户端快速失败和重试**  ###

当客户端连服务端失败时，客户端就快速失败，不进行加载其他的spring容器快速失败

\#如果连接不上获取配置有问题，快速响应失败

spring.cloud.config.fail-fast=true

客户端也有重试功能，连不上服务端是有重试机制，重试功能jar包导入

** 
<**dependency**> 
    <**groupId**>org.springframework.retry</**groupId**> 
    <**artifactId**>spring-retry</**artifactId**> 
</**dependency**>

重试配置：

\#默认重试的间隔时间，默认 1000ms

spring.cloud.config.retry.multiplier=1000

\#下一间隔时间的乘数，默认是 1.1

\#spring.cloud.config.retry.initial-interval=1.1

\#最大间隔时间，最大 2000ms

spring.cloud.config.retry.max-interval=2000

\#最大重试次数，默认 6 次

spring.cloud.config.retry.max-attempts=6

重试效果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5][]

## **二、Config配置中心高可用** ##

现在不管是erueka还是服务提供者都是基于SpringCloudConfig获取配置文件的，这个时候配置中心就至关重要了，但在真实的项目环境中，难免SpringCloudConfig会出现各种问题，这个时候就需要考虑config的高可用机制了。其实解决方式也很简单，把SpringCloudConfig注册到Eureka就搞定了，这个时候用户访问的时候不是直接从配置中心获取配置，而是通过eureka中获取配置中心的地址，再从配置中心获取具体服务的参数就行。

### **1、创建ha-config-eureka高可用服务** ###

复制springcloud-micro-eureka一份，修改成为springcloud-micro-config-eureka-ha，这个eureka不注册具体的业务服务，只是负责config配置中心的负载均衡使用。

**1.1、pom文件如下**

<**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**> 
<**dependency**> 
    <**groupId**>org.springframework.boot</**groupId**> 
    <**artifactId**>spring-boot-starter-security</**artifactId**> 
</**dependency**>

**1.2、修改application.yml文件**

**server**:  
  **port**: 7301  
**eureka**:  
  **server**:  
    **eviction-interval-timer-in-ms**: 1000   *\#设置清理的间隔时间，而后这个时间使用的是毫秒单位（默认是60秒）*  
*    ***enable-self-preservation**: **false** *\#设置为false表示关闭保护模式*  
*  ***client**:  
    **fetch-registry**: **false**  
**    register-with-eureka**: **false**  
**    service-url**:  
      **defaultZone**: http://admin:admin@localhost:7301/eureka  
  **instance**: *\# eureak实例定义*  
*    ***hostname**: localhost *\# 定义 Eureka 实例所在的主机名称*  
**spring**:  
  **security**:  
    **user**:  
      **name**: admin  
      **password**: admin  
  **application**:  
    **name**: springcloud-micro-config-eureka-ha

**1.3、启动类如下**

@SpringBootApplication  
@EnableEurekaServer  *// 添加eureka服务端注解*  
**public class** HaEurekaConfigApp \{   
    **public static void** main(String\[\] args) \{   
        SpringApplication.*run*(HaEurekaConfigApp.**class**,args);  
    \}  
\}

### **2、springcloud配置重新再复制两份** ###

springcloud-micro-config再复制两份，总共3个配置中心，分别为springcloud-micro-config2，springcloud-micro-config3。

**2.1、分别修改pom文件，增加eureka的支持**

springcloud-micro-config、springcloud-micro-config2、springcloud-micro-config分别修改pom文件，增加eureka的支持：

<**dependency**> 
    <**groupId**>org.springframework.cloud</**groupId**> 
    <**artifactId**>spring-cloud-starter-netflix-eureka-client</**artifactId**> 
</**dependency**>

**2.2、分别修改三个config服务的application.yml文件，**

增加eureka的注册地址，注意修改端口号port，以及instance-id

**server**:  
  **port**: 7102  
**spring**:  
  **application**:  
    **name**: springcloud-micro-config  
  **cloud**:  
    **config**:  
      **server**:  
        **git**:  
          **uri**: https://gitee.com/hankin\_chj/springcloud-micro-config.git  
**eureka**:  
  **client**:  
    **service-url**:  
      **defaultZone**: http://admin:admin@localhost:7301/eureka  
  **instance**:  
    **prefer-ip-address**: **true** *\# 在地址栏上使用IP地址进行显示*  
*   ** ***instance-id**: springcloud-micro-config2

先启动springcloud-micro-config-eureka-ha服务，然后分别启动eureka并启动三个配置中心后，访问注册中心：[http://localhost:7301/][http_localhost_7301]

![20200325000448475.png][]

**2.3、config-client修改pom文件，增加eureka的支持**

**2.4、config-client修改bootstrap.yml文件**

增加eureka相关配置，注意添加了discovery与eureka.client配置信息需要注释掉uri配置

**spring**:  
  **cloud**:  
    **config**:  
      **name**: springcloud-micro-config-client *\# 定义要读取的资源文件的名称*  
*      ***profile**: dev *\# 定义profile的 名称*  
*      ***label**: master *\# 定义配置文件所在的分支*  
*\#      uri: http://localhost:7101 \# SpringCloudConfig的服务地址*  
*      ***username**: admin *\# 连接的用户名*  
*      ***password**: admin *\# 连接的密码*  
*    **  ***discovery**:  
        **enabled**: **true   ***\# 通过配置中心加载配置文件*  
*        ***service-id**: SPRINGCLOUD-MICRO-CONFIG   *\# 在eureka之中注册的服务ID*  
**eureka**:  
  **client**:  
    **service-url**:  
      **defaultZone**: http://admin:admin@localhost:7301/eureka

**2.5、启动springcloud-micro-config-client**

访问：[http://localhost:8201/config][http_localhost_8201_config]

返回结果：

ApplicationName =springcloudmicro-test-client、EurekaServers=http://admin:admin@localhost:7001/eureka

## **三、配置自动刷新** ##

在整个SpringCloudConfig设计之中，我们已经实现了配置的统一管理，但其实还有一个问题，就是自动刷新。尝试修改一下springcloud-micro-config-client.yml文件然后提交GitHub，比如讲application: name修随便更新一下，这里的修改非常简单，只是修改了下应用名称，提交后访问[http://localhost:8201/config][http_localhost_8201_config]。

发现配置并没有修改，一直要重启springcloud-micro-config-client服务后才会发现配置已经修改成功，其实这对大多数应用没有什么问题，如果你定时要关注这个小问题也是有办法处理的，在springcloud里面可以借助消息总线SpringCloudBus解决这问题。

### **1、SpringCloudBus** ###

**1.1、springcloudbus介绍**

ESB（企业服务总线）在一开始讲springcloud的时候就讲过，在springcloud中就是使用springcloudbus解决这问题的。基于总线的设计其实是借鉴了硬件的思想，编写的一个程序都需要用到CPU、内存、硬盘等资源，每一个硬件资源的接口都不同，所以需要借助驱动程序，这个驱动程序就类似于设计模式里面的适配器模式。通过这种设计，举例来说，在程序运行中可能需要用到CPU的资源，但由于不同的CPU通过驱动程序已经对硬件完全兼容了。

虽然这样一来CPU、内存、硬盘对系统是可以识别了，但这些硬件资源一般都不是由程序自己去访问，而是由系统的内核来处理，由操作系统来统一调度各种硬件资源。这其实就是消息总线的一种体现，操作系统就是这个总线，在架构中，消息中线是一个中枢系统。

springcloudbus是基于SpringCloudStream的，SpringCloudStream的作用其实也是一种适配器模式的体现，消息中间件由很多，比如activemq、rabbitmq、kafka，不同的消息中间件都会有使用上的差异，而SpringCloudStream就是为了屏蔽各种消息中间件的差异而存在的，具体的SpringCloudStream我们后面会单独拿来说。

再来看个图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6][]

与之前的架构不一样的地方在于增加了消息总线，消息总线连接了config配置中心和各个配置中心的消费方，当配置提交到github的时候，可以借助/bus/refresh刷新，config配置中心再将变更的消息通知到其他的客户端。

**1.2、修改配置springcloud-micro-config-client.yml然后更新到GitHub**

**spring**:  
   **profiles**:  
      **active**:  
      - dev  
\---  
**server**:  
  **port**: 8201  
**spring**:  
  **profiles**: dev  
  **application**:  
      **name**: springcloud-micro-test-client  
**eureka**:  
  **client**:  
    **service-url**:  
      **defaultZone**: http://admin:admin@localhost:7001/eureka  
  **info**:  
    **app.name**: springcloud-micro-config-client-dev  
    **company.name**: hankin  
\---  
**server**:  
  **port**: 8102  
**spring**:  
  **profiles**: beta  
  **application**:  
      **name**: springcloud-micro-test-client  
**eureka**:  
  **client**:  
    **service-url**:  
      **defaultZone**: http://admin:admin@localhost:7001/eureka  
  **info**:  
    **app.name**: springcloud-micro-config-client-dev  
    **company.name**: hankin

**1.3、启动rabbitmq**

这里我们使用的是RabbitMQ，本地安装启动，登陆查看 [http://localhost:15672][http_localhost_15672]

### **2、准备bus配置中心** ###

新建立一个模块springcloud-micro-config-bus，这模块是配置中心的升级版，作用也是配置中心。

**2.1、config-bus模块修改pom文件**

<**dependencies**> 
    <**dependency**> 
        <**groupId**>org.springframework.boot</**groupId**> 
        <**artifactId**>spring-boot-starter-web</**artifactId**> 
    </**dependency**> 
    <**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**> 
    ** 
*   ** *<**dependency**> 
        <**groupId**>org.springframework.cloud</**groupId**> 
        <**artifactId**>spring-cloud-starter-bus-amqp</**artifactId**> 
    </**dependency**> 
    <**dependency**> 
        <**groupId**>org.springframework.boot</**groupId**> 
        <**artifactId**>spring-boot-starter-actuator</**artifactId**> 
    </**dependency**> 
</**dependencies**>

**2.2、config-bus修改application.yml文件**

配置上git目录，一样连接上eureka，要和消息中间件通讯，所以RabbitMQ的连接信息也配置上

**server**:  
  **port**: 7201  
**spring**:  
  **cloud**:  
    **config**:  
      **server**:  
        **git**:  
          **uri**: https://gitee.com/hankin\_chj/springcloud-micro-config.git  
    **bus**:  
      **trace**:  
        **enabled**: true  
  **rabbitmq**:  
    **host**: localhost  
    **port**: 5672    *\# RabbitMQ的监听端口*  
*    ***username**: admin  *\# 用户名*  
*    ***password**: admin *\# 密码*  
*  ***application**:  
    **name**: springcloud-micro-config-bus  
  
**eureka**:  
  **client**:  
    **serviceUrl**:  
      **defaultZone**: http://admin:admin@localhost:7301/eureka  
  **instance**:  
    **prefer-ip-address**: **true** *\# 在地址栏上使用IP地址进行显示*  
*    ***instance-id**: springcloud-micro-config-bus  
**management**:  
  **endpoints**:  
    **web**:  
      **exposure**:  
        **include**: **"\*"**

**2.3、新增启动类**

@SpringBootApplication  
@EnableConfigServer  
@EnableEurekaClient  
**public class** ConfigBusApp \{   
    **public static void** main(String\[\] args) \{   
        SpringApplication.*run*(ConfigBusApp.**class**,args);  
    \}  
\}

先启动eureka，再启动ConfigBusApp，之后访问：[http://localhost:7301/][http_localhost_7301 1]

发现新的注册中心已经注册上去了。

![20200325000348999.png][]

### **3、准备新的客户端** ###

新建立springcloud-micro-config-bus-client模块，这模块是注册中心的客户端，从注册中心获取数据，职责和springcloud-micro-config-client一样，可用基于他拷贝修改，只是增加bus相关的功能。

**3.1、springcloud-micro-config-bus-client修改pom文件**

<**dependencies**> 
    <**dependency**> 
        <**groupId**>org.springframework.cloud</**groupId**> 
        <**artifactId**>spring-cloud-starter-config</**artifactId**> 
    </**dependency**> 
    <**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-client</**artifactId**> 
    </**dependency**> 
    <**dependency**> 
        <**groupId**>org.springframework.cloud</**groupId**> 
        <**artifactId**>spring-cloud-starter-bus-amqp</**artifactId**> 
    </**dependency**> 
    <**dependency**> 
        <**groupId**>org.springframework.boot</**groupId**> 
        <**artifactId**>spring-boot-starter-actuator</**artifactId**> 
    </**dependency**> 
</**dependencies**>

**3.2、bootstrap.yml配置更新**

config-bus-client模块的bootstrap.yml增加rabbitmq相关信息，另外的配置和前面一样，需要从eureka找到注册中心，也需要找具体配置文件信息。

**spring**:  
  **cloud**:  
    **config**:

*\# 注意这里使用的依然是springcloud-micro-config-client服务对应的配置文件*  
      **name**: springcloud-micro-config-bus-client

*      ***profile**: dev *\# 定义profile的 名称*  
*      ***label**: master *\# 定义配置文件所在的分支*  
*      \#uri: http://localhost:7101 \# SpringCloudConfig的服务地址*  
*      ***username**: admin *\# 连接的用户名*  
*      ***password**: admin *\# 连接的密码*  
*      ***discovery**:  
        **enabled**: **true**  
**        service-id**: SPRINGCLOUD-MICRO-CONFIG-BUS  
  **rabbitmq**:  
    **host**: localhost  
    **port**: 5672    *\# RabbitMQ的监听端口*  
*    ***username**: admin  *\# 用户名*  
*    ***password**: admin *\# 密码*  
**eureka**:  
  **client**:  
    **serviceUrl**:  
      **defaultZone**: http://admin:admin@localhost:7301/eureka  
    **register-with-eureka**: **false**

**3.3、修改application.yml文件**

**spring**:  
  **application**:  
    **name**: springcloud-micro-config-bus-client *\# 编写应用的名称*

**3.4、config-bus-client模块建立一个配置文件的映射类**

这类是为了演示使用，里面的属性和github的属性一一对应，同时增加@RefreshScope，代表这个类是可用基于rabbitmq自动刷新的。

**import** org.slf4j.LoggerFactory;  
**import** org.springframework.beans.factory.annotation.Autowired;  
**import** org.springframework.beans.factory.annotation.Value;  
**import** org.springframework.core.env.Environment;  
**import** org.springframework.cloud.context.config.annotation.RefreshScope;  
**import** org.springframework.stereotype.Component;  
*/\*\**  
* \** ***TODO 里面的属性和github的属性一一对应，***  
*** ****\*  ****增加@RefreshScope，代表这个类是可用基于rabbitmq自动刷新的***  
*** ****\*  ****1、Environment 的动态刷新 动态刷新其实要有一个契机，其实这个契机就是手动调用刷新接口，***  
*** ****\*  ****如果你想刷新哪台主机的配置，就调用哪台注解的刷新接口,刷新接口为：http://localhost:8088/actuator/refresh***  
*** ****\*  ****2、@Value 注入的属性动态刷新 其实前面在调用刷新接口后，@Value 注入的属性是没有刷新的还是老的配置，这个也好理 解，@Value 注入的属性是项目启动就已经定了的。如果要使@Value 属性也刷新，就必须要 在类上面加上：@RefreshScope 注解。***  
* \*/*  
@Component  
@RefreshScope  
**public class** InfoConfig \{   
    **private** org.slf4j.Logger **logger** = LoggerFactory.*getLogger*(getClass());  
    @Value(**"$\{info.app.name\}"**)  
    **private** String **appName** ;  
    @Value(**"$\{info.company.name\}"**)  
    **private** String **companyName** ;  
    @Autowired  
    Environment **environment**;  
    **public** String getApenvironmentpName() \{   
        **return** **appName**;  
    \}  
    **public void** setAppName(String appName) \{   
        **this**.**appName** = appName;  
    \}  
    **public** String getCompanyName() \{   
        **return** **companyName**;  
    \}  
    **public void** setCompanyName(String companyName) \{   
        **this**.**companyName** = companyName;  
    \}  
    @Override  
    **public** String toString() \{   
        **logger**.info(**"@Value======username======"** \+ **appName**);  
        **logger**.info(**"Environment======username======"** \+ **environment**.getProperty(**"appName"**));  
        **return** **"InfoConfig\{"** \+**"appName='"** \+ **appName** \+ **'****\\'****'** \+  
                **", companyName='"** \+ **companyName** \+ **'****\\'****'** \+ **'\}'**;  
    \}  
\}

**3.5、config-bus-client模块修改ConfigClientController**

@RestController  
**public class** ConfigClientController \{   
    @Value(**"$\{spring.application.name\}"**)  
    **private** String **applicationName**;  
    @Value(**"$\{eureka.client.serviceUrl.defaultZone\}"**)  
    **private** String **eurekaServers**;  
    @Resource  
    **private** InfoConfig **infoConfig**;  
    @RequestMapping(**"/config"**)  
    **public** String getConfig() \{   
        **return** **"ApplicationName = "** \+ **this**.**applicationName** \+ **"、EurekaServers = "**  
**                **\+ **this**.**eurekaServers**\+**"、infos = "** \+**infoConfig**.toString();  
    \}  
\}

**3.6、新增启动类**

@SpringBootApplication  
@EnableEurekaClient  
**public class** ConfigClientBusApp \{   
    **public static void** main(String\[\] args) \{   
        SpringApplication.*run*(ConfigClientBusApp.**class**,args);  
    \}  
\}

**3.7、启动后访问**

访问地址：[http://localhost:8201/config，这时候已经能获得配置中心的数据][http_localhost_8201_config 1]

![20200325000325538.png][]

### **4、测试自动刷新** ###

**4.1、Environment的动态刷新**

动态刷新其实要有一个契机，其实这个契机就是手动调用刷新接口，如果你想刷新哪台主机的配置，就调用哪台注解的刷新接口，刷新接口为：http://localhost:8088/actuator/refresh

**4.2、@Value注入的属性动态刷新**

其实前面在调用刷新接口后，@Value注入的属性是没有刷新的还是老的配置，这个也好理解，@Value注入的属性是项目启动就已经定了的。如果要使@Value属性也刷新，就必须要在类上面加上：@RefreshScope注解。

但是调用每台主机的刷新接口显然太麻烦了，如果需要刷新的集群机器有几百台，是不是就需要手动调用几百次呢，这几乎是一个不能完成的工作量。Springcloud中也提供了消息总线的东西，借助mq来完成消息的广播，当需要刷新时我们就只要调用一次刷新接口即可。

其实这里的自动刷新只能说是半自动的，github上面的springcloud-micro-config-client.yml配置文件，随便修改里面的内容（例如app.name），提交**config-bus-client模块**刷新客户端。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 7][]

访问：[http://localhost:8201/config][http_localhost_8201_config 2]

这个时候信息并没自动刷新，数据还是以前的，这是因为对应消息中间件来说，还需要给他发个消息，代表数据已经更新了。

**springcloud-micro-config-bus模块**使用postman发生一条post刷新的指令：

访问地址：http://localhost:7201/actuator/bus-refresh

然后访问：http://localhost:15672，发现消息队列里面已经有消息传递了。

然后config-bus-client服务刷新客户端：[http://localhost:8201/config][http_localhost_8201_config] 发现数据已经更新。

## **四、自定义分布式配置中心** ##

### **1、zookeeper 创建节点及事件监听** ###

代码参见：springcloud-micro-config-client项目下的com.chj.refresh.curator.CuratorUtil

@Component  
**public class** CuratorUtil **implements** ApplicationContextAware \{   
    **private static** String *connnectStr* = **"192.168.****32****.****166****:2181"**;  
    **private static** CuratorFramework *client*;  
    **private static** String *path* = **"/config"**;  
    @Value((**"$\{zookeeper.config.enable:false\}"**))  
    **private boolean** **enbale**;  
    @Autowired  
    Environment **environment**;  
    **private static** String *zkPropertyName* = **"zookeeperSource"**;  
    **private static** String *scopeName* = **"refresh"**;  
    **private static** ConfigurableApplicationContext *applicationContext*;  
    **private** ConcurrentHashMap **map** = **new** ConcurrentHashMap();  
    **private** BeanDefinitionRegistry **beanDefinitionRegistry**;  
  
    @PostConstruct  
    **public void** init() \{   
        **if** (!**enbale**) **return**;  
        RefreshScopeRegistry refreshScopeRegistry = (RefreshScopeRegistry)*applicationContext*.getBean(**"refreshScopeRegistry"**);  
        **beanDefinitionRegistry** = refreshScopeRegistry.getBeanDefinitionRegistry();  
        *client* = CuratorFrameworkFactory.builder().  
                connectString(*connnectStr*).  
                sessionTimeoutMs(5000).  
                retryPolicy(**new** ExponentialBackoffRetry(1000, 3)).build();  
        *client*.start();  
        **try** \{   
            Stat stat = *client*.checkExists().forPath(*path*);  
            **if** (stat == **null**) \{   
                *client*.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).  
                        forPath(*path*, **"zookeeper config"**.getBytes());  
                TimeUnit.***SECONDS***.sleep(1);  
            \} **else** \{   
                *//1、把config下面的子节点加载到spring容器的属性对象中*  
*                *addChildToSpringProperty(*client*, *path*);  
            \}  
*//            nodeCache(client,path);*  
*            *childNodeCache(*client*, *path*);  
        \} **catch** (Exception e) \{   
            e.printStackTrace();  
        \}  
    \}

创建zk节点的代码：

client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath(path, "zookeeper config".getBytes());

### **2、如果zookeeper里面有配置了把配置加载到spring中** ###

com.chj.refresh.curator.CuratorUtil\#createZookeeperSpringProperty

**private void** createZookeeperSpringProperty() \{   
    MutablePropertySources propertySources = *applicationContext*.getEnvironment().getPropertySources();  
    OriginTrackedMapPropertySource zookeeperSource = **new** OriginTrackedMapPropertySource(*zkPropertyName*, **map**);  
    propertySources.addLast(zookeeperSource);  
\}

com.chj.refresh.curator.CuratorUtil\#addChildToSpringProperty

**private void** addChildToSpringProperty(CuratorFramework client, String path) \{ 
    **if** (!checkExistsSpringProperty()) \{ 
        *//如果不存在zookeeper的配置属性对象则创建* 
*        *createZookeeperSpringProperty(); 
    \} 
    *//把config目录下的子节点添加到 zk的PropertySource对象中* 
*    *MutablePropertySources propertySources = *applicationContext*.getEnvironment().getPropertySources(); 
    PropertySource<?> propertySource = propertySources.get(*zkPropertyName*); 
    ConcurrentHashMap zkmap = (ConcurrentHashMap) propertySource.getSource(); 
    **try** \{ 
        List<String> strings = client.getChildren().forPath(path); 
        **for** (String string : strings) \{ 
            zkmap.put(string, client.getData().forPath(path + **"/"** \+ string)); 
        \} 
    \} **catch** (Exception e) \{ 
        e.printStackTrace(); 
    \} 
\}

### **3、为配置节点添加事件** ###

com.chj.refresh.curator.CuratorUtil\#childNodeCache

**private void** childNodeCache(CuratorFramework client, String path) \{   
    **try** \{   
        **final** PathChildrenCache pathChildrenCache = **new** PathChildrenCache(client, path, **false**);  
        pathChildrenCache.start(PathChildrenCache.StartMode.POST\_INITIALIZED\_EVENT);  
        pathChildrenCache.getListenable().addListener(**new** PathChildrenCacheListener() \{   
            @Override  
            **public void** childEvent(CuratorFramework client, PathChildrenCacheEvent event) **throws** Exception \{   
                **switch** (event.getType()) \{   
                    **case** CHILD\_ADDED:  
                        System.***out***.println(**"增加了节点"**);  
                        addEnv(event.getData(), client);  
                        **break**;  
                    **case** CHILD\_REMOVED:  
                        System.***out***.println(**"删除了节点"**);  
                        delEnv(event.getData());  
                        **break**;  
                    **case** CHILD\_UPDATED:  
                        System.***out***.println(**"更新了节点"**);  
                        addEnv(event.getData(), client);  
                        **break**;  
                    **default**:  
                        **break**;  
                \}  
              **  *****//对refresh作用域的实例进行刷新***  
***                *****refreshBean();**  
            \}  
        \});  
    \} **catch** (Exception e) \{   
        e.printStackTrace();  
    \}  
\}

当有节点新增、修改、删除时触发对应的事件，事件方法：

**private void** delEnv(ChildData childData) \{ 
    ChildData next = childData; 
    String childpath = next.getPath(); 
    MutablePropertySources propertySources = *applicationContext*.getEnvironment().getPropertySources(); 
    **for** (PropertySource<?> propertySource : propertySources) \{ 
        **if** (*zkPropertyName*.equals(propertySource.getName())) \{ 
            OriginTrackedMapPropertySource ps = (OriginTrackedMapPropertySource) propertySource; 
            ConcurrentHashMap chm = (ConcurrentHashMap) ps.getSource(); 
            chm.remove(childpath.substring(*path*.length() + 1)); 
        \} 
    \} 
\} 
**private void** addEnv(ChildData childData, CuratorFramework client) \{ 
    ChildData next = childData; 
    String childpath = next.getPath(); 
    String data = **null**; 
    **try** \{ 
        data = **new** String(client.getData().forPath(childpath)); 
    \} **catch** (Exception e) \{ 
        e.printStackTrace(); 
    \} 
    MutablePropertySources propertySources = *applicationContext*.getEnvironment().getPropertySources(); 
    **for** (PropertySource<?> propertySource : propertySources) \{ 
        **if** (*zkPropertyName*.equals(propertySource.getName())) \{ 
            OriginTrackedMapPropertySource ps = (OriginTrackedMapPropertySource) propertySource; 
            ConcurrentHashMap chm = (ConcurrentHashMap) ps.getSource(); 
            chm.put(childpath.substring(*path*.length() + 1), data); 
        \} 
    \} 
\}

### **4、对象重新创建触发@Value 的依赖注入**  ###

**4.1、自定义Scope，自己来管理bean**

**public class** RefreshScope **implements** Scope \{ 
    **private** ConcurrentHashMap **map** = **new** ConcurrentHashMap(); 
    @Override 
    **public** Object get(String name, ObjectFactory<?> objectFactory) \{ 
        **if**(**map**.containsKey(name)) \{ 
            **return** **map**.get(name); 
        \} 
        Object object = objectFactory.getObject(); 
        **map**.put(name,object); 
        **return** object; 
    \} 
    @Override 
    **public** Object remove(String name) \{ 
        **return map**.remove(name); 
    \} 
    @Override 
    **public void** registerDestructionCallback(String name, Runnable callback) \{ 
    \} 
    @Override 
    **public** Object resolveContextualObject(String key) \{ 
        **return null**; 
    \} 
    @Override 
    **public** String getConversationId() \{ 
        **return null**; 
    \} 
\}

如果缓存中有则直接返回，如果缓存没用则调用getObject方法创建对象。

**4.2、把自定义作用域注册到spring中**

@Data  
*@Component*  
**public class** RefreshScopeRegistry **implements** BeanDefinitionRegistryPostProcessor \{   
    **private** BeanDefinitionRegistry **beanDefinitionRegistry**;  
    @Override  
    **public void** postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) **throws** BeansException \{   
        **this**.**beanDefinitionRegistry** = registry;  
    \}  
    @Override  
    **public void** postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) **throws** BeansException \{   
        beanFactory.registerScope(**"refresh"**,**new** RefreshScope());  
    \}  
\}

**4.3、在有节点更新修改时重新创建节点**

**private void** refreshBean() \{   
    String\[\] beanDefinitionNames = *applicationContext*.getBeanDefinitionNames();  
    **for** (String beanDefinitionName : beanDefinitionNames) \{   
        BeanDefinition beanDefinition = **beanDefinitionRegistry**.getBeanDefinition(beanDefinitionName);  
        **if**(*scopeName*.equals(beanDefinition.getScope())) \{   
            *//先删除**：**思考，如果这时候删除了bean，有没有问题？*  
*            **applicationContext*.getBeanFactory().destroyScopedBean(beanDefinitionName);  
            *//在实例化*  
*            **applicationContext*.getBean(beanDefinitionName);  
        \}  
    \}  
\}

这里就会把自己管理的bean从缓存中删除，并且调用getBean创建新的对象。

### **5、超时配置** ###

***\#全局超时时间*** 
**hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=5000** 
*\#hystrix.command.default.metrics.rollingStats.timeInMilliseconds=4000* 
*\#hystrix.command.default.metrics.healthSnapshot.intervalInMilliseconds=2000* 
*\#hystrix.command.<commandKey>作为前缀,默认是采用Feign的客户端的方法名字作为标识* 
**hystrix.command.saveStudent.execution.isolation.thread.timeoutInMilliseconds**=**6000** 
**hystrix.command.queryContents.circuitBreaker.sleepWindowInMilliseconds**=**20000** 
**hystrix.command.errorMessage.execution.isolation.thread.timeoutInMilliseconds**=**100000000000** 
*\#ribbon.restclient.enabled=true* 
*\#点对点直连测试配置* 
*\# 关闭ribbon访问注册中心Eureka Server发现服务，但是服务依旧会注册。* 
*\#true使用eureka false不使用* 
**ribbon.eureka.enabled**=**true** 
**spring.cloud.loadbalancer.retry.enabled**=**true** 
*\#单位ms ,请求连接超时时间* 
**ribbon.ConnectTimeout**=**1000** 
*\#单位ms ,请求处理的超时时间* 
**ribbon.ReadTimeout**=**3000** 
**ribbon.OkToRetryOnAllOperations**=**false** 
*\#切换实例的重试次数* 
**ribbon.MaxAutoRetriesNextServer**=**0** 
*\#对当前实例的重试次数 当Eureka中可以找到服务，但是服务连不上时将会重试* 
**ribbon.MaxAutoRetries**=**0**

超时时间配置，如果hystrix超时时间大于ribbon超时时间，那么就以hystrix超时时间为准。

http://localhost:8083/student/timeOut?millis=2999，总共耗时：5009ms

![20200326213805960.png][]

Ribbon重试

![20200326213756532.png][]

这种请求是hystrix超时了，触发了ribbon的重试，ribbon调用还没结束，但是超过了hystrix的超时，所以hystrix拿不到异常。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70]: /images/20230528/3f7b0f0380b941fa8613539b46a6e8d4.png
[https_github.com]: https://github.com/
[http_localhost_7101_application-dev.yml]: http://localhost:7101/application-dev.yml
[http_localhost_7101_master_application-dev.yml]: http://localhost:7101/master/application-dev.yml
[http_localhost_7101_springcloud-micro-config-client-beta.yml]: http://localhost:7101/springcloud-micro-config-client-beta.yml
[http_localhost_8201_config]: http://localhost:8201/config
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 1]: /images/20230528/7175af0e97ab41a1936c946bc649e2ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 2]: /images/20230528/b6c4c5fdc0004dc68a535d890b07f336.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 3]: /images/20230528/013d3089e6ab46468a93102dce187beb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 4]: /images/20230528/c1b0bb818fd14aa6b99fd78facddeba1.png
[20200325000555517.png]: /images/20230528/f936646380b54844832a46cb44f6ad26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 5]: /images/20230528/efdff4fa67b4412e8f8d56560c8749b9.png
[http_localhost_7301]: http://localhost:7301/
[20200325000448475.png]: /images/20230528/26ef8f4ac13d459e8a8cb7e66a04a5a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 6]: /images/20230528/4f847e657a014bdfa77fafd5b7db699c.png
[http_localhost_15672]: http://localhost:15672
[http_localhost_7301 1]: http://localhost:7301/%EF%BC%8C%E5%8F%91%E7%8E%B0%E6%96%B0%E7%9A%84%E6%B3%A8%E5%86%8C%E4%B8%AD%E5%BF%83%E5%B7%B2%E7%BB%8F%E6%B3%A8%E5%86%8C%E4%B8%8A%E5%8E%BB%E4%BA%86%E3%80%82
[20200325000348999.png]: /images/20230528/07b6f656996c47979bca12eb9fce7c0f.png
[http_localhost_8201_config 1]: http://localhost:8201/config%EF%BC%8C%E8%BF%99%E6%97%B6%E5%80%99%E5%B7%B2%E7%BB%8F%E8%83%BD%E8%8E%B7%E5%BE%97%E9%85%8D%E7%BD%AE%E4%B8%AD%E5%BF%83%E7%9A%84%E6%95%B0%E6%8D%AE
[20200325000325538.png]: /images/20230528/f7f1371caa884162a18ccf8d6b6f5fc3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NjYxNDU4_size_16_color_FFFFFF_t_70 7]: /images/20230528/a94eb5d4c32d468793b03d228542215b.png
[http_localhost_8201_config 2]: http://localhost:8201/config%EF%BC%8C%E8%BF%99%E4%B8%AA%E6%97%B6%E5%80%99%E4%BF%A1%E6%81%AF%E5%B9%B6%E6%B2%A1%E8%87%AA%E5%8A%A8%E5%88%B7%E6%96%B0%EF%BC%8C%E6%95%B0%E6%8D%AE%E8%BF%98%E6%98%AF%E4%BB%A5%E5%89%8D%E7%9A%84%EF%BC%8C%E8%BF%99%E6%98%AF%E4%BB%A5%E4%B8%BA%E5%AF%B9%E5%BA%94%E6%B6%88%E6%81%AF%E4%B8%AD%E9%97%B4%E4%BB%B6%E6%9D%A5%E8%AF%B4%EF%BC%8C%E8%BF%98%E9%9C%80%E8%A6%81%E7%BB%99%E4%BB%96%E5%8F%91%E4%B8%AA%E6%B6%88%E6%81%AF%EF%BC%8C%E4%BB%A3%E8%A1%A8%E6%95%B0%E6%8D%AE%E5%B7%B2%E7%BB%8F%E6%9B%B4%E6%96%B0%E4%BA%86%E3%80%82
[20200326213805960.png]: /images/20230528/c14c3728838040648291c164358102bc.png
[20200326213756532.png]: /images/20230528/bd297031711d40f09557925fcd6dc8bc.png