【动态配置中心】Java+Redis构建动态配置中心

前言

一、动态配置中心的核心价值与应用场景

[1.1 为什么需要动态配置中心？](#1.1 为什么需要动态配置中心？)

[1.2 典型应用场景](#1.2 典型应用场景)

[1.3 技术选型：为什么选择Redis？](#1.3 技术选型：为什么选择Redis？)

二、基于Redis的动态配置中心设计与实现

[2.1 整体架构设计](#2.1 整体架构设计)

[2.2 核心实现机制](#2.2 核心实现机制)

三、完整代码实现

[3.1 pom.xml 依赖文件](#3.1 pom.xml 依赖文件)

[3.2 spring.factories 配置文件](#3.2 spring.factories 配置文件)

[3.3 DCCValue 动态配置中心值注解](#3.3 DCCValue 动态配置中心值注解)

[3.4 Constant 常量类](#3.4 Constant 常量类)

[3.5 AttributeVO 配置属性值对象](#3.5 AttributeVO 配置属性值对象)

[3.6 DynamicConfigCenterRegisterAutoConfigProperties 动态配置中心Redis连接配置属性类](#3.6 DynamicConfigCenterRegisterAutoConfigProperties 动态配置中心Redis连接配置属性类)

[3.7 DynamicConfigCenterRegisterAutoConfig 动态配置中心注册自动配置类](#3.7 DynamicConfigCenterRegisterAutoConfig 动态配置中心注册自动配置类)

[3.8 DynamicConfigCenterAutoProperties 动态配置中心属性配置属性类](#3.8 DynamicConfigCenterAutoProperties 动态配置中心属性配置属性类)

[3.9 DynamicConfigCenterAutoConfig 动态配置中心自动配置类](#3.9 DynamicConfigCenterAutoConfig 动态配置中心自动配置类)

[3.10 DynamicConfigCenterAdjustListener 动态配置中心调整监听器](#3.10 DynamicConfigCenterAdjustListener 动态配置中心调整监听器)

[3.11 IDynamicConfigCenterService 动态配置中心服务接口](#3.11 IDynamicConfigCenterService 动态配置中心服务接口)

[3.12 DynamicConfigCenterService 动态配置中心服务实现类](#3.12 DynamicConfigCenterService 动态配置中心服务实现类)

四、测试动态配置

[4.1 application.yml配置文件](#4.1 application.yml配置文件)

[4.2 ApiTest 测试类](#4.2 ApiTest 测试类)

[4.3 测试结果](#4.3 测试结果)

五、优化与最佳实践

[5.1 性能优化策略](#5.1 性能优化策略)

[5.2 稳定性保障措施](#5.2 稳定性保障措施)

[5.3 安全考虑](#5.3 安全考虑)

[5.4 监控与告警](#5.4 监控与告警)

六、总结

前言

在微服务架构盛行的今天，系统拆分为多个服务带来了良好的扩展性和灵活性，同时也带来了配置管理的新挑战：如何在不重启服务的情况下实时调整系统参数？动态配置中心正是解决这一问题的关键。

动态配置中心是微服务架构中实现「配置热更新」的核心组件，其核心价值在于无需重启服务即可实时调整系统参数。这种能力在灰度发布、流量切换、紧急熔断等场景中至关重要。

虽然市面上已有功能完善的配置中心（如阿里云的Nacos、携程的Apollo），但基于Redis自研配置中心具有学习成本低、架构简单、复用现有基础设施等优势，特别适合中小团队和技术学习目的。

一、动态配置中心的核心价值与应用场景

1.1 为什么需要动态配置中心？

在传统的配置管理方式中，我们通常将配置写在配置文件中，修改配置需要重启应用才能生效。这种方式的弊端显而易见：

重启成本高：特别是在分布式系统中，重启服务可能影响用户体验和系统可用性。

缺乏实时性：无法应对急需调整配置的突发情况。

管理困难：当服务实例众多时，配置的一致性和同步成为挑战。

1.2 典型应用场景

动态配置中心在多种场景下发挥重要作用：

场景	描述	案例
服务降级开关	在系统负载过高或依赖服务异常时，临时关闭非核心功能	秒杀活动期间关闭推荐功能；外部接口超时时切换本地缓存
白名单控制	控制用户、IP或设备访问特定功能	新功能只对10%用户开放；特定账号访问权限控制
流量切分	按比例划分流量到不同服务版本	A/B测试、新旧版本对比、灰度发布
运行时参数调整	动态调整业务参数，如限流阈值、重试次数	网络波动时提高重试次数；限流规则实时调整

1.3 技术选型：为什么选择Redis？

实现动态配置中心有多种技术方案，以下是Redis方案与ZooKeeper方案的对比：

维度	Redis方案	ZooKeeper方案	技术选型建议
一致性模型	最终一致性（依赖主从同步）	强一致性（ZAB协议保证）	金融/交易类系统选ZooKeeper
实时性	依赖Pub/Sub机制，毫秒级延迟	Watch通知机制，亚秒级响应	实时性要求极高时选ZooKeeper
运维复杂度	无需新增组件，复用现有Redis集群	需独立部署集群，维护成本较高	中小团队优先选Redis方案
功能完备性	需自行实现版本管理、权限控制	原生支持ACL、节点历史版本追踪	复杂企业级场景选ZooKeeper

选择Redis的主要原因包括：复用现有基础设施，避免引入ZooKeeper的运维负担；快速迭代需求，通过注解+反射实现配置注入，开发效率高；以及满足中小规模集群需求。

二、基于Redis的动态配置中心设计与实现

2.1 整体架构设计

一个基本的动态配置中心通常包含以下组件：

配置存储：使用Redis存储配置信息，利用其高性能和持久化能力

配置更新接口：提供HTTP或RPC接口用于修改配置

变更通知机制：利用Redis的Pub/Sub功能通知客户端配置变更

客户端SDK：集成到业务应用中，负责监听配置变更并应用更新

2.2 核心实现机制

基于注解的配置管理

通过自定义注解标记需要动态更新的字段，利用反射机制实现配置注入：

java 复制代码

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@Documented
public @interface DCCValue {
    String value() default "";
}

配置初始化与监听流程

整个系统的运行流程如下：

1，外部调用 HTTP接口更新配置

2，DCCController 将key-value发布到Redis主题

3，DCCValueBeanFactory 监听并接收消息

4，查找本地缓存中对应的Bean对象

5，通过反射更新Bean中@DCCValue字段的值

6，配置实时生效，无需重启应用

三、完整代码实现

3.1 pom.xml 依赖文件

项目依赖包括Spring Boot基础启动器、AOP支持、Redisson客户端等，确保动态配置中心的核心功能得以实现。

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">
    <!-- Maven项目模型版本 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- 父项目配置，继承wrench父项目的配置 -->
    <parent>
        <groupId>com.yang.wrench</groupId>
        <artifactId>wrench</artifactId>
        <version>1.0</version>
    </parent>

    <!-- 当前项目的唯一标识符 -->
    <artifactId>wrench-starter-dynamic-config-center</artifactId>

    <!-- 项目依赖配置 -->
    <dependencies>
        <!-- Spring Boot基础启动器，提供核心Spring Boot功能 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <!-- Spring Boot配置处理器，用于生成配置元数据（可选依赖） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- Spring Boot自动配置支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
        </dependency>

        <!-- Spring Boot AOP支持，用于实现动态配置的切面编程 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

        <!-- Spring Boot测试支持（仅测试范围） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- Apache Commons Lang工具库，提供常用工具类 -->
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
        </dependency>

        <!-- 阿里巴巴FastJSON库，用于JSON序列化/反序列化 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>

        <!-- JUnit测试框架（仅测试范围） -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- Redisson Spring Boot启动器，提供Redis分布式功能 -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.26.0</version>
        </dependency>
    </dependencies>

    <!-- 构建配置 -->
    <build>
        <!-- 指定最终生成的artifact名称 -->
        <finalName>${project.artifactId}</finalName>
    </build>

</project>

3.2 spring.factories 配置文件

SPI（Service Provider Interface）是一种服务发现机制，允许框架在运行时动态加载实现类。

在Java中，SPI通常通过在META-INF/services或META-INF/spring.factories等配置文件中声明接口的实现类来实现。

Spring Boot利用SPI机制实现自动装配（AutoConfiguration）。开发人员只需在组件的META-INF/spring.factories文件中配置自动配置类，Spring Boot启动时便会自动加载并初始化这些类。

在本项目中，通过SPI机制将DynamicConfigCenterRegisterAutoConfig和DynamicConfigCenterAutoConfig注册到Spring Boot应用中，实现了动态配置中心组件的自动装配与初始化。用户仅需引入相关依赖，无需任何手动配置，即可使用动态配置中心的全部功能。

java 复制代码

org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.yang.wrench.starter.dynamic.config.center.config.DynamicConfigCenterRegisterAutoConfig,com.yang.wrench.starter.dynamic.config.center.config.DynamicConfigCenterAutoConfig

3.3 DCCValue 动态配置中心值注解

@DCCValue注解用于标记需要动态配置的字段，支持从配置中心动态获取配置值并在变更时自动更新。

java 复制代码

import java.lang.annotation.*;

/**
 * DCCValue 注解（Dynamic Config Center Value）
 *
 * 功能说明：
 * 1. 用于标记需要动态配置的字段，实现配置的自动注入和热更新
 * 2. 支持从配置中心动态获取配置值，并在配置变更时自动更新字段值
 * 3. 提供零侵入的配置管理方式，业务代码无需关心配置来源和更新逻辑
 *
 * 使用场景：
 * - 需要动态调整的配置参数（如超时时间、开关标志、连接数等）
 * - 需要支持热更新的业务配置
 * - 多环境统一管理的配置项
 *
 * 示例：
 * @DCCValue("user-service:database.timeout")
 * private int databaseTimeout;
 *
 * @DCCValue("feature.flag.enabled")
 * private boolean featureEnabled;
 *
 * @Author: yang
 * @Description: 动态配置中心值注解，用于标记需要动态配置的字段
 */
@Retention(RetentionPolicy.RUNTIME)  // 注解在运行时保留，可以通过反射获取
@Target({ElementType.FIELD})         // 注解只能应用于字段
@Documented                          // 注解包含在Javadoc中
public @interface DCCValue {

    /**
     * 配置键（Key）
     * 格式：通常在配置中心中的完整键名
     * 示例：system:attributeName（如：user-service:database.timeout）
     *
     * 如果值为空字符串，默认使用 字段名 作为配置键（需要配合命名策略）
     *
     * @return 配置中心中的键名
     */
    String value() default "";
}

3.4 Constant 常量类

定义常量，如Redis主题名称和符号常量，用于统一管理配置中心的键和主题。

java 复制代码

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: yang
 * @Description: 常量类
 */

public class Constant {

    public static final String DYNAMIC_CONFIG_CENTER_REDIS_TOPIC = "DYNAMIC_CONFIG_CENTER_REDIS_TOPIC";
    public static final String SYMBOL_COLON = ":";
    public static final String LINE = "_";
    public static String getTopic(String application){
        return DYNAMIC_CONFIG_CENTER_REDIS_TOPIC + SYMBOL_COLON + application;
    }

}

3.5 AttributeVO 配置属性值对象

用于传递配置属性的键值对信息，作为配置变更消息的载体。

java 复制代码

/**
 * 属性值调整值对象（Value Object）
 *
 * 功能说明：
 * 1. 用于在配置中心中传递配置属性的键值对信息
 * 2. 作为配置变更消息的载体，通过Redis消息总线进行发布和订阅
 * 3. 实现配置属性的序列化和反序列化，支持跨进程传输
 *
 * 示例：
 * - 属性：database.timeout，值：5000
 * - 属性：redis.host，值：127.0.0.1
 * - 属性：feature.flag.enabled，值：true
 *
 * @author yang
 * @Description: 配置属性值对象，用于配置变更消息的传递
 */
public class AttributeVO {

    /**
     * 属性键（Key） - 配置项的唯一标识
     * 格式通常为：系统标识 + ":" + 属性名（如：user-service:database.timeout）
     * 用于在配置中心中唯一标识一个配置项
     */
    private String attribute;

    /**
     * 属性值（Value） - 配置项的具体值
     * 支持各种类型的数据，最终以字符串形式存储和传输
     * 接收方需要根据业务需求进行类型转换
     */
    private String value;

    /**
     * 默认构造函数
     * 用于序列化框架的反序列化操作
     */
    public AttributeVO() {
    }

    /**
     * 带参数的构造函数
     * 用于快速创建属性值对象
     *
     * @param attribute 属性键
     * @param value 属性值
     */
    public AttributeVO(String attribute, String value) {
        this.attribute = attribute;
        this.value = value;
    }

    public String getAttribute() {
        return attribute;
    }

    public void setAttribute(String attribute) {
        this.attribute = attribute;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }
}

3.6 DynamicConfigCenterRegisterAutoConfigProperties 动态配置中心Redis连接配置属性类

读取Redis连接配置属性，支持连接池、超时和重试等详细参数的配置。

java 复制代码

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * 动态配置中心Redis连接配置属性类
 *
 * 功能说明：
 * 1. 用于读取和应用配置文件中以"wrench.config.register"为前缀的Redis连接配置属性
 * 2. 提供Redis连接池、超时、重试等详细参数的配置支持
 * 3. 作为Redisson客户端配置的数据载体，支持灵活的Redis连接配置
 *
 * 配置示例：
 * wrench:
 *   config:
 *     register:
 *       host: 127.0.0.1           # Redis服务器地址
 *       port: 6379                # Redis服务器端口
 *       password: 1234            # Redis访问密码
 *       poolSize: 64              # 连接池大小
 *       minIdleSize: 10           # 最小空闲连接数
 *       idleTimeout: 10000        # 空闲连接超时时间(毫秒)
 *       connectTimeout: 10000     # 连接超时时间(毫秒)
 *       retryAttempts: 3          # 重试次数
 *       retryInterval: 1000       # 重试间隔时间(毫秒)
 *       pingInterval: 0           # 心跳检测间隔(毫秒)
 *       keepAlive: true           # 是否保持长连接
 */
@ConfigurationProperties(prefix = "wrench.config.register", ignoreInvalidFields = true)  // 读取wrench.config.register前缀的配置，忽略无效字段
public class DynamicConfigCenterRegisterAutoConfigProperties {

    /**
     * Redis服务器主机地址
     * 示例：127.0.0.1 或 redis.example.com
     */
    private String host;

    /**
     * Redis服务器端口号
     * 默认端口：6379
     */
    private int port;

    /**
     * Redis访问密码
     * 如果Redis未设置密码，可以留空或注释掉该配置
     */
    private String password;

    /**
     * 连接池大小 - 最大连接数
     * 默认值：64，根据应用并发量和服务器资源调整
     */
    private int poolSize = 64;

    /**
     * 连接池最小空闲连接数
     * 默认值：10，保持一定数量的空闲连接以提高响应速度
     */
    private int minIdleSize = 10;

    /**
     * 空闲连接超时时间（单位：毫秒）
     * 默认值：10000（10秒），超过该时间的空闲连接将被关闭
     */
    private int idleTimeout = 10000;

    /**
     * 连接超时时间（单位：毫秒）
     * 默认值：10000（10秒），建立连接时的最大等待时间
     */
    private int connectTimeout = 10000;

    /**
     * 连接重试次数
     * 默认值：3，连接失败时的重试次数
     */
    private int retryAttempts = 3;

    /**
     * 连接重试间隔时间（单位：毫秒）
     * 默认值：1000（1秒），每次重试之间的等待时间
     */
    private int retryInterval = 1000;

    /**
     * 心跳检测间隔（单位：毫秒）
     * 默认值：0，表示不进行定期检查；建议生产环境设置为30000（30秒）
     */
    private int pingInterval = 0;

    /**
     * 是否保持长连接
     * 默认值：true，启用TCP keepalive机制保持连接活跃
     */
    private boolean keepAlive = true;

    // Getter和Setter方法
    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getPoolSize() {
        return poolSize;
    }

    public void setPoolSize(int poolSize) {
        this.poolSize = poolSize;
    }

    public int getMinIdleSize() {
        return minIdleSize;
    }

    public void setMinIdleSize(int minIdleSize) {
        this.minIdleSize = minIdleSize;
    }

    public int getIdleTimeout() {
        return idleTimeout;
    }

    public void setIdleTimeout(int idleTimeout) {
        this.idleTimeout = idleTimeout;
    }

    public int getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public int getRetryAttempts() {
        return retryAttempts;
    }

    public void setRetryAttempts(int retryAttempts) {
        this.retryAttempts = retryAttempts;
    }

    public int getRetryInterval() {
        return retryInterval;
    }

    public void setRetryInterval(int retryInterval) {
        this.retryInterval = retryInterval;
    }

    public int getPingInterval() {
        return pingInterval;
    }

    public void setPingInterval(int pingInterval) {
        this.pingInterval = pingInterval;
    }

    public boolean isKeepAlive() {
        return keepAlive;
    }

    public void setKeepAlive(boolean keepAlive) {
        this.keepAlive = keepAlive;
    }
}

3.7 DynamicConfigCenterRegisterAutoConfig 动态配置中心注册自动配置类

初始化Redisson客户端和配置监听器，实现配置中心的自动注册和初始化。

java 复制代码

import com.yang.wrench.starter.dynamic.config.center.domain.model.valobj.AttributeVO;
import com.yang.wrench.starter.dynamic.config.center.domain.service.DynamicConfigCenterService;
import com.yang.wrench.starter.dynamic.config.center.domain.service.IDynamicConfigCenterService;
import com.yang.wrench.starter.dynamic.config.center.listener.DynamicConfigCenterAdjustListener;
import com.yang.wrench.starter.dynamic.config.center.types.common.Constant;
import org.redisson.Redisson;
import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.config.Config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 动态配置中心注册自动配置类
 *
 * 功能说明：
 * 1. 动态配置中心的Spring Boot自动配置入口
 * 2. 初始化Redisson客户端连接Redis，作为配置中心的存储和消息总线
 * 3. 注册配置监听器，实现配置变更的实时通知和动态更新
 * 4. 创建配置服务Bean，提供配置的读写和管理能力
 *
 * 核心组件：
 * - RedissonClient: Redis客户端，用于配置存储和发布订阅
 * - IDynamicConfigCenterService: 配置中心核心服务接口
 * - DynamicConfigCenterAdjustListener: 配置变更监听器
 * - RTopic: Redis消息主题，用于配置变更通知
 *
 * @Author: yang
 * @Description: 动态配置中心自动配置类，负责核心组件的初始化和注册
 */
@Configuration  // 标识为Spring配置类
@EnableConfigurationProperties({DynamicConfigCenterAutoProperties.class, DynamicConfigCenterRegisterAutoConfigProperties.class})  // 启用配置属性绑定
public class DynamicConfigCenterRegisterAutoConfig {

    private final Logger log = LoggerFactory.getLogger(DynamicConfigCenterRegisterAutoConfig.class);

    /**
     * 创建Redisson客户端Bean
     * 用于连接Redis服务器，作为配置中心的存储和消息总线
     *
     * @param properties Redis连接配置属性
     * @return RedissonClient实例
     */
    @Bean("WrenchRedissonClient")
    public RedissonClient redissonClient(DynamicConfigCenterRegisterAutoConfigProperties properties) {
        Config config = new Config();
        // 使用Jackson JSON编解码器，支持复杂对象的序列化
        config.setCodec(JsonJacksonCodec.INSTANCE);

        // 配置单节点Redis服务器连接
        config.useSingleServer()
                .setAddress("redis://" + properties.getHost() + ":" + properties.getPort())  // Redis服务器地址
                .setPassword(properties.getPassword())  // Redis密码
                .setConnectionPoolSize(properties.getPoolSize())  // 连接池大小
                .setConnectionMinimumIdleSize(properties.getMinIdleSize())  // 最小空闲连接数
                .setIdleConnectionTimeout(properties.getIdleTimeout())  // 空闲连接超时时间
                .setConnectTimeout(properties.getConnectTimeout())  // 连接超时时间
                .setRetryAttempts(properties.getRetryAttempts())  // 重试次数
                .setRetryInterval(properties.getRetryInterval())  // 重试间隔
                .setPingConnectionInterval(properties.getPingInterval())  // 心跳检测间隔
                .setKeepAlive(properties.isKeepAlive())  // 是否保持长连接
        ;

        RedissonClient redissonClient = Redisson.create(config);

        log.info("wrench，注册器（redis）链接初始化完成。host: {}, poolSize: {}, isShutdown: {}",
                properties.getHost(), properties.getPoolSize(), !redissonClient.isShutdown());

        return redissonClient;
    }

    /**
     * 创建动态配置中心服务Bean
     * 提供配置的读取、写入、更新等核心功能
     *
     * @param dynamicConfigCenterAutoProperties 配置属性
     * @param WrenchRedissonClient Redisson客户端
     * @return 配置中心服务实例
     */
    @Bean
    public IDynamicConfigCenterService dynamicConfigCenterService(
            DynamicConfigCenterAutoProperties dynamicConfigCenterAutoProperties,
            RedissonClient WrenchRedissonClient) {
        return new DynamicConfigCenterService(dynamicConfigCenterAutoProperties, WrenchRedissonClient);
    }

    /**
     * 创建配置变更监听器Bean
     * 负责处理配置变更消息并执行相应的更新操作
     *
     * @param dynamicConfigCenterService 配置中心服务
     * @return 配置变更监听器实例
     */
    @Bean
    public DynamicConfigCenterAdjustListener dynamicConfigCenterAdjustListener(
            IDynamicConfigCenterService dynamicConfigCenterService) {
        return new DynamicConfigCenterAdjustListener(dynamicConfigCenterService);
    }

    /**
     * 创建Redis消息主题Bean并注册监听器
     * 用于发布和订阅配置变更消息
     *
     * @param dynamicConfigCenterAutoProperties 配置属性
     * @param redissonClient Redisson客户端
     * @param dynamicConfigCenterAdjustListener 配置变更监听器
     * @return Redis消息主题实例
     */
    @Bean(name = "dynamicConfigCenterRedisTopic")
    public RTopic threadPoolConfigAdjustListener(
            DynamicConfigCenterAutoProperties dynamicConfigCenterAutoProperties,
            RedissonClient redissonClient,
            DynamicConfigCenterAdjustListener dynamicConfigCenterAdjustListener) {
        // 获取系统对应的消息主题，格式为：system:config:topic
        RTopic topic = redissonClient.getTopic(Constant.getTopic(dynamicConfigCenterAutoProperties.getSystem()));
        // 注册消息监听器，监听AttributeVO类型的消息
        topic.addListener(AttributeVO.class, dynamicConfigCenterAdjustListener);
        return topic;
    }
}

3.8 DynamicConfigCenterAutoProperties 动态配置中心属性配置属性类

读取系统标识等配置属性，生成完整的配置键。

java 复制代码

import com.yang.wrench.starter.dynamic.config.center.types.common.Constant;
import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * 动态配置中心属性配置类
 *
 * 功能说明：
 * 1. 用于读取和应用配置文件中以"wrench.config"为前缀的配置属性
 * 2. 提供配置键的生成方法，用于在配置中心中存储和检索配置
 * 3. 作为配置属性的承载对象，与Spring Boot的配置绑定机制集成
 *
 * 配置示例：
 * wrench:
 *   config:
 *     system: user-service  # 系统标识，用于配置键的前缀
 *
 * @Author: yang
 * @Description: 动态配置中心属性配置类，负责配置属性的加载和键的生成
 */
@ConfigurationProperties(prefix = "wrench.config", ignoreInvalidFields = true)  // 读取wrench.config前缀的配置，忽略无效字段
public class DynamicConfigCenterAutoProperties {

    /**
     * 系统标识
     * 用途：作为配置键的前缀，用于区分不同系统或服务的配置
     * 示例：如果system="user-service"，则生成的配置键为"user-service:attributeName"
     * 配置方式：在application.yml中配置 wrench.config.system=your-system-name
     */
    private String system;

    /**
     * 生成完整的配置键
     * 格式：system:attributeName
     *
     * @param attributeName 属性名称
     * @return 完整的配置键，用于在配置中心存储和检索
     *
     * 示例：
     * - getKey("timeout") → "user-service:timeout"
     * - getKey("database.url") → "user-service:database.url"
     */
    public String getKey(String attributeName) {
        return this.system + Constant.SYMBOL_COLON + attributeName;
    }

    public String getSystem() {
        return system;
    }

    public void setSystem(String system) {
        this.system = system;
    }
}

3.9 DynamicConfigCenterAutoConfig 动态配置中心自动配置类

通过BeanPostProcessor接口对所有Bean进行后处理，实现配置的动态代理和热更新。

java 复制代码

import com.yang.wrench.starter.dynamic.config.center.domain.service.IDynamicConfigCenterService;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.Configuration;

/**
 * 动态配置中心自动配置类
 *
 * 功能说明：
 * 1. 作为Spring Boot Starter的自动配置类，实现动态配置中心的自动装配
 * 2. 通过BeanPostProcessor接口对所有Bean进行后处理，实现配置的动态代理
 * 3. 提供运行时配置热更新能力，支持配置变更时的动态生效
 *
 * 工作原理：
 * - 在Spring容器初始化每个Bean后，通过IDynamicConfigCenterService对Bean进行代理
 * - 代理后的Bean能够监听配置中心的变更并实时更新自身配置
 *
 * @Author: yang
 * @Description: 动态配置中心自动配置类，负责配置的动态代理和热更新
 */
@Configuration
public class DynamicConfigCenterAutoConfig implements BeanPostProcessor {

    // 动态配置中心服务接口，提供配置代理能力
    private final IDynamicConfigCenterService dynamicConfigCenterService;

    /**
     * 构造函数，通过Spring依赖注入配置中心服务
     * @param dynamicConfigCenterService 动态配置中心服务实现
     */
    public DynamicConfigCenterAutoConfig(IDynamicConfigCenterService dynamicConfigCenterService) {
        this.dynamicConfigCenterService = dynamicConfigCenterService;
    }

    /**
     * Bean初始化后处理方法
     * 对容器中的所有Bean进行代理，使其具备动态配置能力
     *
     * @param bean 已经初始化的Bean实例
     * @param beanName Bean的名称
     * @return 代理后的Bean实例（如果该Bean需要动态配置）或原始Bean实例
     * @throws BeansException 如果代理过程中发生异常
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 使用动态配置中心服务对Bean进行代理
        // 代理后的Bean能够响应配置变更并自动更新
        return dynamicConfigCenterService.proxyObject(bean);
    }
}

3.10 DynamicConfigCenterAdjustListener 动态配置中心调整监听器

监听Redis发布订阅通道中的配置变更消息，并调用配置中心服务进行属性值调整。

java 复制代码

import com.yang.wrench.starter.dynamic.config.center.domain.model.valobj.AttributeVO;
import com.yang.wrench.starter.dynamic.config.center.domain.service.IDynamicConfigCenterService;
import org.redisson.api.listener.MessageListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 动态配置中心调整监听器
 * 负责监听配置属性的变更消息，并调用配置中心服务进行动态调整
 *
 * 功能说明：
 * 1. 监听Redis发布订阅通道中的配置属性变更消息
 * 2. 接收到消息后调用配置中心服务进行属性值调整
 * 3. 提供完整的异常处理和日志记录
 *
 * 技术实现：
 * - 基于Redisson的MessageListener实现消息监听
 * - 使用AttributeVO作为消息载体传递配置属性信息
 * - 依赖IDynamicConfigCenterService执行实际的配置调整逻辑
 */
public class DynamicConfigCenterAdjustListener implements MessageListener<AttributeVO> {

    private final Logger log = LoggerFactory.getLogger(DynamicConfigCenterAdjustListener.class);

    // 动态配置中心服务接口，用于执行配置调整操作
    private final IDynamicConfigCenterService dynamicConfigCenterService;

    /**
     * 构造函数，注入动态配置中心服务
     * @param dynamicConfigCenterService 配置中心服务实例
     */
    public DynamicConfigCenterAdjustListener(IDynamicConfigCenterService dynamicConfigCenterService) {
        this.dynamicConfigCenterService = dynamicConfigCenterService;
    }

    /**
     * 消息监听处理方法
     * 当配置属性变更消息到达时，调用配置中心服务进行属性值调整
     *
     * @param charSequence Redis通道名称
     * @param attributeVO 配置属性值对象，包含属性名和属性值
     */
    @Override
    public void onMessage(CharSequence charSequence, AttributeVO attributeVO) {
        try {
            // 记录接收到的配置属性信息
            log.info("DDC 配置 attribute:{} value:{}", attributeVO.getAttribute(), attributeVO.getValue());

            // 调用配置中心服务进行属性值调整
            dynamicConfigCenterService.adjustAttributeValue(attributeVO);
        } catch (Exception e) {
            // 记录配置调整过程中的异常信息
            log.error("DDC 配置 attribute:{} value:{}", attributeVO.getAttribute(), attributeVO.getValue(), e);
        }
    }
}

3.11 IDynamicConfigCenterService 动态配置中心服务接口

定义配置管理的核心操作，包括Bean代理和配置调整。

java 复制代码

import com.yang.wrench.starter.dynamic.config.center.domain.model.valobj.AttributeVO;

/**
 * 动态配置中心服务接口
 *
 * 功能说明：
 * 1. 提供动态配置的核心服务能力，包括Bean代理和配置调整
 * 2. 作为配置中心与业务应用之间的桥梁，实现配置的动态管理
 * 3. 支持配置的实时更新和生效，无需重启应用
 *
 * 核心功能：
 * - Bean代理：对Spring Bean进行包装，使其具备动态配置能力
 * - 配置调整：接收配置变更通知并更新对应的Bean字段值
 *
 * @Author: yang
 * @Description: 动态配置中心服务接口，定义配置管理的核心操作
 */
public interface IDynamicConfigCenterService {

    /**
     * 代理对象方法
     * 对Spring Bean进行代理，使其具备动态配置能力
     *
     * @param bean 需要被代理的原始Bean对象
     * @return 代理后的Bean对象（具备动态配置能力）
     *
     * 工作原理：
     * 1. 扫描Bean中所有带有@DCCValue注解的字段
     * 2. 根据注解配置从配置中心获取初始值
     * 3. 创建代理对象，拦截字段访问和配置更新
     * 4. 注册配置变更监听器
     */
    Object proxyObject(Object bean);

    /**
     * 调整属性值方法
     * 处理配置变更消息，更新对应的Bean字段值
     *
     * @param attributeVO 属性值对象，包含配置键和新的配置值
     *
     * 示例：
     * attributeVO: {attribute: "user-service:timeout", value: "5000"}
     * → 更新所有@DCCValue("user-service:timeout")标注的字段值为5000
     */
    void adjustAttributeValue(AttributeVO attributeVO);

}

3.12 DynamicConfigCenterService 动态配置中心服务实现类

实现配置管理的核心逻辑，包括代理对象和处理配置变更。

java 复制代码

import com.yang.wrench.starter.dynamic.config.center.config.DynamicConfigCenterAutoProperties;
import com.yang.wrench.starter.dynamic.config.center.domain.model.valobj.AttributeVO;
import com.yang.wrench.starter.dynamic.config.center.types.annotations.DCCValue;
import com.yang.wrench.starter.dynamic.config.center.types.common.Constant;
import org.apache.commons.lang.StringUtils;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.framework.AopProxyUtils;
import org.springframework.aop.support.AopUtils;

import java.lang.reflect.Field;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: yang
 * @Description: 动态配置中心服务实现类
 */

public class DynamicConfigCenterService implements IDynamicConfigCenterService{

    private final Logger log = LoggerFactory.getLogger(DynamicConfigCenterService.class);

    private final DynamicConfigCenterAutoProperties properties;
    private final RedissonClient redissonClient;
    private final Map<String, Object> dccBeamGroup = new ConcurrentHashMap<>();

    public DynamicConfigCenterService(DynamicConfigCenterAutoProperties dynamicConfigCenterAutoProperties, RedissonClient redissonClient) {
        this.properties = dynamicConfigCenterAutoProperties;
        this.redissonClient = redissonClient;
    }

    /**
     * 代理对象方法 - 处理带有@DCCValue注解的字段
     * 1. 支持AOP代理对象的处理
     * 2. 从配置中心读取配置值并注入字段
     * 3. 缓存Bean对象用于后续配置更新
     */
    @Override
    public Object proxyObject(Object bean) {
        Class<?> targetBeanClass = bean.getClass();
        Object targetBeanObject = bean;
        // 处理AOP代理对象，获取目标类
        if (AopUtils.isAopProxy(bean)){
            targetBeanClass = AopUtils.getTargetClass(bean);
            targetBeanObject = AopProxyUtils.getSingletonTarget(bean);
        }

        // 扫描所有字段，查找@DCCValue注解
        Field[] fields = targetBeanClass.getDeclaredFields();
        for (Field field : fields) {
            if (!field.isAnnotationPresent(DCCValue.class)) {
                continue;
            }
            DCCValue dccValue = field.getAnnotation(DCCValue.class);
            String value = dccValue.value();
            if (StringUtils.isBlank(value)) {
                throw new RuntimeException("DCCValue注解的value属性不能为空");
            }
            // 解析注解值格式：attribute:defaultValue
            // @DCCValue("user:10") → 分割为["user", "10"]
            String[] split = value.split(Constant.SYMBOL_COLON);
            // 生成完整的配置键：system:attribute
            String key = properties.getKey(split[0].trim());

            // 获取默认值
            String defaultValue = split.length == 2 ? split[1] : null;
            String setValue = defaultValue;

            try{
                if (StringUtils.isBlank(defaultValue)){
                    throw new RuntimeException("DCCValue注解的value属性不能为空");
                }

                // 从Redis配置中心读取配置
                RBucket<String> bucket = redissonClient.getBucket(key);
                if (!bucket.isExists()) {
                    // 配置不存在，使用默认值并保存到配置中心
                    bucket.set(defaultValue);
                } else {
                    // 配置存在，使用配置中心的值
                    setValue = bucket.get();
                }
                // 反射设置字段值
                field.setAccessible(true);
                field.set(targetBeanObject, setValue);
                field.setAccessible(false);
            } catch (Exception e) {
                throw new RuntimeException("获取属性值失败" + e);
            }

            // 缓存Bean对象，key为配置键，value为Bean实例
            dccBeamGroup.put(key, targetBeanObject);
        }

        return bean;
    }

    /**
     * 调整属性值方法 - 响应配置变更
     * 1. 更新配置中心的值
     * 2. 更新所有相关Bean的字段值
     */
    @Override
    public void adjustAttributeValue(AttributeVO attributeVO) {
        String key = properties.getKey(attributeVO.getAttribute());
        String value = attributeVO.getValue();
        // 更新配置中心的值
        RBucket<String> bucket = redissonClient.getBucket(key);
        if (!bucket.isExists()){
            return;
        }
        bucket.set(value);

        // 获取使用该配置的Bean对象
        Object objectBean = dccBeamGroup.get(key);
        if (objectBean == null){
            return;
        }
        Class<?> objectBeanClass = objectBean.getClass();

        // 处理AOP代理对象
        if (AopUtils.isAopProxy(objectBean)){
            objectBeanClass = AopUtils.getTargetClass(objectBean);
        }

        try {
            // 通过反射更新字段值
            Field field = objectBeanClass.getDeclaredField(attributeVO.getAttribute());
            field.setAccessible(true);
            field.set(objectBean, value);
            field.setAccessible(false);
        } catch(Exception e){
            throw new RuntimeException("刷新属性值失败" + e);
        }
    }
}

四、测试动态配置

通过测试类验证动态配置的功能，包括初始化和动态更新配置值。测试结果显示配置能够实时生效，无需重启应用。

4.1 application.yml配置文件

javascript 复制代码

server:
  port: 9191

# 组件配置
wrench:
  config:
    system: test-system
    register:
      # redis host
      host: 127.0.0.1
      # redis port
      port: 6379

# 日志
logging:
  level:
    root: info
  config: classpath:logback-spring.xml

4.2 ApiTest 测试类

java 复制代码

import com.yang.wrench.starter.dynamic.config.center.domain.model.valobj.AttributeVO;
import com.yang.wrench.starter.dynamic.config.center.types.annotations.DCCValue;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.redisson.api.RTopic;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.concurrent.CountDownLatch;

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest()
public class ApiTest {

    @DCCValue("test:0")
    private String test;

    @Resource
    private RTopic dynamicConfigCenterRedisTopic;

    @Test
    public void test_get() throws InterruptedException {
        log.info("测试结果:{}", test);
    }

    @Test
    public void test_publish() throws InterruptedException {
        // 推送
        dynamicConfigCenterRedisTopic.publish(new AttributeVO("test", "4"));

        new CountDownLatch(1).await();
    }

}