【SpringCloud】Config 简单使用_spring.cloud.config

1 说明

因为 SpirngBoot, SpringCloud 的各个版本之间差异还是挺大的, 所以在参照本博客进行学习时, 有可能出现因为版本不一致, 而出现不同的问题。
如果可以和本项目使用的环境保持一致, 即使不一致, 也尽可能不要跨大版本。

环境清单

2 准备

2.1 Maven 父模块配置

1. 先建立一个 Maven 的父模块, 也就是整个项目里面只有一个 pom 文件
2. 在父 pom 里面添加一些共用的配置, 比如 SpringBoot, SpringCloud 的依赖

<?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>

    <!-- 手动引入 spring boot 版本依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/>
    </parent>

    <groupId>lcn29.github.io</groupId>
    <artifactId>spring-cloud-eureka</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>

    <dependencyManagement>
        <dependencies>
            <!-- 手动引入 spring cloud 对应的配置 -->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 手动 引入 spring cloud 的基础模块-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter</artifactId>
        </dependency>
    </dependencies>

    <!-- 省略一些打包相关的配置 -->
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

2.2 启动 2 个服务端 (注册中心)

1. 在父模块里面新建一个子模块, 模块名 eureka-server
2. 在子模块引入 Eureka 服务端需要的依赖

<dependencies>
    <!-- eureka 服务端的依赖-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
    </dependency>
</dependencies>
1
2
3
4
5
6
7

3. 在启动类上加上注解 @EnableEurekaServer

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

4. 在 src/main/resources 里面新建 3 个配置文件, 分别是 application.yml, application-8081.yml, application-8081.yml

5. 在 application.yml 里面加上这 2 个配置

# eureka 服务端的通用配置
spring:
  application:
    name: server-eureka

eureka:
  instance:
    instance-id: ${spring.application.name}:${server.port}
1
2
3
4
5
6
7
8

6. 在 application-8081.yml 里面加上这 2 个配置

# eureka 服务端 1 的配置
server:
  port: 8081
eureka:
  instance:
    hostname: eureka-8081.com
  client:
    service-url:
      defaultZone: http://eureka-8082.com:8082/eureka/
1
2
3
4
5
6
7
8
9

7. 在 application-8082.yml 里面加上这 2 个配置

# eureka 服务端 1 的配置
server:
  port: 8082
eureka:
  instance:
    hostname: eureka-8082.com
  client:
    service-url:
      defaultZone: http://eureka-8081.com:8081/eureka/
1
2
3
4
5
6
7
8
9

8. 在电脑的 hosts 文件里面添加这 2 行映射

127.0.0.1 eureka-8081.com
127.0.0.1 eureka-8082.com
1
2

9. 为了让我们的子模块能够启动为 2 个服务端, 需要我们做一下启动的配置

1. Idea 找到右上角的这个
   

2. 点一下左边的 +, 找到 SpringBoot 项, 配置一下下面的三项
   
   (如果 Program arguments 没有的话, 可以在绿色区域搜索添加)

3. Program arguments 配置的内容为 --spring.profiles.active=8081, 作用是启动这个 SpringBoot 应用时使用8081 环境, 也就是对应 application-8081.yml 里面的配置

4. 同理, 在配置多一条 8082 环境的启动命令, 这样子模块就能启动 2 个程序了

2.3 创建 1 个配置客户端 (配置中心)

1. 在父模块里面新建一个子模块, 模块名 config-server

2. 在模块里面添加如下依赖

<!-- eureka 服务端的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

<!-- web 功能的支持, 没有这个 客户端就会启动完就结束程序 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11

3. 然后在启动类上加上注解 @EnableEurekaClient

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

4. 同样在 src/main/resources 里面新建 1 个配置文件, application.yml

5. 在 application.yml 里面加上这 2 个配置

spring:
  application:
    name: spring-cloud-config-server

server:
  port: 9091

eureka:
  instance:
    instance-id: ${spring.application.name}:${server.port}
  client:
    service-url:
      # 向服务端的注册地址
      defaultZone: http://eureka-8081.com:8081/eureka/,http://eureka-8082.com:8082/eureka
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.4 创建 1 个客户端 (用来测试功能)

1. 在父模块里面再建立一个子模块, 模块名config-client, 作为服务的调用方
2. 在模块里面添加如下依赖

<!-- eureka 服务端的依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

<!-- web 功能的支持, 没有这个 客户端就会启动完就结束程序 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!--远程调用-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3. 然后在启动类上加上注解 @EnableEurekaClient

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

4. 在 application.yml 中添加配置

spring:
  application:
    name: client-consumer
server:
  port: 10101

eureka:
  instance:
    instance-id: ${spring.application.name}:${server.port}
  client:
    service-url:
      # 向服务端的注册地址
      defaultZone: http://eureka-8081.com:8081/eureka/,http://eureka-8082.com:8082/eureka
1
2
3
4
5
6
7
8
9
10
11
12
13

5. 声明一个 Controller (用于测试), 注入刚声明的接口

@RestController
public class PropertyController {

    private String name = "local";

    @GetMapping("/property")
    public String getProperty() {
        String resp = "从远程获取到的配置" + name;
        return resp;
    }
}
1
2
3
4
5
6
7
8
9
10
11

2.5 在 GitHub 上创建一个仓库, 用于存放配置文件

1. 在 GitHub 上创建一个仓库, 仓库名为 spring-cloud-config, 名字随意
2. 在仓库里面新建了一个文件夹 application-config, 里面新建了三个文件 config-dev.yml, config-test.yml, config-prod.yml
3. 在三个文件里面分别写入对应的配置内容

# config-dev.yml 配置, config-test.yml, config-prod.yml 配置类似, 改为 my.name 修改为 test/prod 即可
my:
  name: dev
1
2
3

到此, 环境准备基本完成了。

3 Config 开始使用

3.1 配置客户端搭建 (配置中心)

1. 在配置客户端 config-center 引入对应的依赖

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

2. 在 application.yml 中添加配置

spring:
  application:
    name: spring-cloud-config-server
  cloud:
    config:
      server:
        git:
          uri: 你GitHub配置仓库的地址
          # 指定某个目录
          search-paths: 配置仓库里面哪个文件夹存放着你这个项目需要的配置文件(这里我的就是 /application-config)
          username: GitHub的用户名
          password: GitHub的登录密码

1
2
3
4
5
6
7
8
9
10
11
12
13

3. 在启动类上加上注解 @EnableConfigServer

@EnableEurekaClient
@EnableConfigServer
@SpringBootApplication
public class ConfigServer {

    public static void main(String[] args) {
        SpringApplication.run(ConfigServer.class, args);
    }
}
1
2
3
4
5
6
7
8
9

4. 启动注册中心, 启动配置客户端, 测试一下是否能获取得到配置信息, 访问路径 http://localhost:服务端的端口/你的配置文件-的前部分/你的配置文件-的后半部分/(这个可选, 取那条分支的内容, 默认是master), 我的访问路径为 http://localhost:9091/config/dev/master, 如果成功的话, 可以看到类似下面的内容, 说明你的配置客户端没问题了

{
  name: "config", profiles: [
    "dev"
  ], label: "master", version: "dcc1f4eb6c3f44c59b28d3699edf39ac4da0e97b", state: null, propertySources: [
    {
      name: "https://github.com/GitHub用户名/你的配置仓库名/配置文件夹名/配置文件名.yml", source: {
        my.name: "dev-update-v1.2"
      }, }
  ], }
1
2
3
4
5
6
7
8
9

3.2 配置读取客户端搭建 (测试配置读取)

1. 在配置客户端 config-client 引入对应的依赖

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

2. 在 src/main/resources 里面新建一个 bootstrap.yml 的配置文件 (启动配置文件, 他的优先级高于 application.yml), 在里面配置

eureka:
  instance:
    instance-id: ${spring.application.name}:${server.port}
  client:
    service-url:
      # 向服务端的注册地址
      defaultZone: http://eureka-8081.com:8081/eureka/,http://eureka-8082.com:8082/eureka

spring:
  cloud:
    config:
      # 下面三个参数对应登录我们服务端获取配置信息的 url 的三个参数
      name: config
      profile: dev
      label: master
      discovery:
        # Config 服务发现支持
        enabled: true
        # config server 的应用名
        serviceId: spring-cloud-config-server
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 客户端还是需要在 application.yml设置我们客户端的其他信息的, 如端口, 应用名

server:
  port: 9091

spring:
  application:
    name: spring-cloud-config-client
1
2
3
4
5
6

4. 修改测试的 Controller

@RestController
public class PropertyController {

    @Value("${my.name}")
    private String name;

    @GetMapping("/property")
    public String getProperty() {
        String resp = "从远程获取到的配置" + name;
        return resp;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

5. 启动客户端, 访问 http://localhost:你的端口/property 可以看到 从远程获取到的配置 dev

6. 这时候你修改了 GitHub 上面 config-dev.yml 的内容, 你会发现你的客户端没法获取到最新的配置, SpringCloud 提供了一个 POST 方法, 请求一下 /refresh 这个接口就行了。但是需要做一下配置

7. 在测试客户端引入 actuator 依赖, 他里面有我们需要的的 /refresh的实现

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

8. 在你引用到远程配置的类的上面加上注解 @RefreshScope, 我们这里就是在 Controller 上面加上就行了

@RestController
public class PropertyController {
    // 省略
}
1
2
3
4

9. actuator 默认的 refresh 端点是关闭的, 需要开启 (配置在 application.yml 就行了)

# 暴露所有的端点 management.security.enabled=false 在 spring boot 2.0 版本以上已过期
management:
  endpoints:
    web:
      exposure:
        include: '*'
1
2
3
4
5
6

10. 当我们的远程仓库的配置继续了修改, 只需要我们手动发起一个 Post 请求到 http://你客户端的地址:端口/actuator/refresh, 你的项目里面的配置就会进行刷新

11. 上面的主动请求 /refresh, 可以通过 GitHub 的 Webhooks 进行回调。但是随着系统的客户端的增加, Webhooks 的 url 也会增大, 不好管理。下面看一下, 通过消息总线的方式的解决

4 消息总线

流程大概是这样的

1. 当我们代码提交了, 通过GitHub的Webhook功能回调我们的服务端(单机集群都可以), 地址 http://你的服务端的地址:端口/actuator/bus-refresh
2. 这时候服务端通知消息总线 (也就是 MQ), 消息总线通知所有的客户端
3. 客户端主动去请求服务端获取最新的配置

1. 首先搭建一套 MQ 环境, 这里使用的是 RabbitMQ, 你可以使用其他的, 但是需要修改配置

2. 在配置客户端 config-center 引入对应的依赖

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

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

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3. 在 配置客户端 config-center 的 `application.yml`` 配置文件里面加上配置

spring:
  cloud:
    bus:
      # 开启总线
      enabled: true
      trace:
        # 追踪链路
        enabled: true
  rabbitmq:
    host: RabbitMQ 的地址
    port: RabbitMQ 的端口
    username: RabbitMQ 用户名
    password: RabbitMQ 密码
    
# 暴露端点
management:
  endpoints:
    web:
      exposure:
        include: bus-refresh    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4. 配置读取客户端 config-client 移除 actuator 的依赖和配置(这些我们配置在服务端), 同时加上依赖

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

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-bus</artifactId>
</dependency>
1
2
3
4
5
6
7
8
9

5. 配置读取客户端在 `bootstrap.yml`` 里面加一下总线的和 RabbitMQ 的配置

spring:
  cloud:
    bus:
      # 开启总线
      enabled: true
      trace:
        # 追踪链路
        enabled: true
  rabbitmq:
    host: RabbitMQ 的地址
    port: RabbitMQ 的端口
    username: RabbitMQ 用户名
    password: RabbitMQ 密码
1
2
3
4
5
6
7
8
9
10
11
12
13

6. 在 GitHub 的 webhook 配置上我们的配置服务端的请求地址 http://localhost:9091/actuator/bus-refresh (这个地址, Github 是无论都访问不到的, 如果是正式环境需要正确的配置), 在这里我们通过模拟发送 Post 请求到这个地址, 达到测试的效果

7. 刷新页面, 可以看到你修改并提交到 GitHub 的内容都能不用重启就取到了