SpringBoot中10种动态修改配置的方法

风象南2025-05-16 8:16

在SpringBoot应用中，配置信息通常通过application.properties或application.yml文件静态定义，应用启动后这些配置就固定下来了。

但我们常常需要在不重启应用的情况下动态修改配置，以实现灰度发布、A/B测试、动态调整线程池参数、切换功能开关等场景。

本文将介绍SpringBoot中10种实现配置动态修改的方法。

1. @RefreshScope结合Actuator刷新端点

Spring Cloud提供的@RefreshScope注解是实现配置热刷新的基础方法。

实现步骤

  1. 添加依赖：

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

  2. 开启刷新端点：

    management.endpoints.web.exposure.include=refresh

  3. 给配置类添加@RefreshScope注解：

    @RefreshScope
    @RestController
    public class ConfigController {

    复制代码 
     @Value("${app.message:Default message}")
 private String message;
 
 @GetMapping("/message")
 public String getMessage() {
     return message;
 }

    }

  4. 修改配置后，调用刷新端点：

    curl -X POST http://localhost:8080/actuator/refresh

优缺点

优点

  • 实现简单，利用Spring Cloud提供的现成功能
  • 无需引入额外的配置中心

缺点

  • 需要手动触发刷新
  • 只能刷新单个实例，在集群环境中需要逐个调用
  • 只能重新加载配置源中的值，无法动态添加新配置

2. Spring Cloud Config配置中心

Spring Cloud Config提供了一个中心化的配置服务器，支持配置文件的版本控制和动态刷新。

实现步骤

  1. 设置Config Server：

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

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

    spring.cloud.config.server.git.uri=https://github.com/your-repo/config

  2. 客户端配置：

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

    bootstrap.properties

    spring.application.name=my-service
    spring.cloud.config.uri=http://localhost:8888

  3. 添加自动刷新支持：

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

优缺点

优点

  • 提供配置的版本控制
  • 支持配置的环境隔离
  • 通过Spring Cloud Bus可实现集群配置的自动刷新

缺点

  • 引入了额外的基础设施复杂性
  • 依赖额外的消息总线实现集群刷新
  • 配置更新有一定延迟

3. 基于数据库的配置存储

将配置信息存储在数据库中，通过定时任务或事件触发机制实现配置刷新。

实现方案

  1. 创建配置表：

    CREATE TABLE app_config (
    config_key VARCHAR(100) PRIMARY KEY,
    config_value VARCHAR(500) NOT NULL,
    description VARCHAR(200),
    update_time TIMESTAMP
    );

  2. 实现配置加载和刷新：

    @Service
    public class DatabaseConfigService {

    复制代码 
     @Autowired
 private JdbcTemplate jdbcTemplate;
 
 private Map<String, String> configCache = new ConcurrentHashMap<>();
 
 @PostConstruct
 public void init() {
     loadAllConfig();
 }
 
 @Scheduled(fixedDelay = 60000)  // 每分钟刷新
 public void loadAllConfig() {
     List<Map<String, Object>> rows = jdbcTemplate.queryForList("SELECT config_key, config_value FROM app_config");
     for (Map<String, Object> row : rows) {
         configCache.put((String) row.get("config_key"), (String) row.get("config_value"));
     }
 }
 
 public String getConfig(String key, String defaultValue) {
     return configCache.getOrDefault(key, defaultValue);
 }

    }

优缺点

优点

  • 简单直接，无需额外组件
  • 可以通过管理界面实现配置可视化管理
  • 配置持久化，重启不丢失

缺点

  • 刷新延迟取决于定时任务间隔
  • 数据库成为潜在的单点故障
  • 需要自行实现配置的版本控制和权限管理

4. 使用ZooKeeper管理配置

利用ZooKeeper的数据变更通知机制，实现配置的实时动态更新。

实现步骤

  1. 添加依赖：

    <dependency> <groupId>org.apache.curator</groupId> <artifactId>curator-recipes</artifactId> <version>5.1.0</version> </dependency>

  2. 实现配置监听：

    @Component
    public class ZookeeperConfigManager {

    复制代码 
     private final CuratorFramework client;
 private final Map<String, String> configCache = new ConcurrentHashMap<>();
 
 @Autowired
 public ZookeeperConfigManager(CuratorFramework client) {
     this.client = client;
     initConfig();
 }
 
 private void initConfig() {
     try {
         String configPath = "/config";
         if (client.checkExists().forPath(configPath) == null) {
             client.create().creatingParentsIfNeeded().forPath(configPath);
         }
         
         List<String> keys = client.getChildren().forPath(configPath);
         for (String key : keys) {
             String fullPath = configPath + "/" + key;
             byte[] data = client.getData().forPath(fullPath);
             configCache.put(key, new String(data));
             
             // 添加监听器
             NodeCache nodeCache = new NodeCache(client, fullPath);
             nodeCache.getListenable().addListener(() -> {
                 byte[] newData = nodeCache.getCurrentData().getData();
                 configCache.put(key, new String(newData));
                 System.out.println("Config updated: " + key + " = " + new String(newData));
             });
             nodeCache.start();
         }
     } catch (Exception e) {
         throw new RuntimeException("Failed to initialize config from ZooKeeper", e);
     }
 }
 
 public String getConfig(String key, String defaultValue) {
     return configCache.getOrDefault(key, defaultValue);
 }

    }

优缺点

优点

  • 实时通知，配置变更后立即生效
  • ZooKeeper提供高可用性保证
  • 适合分布式环境下的配置同步

缺点

  • 需要维护ZooKeeper集群
  • 配置管理不如专用配置中心直观
  • 存储大量配置时性能可能受影响

5. Redis发布订阅机制实现配置更新

利用Redis的发布订阅功能，实现配置变更的实时通知。

实现方案

  1. 添加依赖：

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

  2. 实现配置刷新监听：

    @Component
    public class RedisConfigManager {

    复制代码 
     @Autowired
 private StringRedisTemplate redisTemplate;
 
 private final Map<String, String> configCache = new ConcurrentHashMap<>();
 
 @PostConstruct
 public void init() {
     loadAllConfig();
     subscribeConfigChanges();
 }
 
 private void loadAllConfig() {
     Set<String> keys = redisTemplate.keys("config:*");
     if (keys != null) {
         for (String key : keys) {
             String value = redisTemplate.opsForValue().get(key);
             configCache.put(key.replace("config:", ""), value);
         }
     }
 }
 
 private void subscribeConfigChanges() {
     redisTemplate.getConnectionFactory().getConnection().subscribe(
         (message, pattern) -> {
             String[] parts = new String(message.getBody()).split("=");
             if (parts.length == 2) {
                 configCache.put(parts[0], parts[1]);
             }
         },
         "config-channel".getBytes()
     );
 }
 
 public String getConfig(String key, String defaultValue) {
     return configCache.getOrDefault(key, defaultValue);
 }
 
 // 更新配置的方法（管理端使用）
 public void updateConfig(String key, String value) {
     redisTemplate.opsForValue().set("config:" + key, value);
     redisTemplate.convertAndSend("config-channel", key + "=" + value);
 }

    }

优缺点

优点

  • 实现简单，利用Redis的发布订阅机制
  • 集群环境下配置同步实时高效
  • 可以与现有Redis基础设施集成

缺点

  • 依赖Redis的可用性
  • 需要确保消息不丢失
  • 缺乏版本控制和审计功能

6. 自定义配置加载器和监听器

通过自定义Spring的PropertySource和文件监听机制，实现本地配置文件的动态加载。

实现方案

复制代码 
@Component
public class DynamicPropertySource implements ApplicationContextAware {
    
    private static final Logger logger = LoggerFactory.getLogger(DynamicPropertySource.class);
    private ConfigurableApplicationContext applicationContext;
    private File configFile;
    private Properties properties = new Properties();
    private FileWatcher fileWatcher;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = (ConfigurableApplicationContext) applicationContext;
        try {
            configFile = new File("config/dynamic.properties");
            if (configFile.exists()) {
                loadProperties();
                registerPropertySource();
                startFileWatcher();
            }
        } catch (Exception e) {
            logger.error("Failed to initialize dynamic property source", e);
        }
    }
    
    private void loadProperties() throws IOException {
        try (FileInputStream fis = new FileInputStream(configFile)) {
            properties.load(fis);
        }
    }
    
    private void registerPropertySource() {
        MutablePropertySources propertySources = applicationContext.getEnvironment().getPropertySources();
        PropertiesPropertySource propertySource = new PropertiesPropertySource("dynamic", properties);
        propertySources.addFirst(propertySource);
    }
    
    private void startFileWatcher() {
        fileWatcher = new FileWatcher(configFile);
        fileWatcher.setListener(new FileChangeListener() {
            @Override
            public void fileChanged() {
                try {
                    Properties newProps = new Properties();
                    try (FileInputStream fis = new FileInputStream(configFile)) {
                        newProps.load(fis);
                    }
                    
                    // 更新已有属性
                    MutablePropertySources propertySources = applicationContext.getEnvironment().getPropertySources();
                    PropertiesPropertySource oldSource = (PropertiesPropertySource) propertySources.get("dynamic");
                    if (oldSource != null) {
                        propertySources.replace("dynamic", new PropertiesPropertySource("dynamic", newProps));
                    }
                    
                    // 发布配置变更事件
                    applicationContext.publishEvent(new EnvironmentChangeEvent(Collections.singleton("dynamic")));
                    
                    logger.info("Dynamic properties reloaded");
                } catch (Exception e) {
                    logger.error("Failed to reload properties", e);
                }
            }
        });
        fileWatcher.start();
    }
    
    // 文件监听器实现（简化版）
    private static class FileWatcher extends Thread {
        private final File file;
        private FileChangeListener listener;
        private long lastModified;
        
        public FileWatcher(File file) {
            this.file = file;
            this.lastModified = file.lastModified();
        }
        
        public void setListener(FileChangeListener listener) {
            this.listener = listener;
        }
        
        @Override
        public void run() {
            try {
                while (!Thread.interrupted()) {
                    long newLastModified = file.lastModified();
                    if (newLastModified != lastModified) {
                        lastModified = newLastModified;
                        if (listener != null) {
                            listener.fileChanged();
                        }
                    }
                    Thread.sleep(5000);  // 检查间隔
                }
            } catch (InterruptedException e) {
                // 线程中断
            }
        }
    }
    
    private interface FileChangeListener {
        void fileChanged();
    }
}

优缺点

优点

  • 不依赖外部服务，完全自主控制
  • 可以监控本地文件变更实现实时刷新
  • 适合单体应用或简单场景

缺点

  • 配置分发需要额外机制支持
  • 集群环境下配置一致性难以保证
  • 需要较多自定义代码

7. Apollo配置中心

携程开源的Apollo是一个功能强大的分布式配置中心，提供配置修改、发布、回滚等完整功能。

实现步骤

  1. 添加依赖：

    <dependency> <groupId>com.ctrip.framework.apollo</groupId> <artifactId>apollo-client</artifactId> <version>2.0.1</version> </dependency>

  2. 配置Apollo客户端：

    app.properties

    app.id=your-app-id
    apollo.meta=http://apollo-config-service:8080

  3. 启用Apollo：

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

  4. 使用配置：

    @Component
    public class SampleService {

    复制代码 
     @Value("${timeout:1000}")
 private int timeout;
 
 // 监听特定配置变更
 @ApolloConfigChangeListener
 public void onConfigChange(ConfigChangeEvent event) {
     if (event.isChanged("timeout")) {
         ConfigChange change = event.getChange("timeout");
         System.out.println("timeout changed from " + change.getOldValue() + " to " + change.getNewValue());
         // 可以在这里执行特定逻辑，如重新初始化线程池等
     }
 }

    }

优缺点

优点

  • 提供完整的配置管理界面
  • 支持配置的灰度发布
  • 具备权限控制和操作审计
  • 集群自动同步，无需手动刷新

缺点

  • 需要部署和维护Apollo基础设施
  • 学习成本相对较高
  • 小型项目可能过于重量级

8. Nacos配置管理

阿里开源的Nacos既是服务发现组件，也是配置中心，广泛应用于Spring Cloud Alibaba生态。

实现步骤

  1. 添加依赖：

    <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId> </dependency>

  2. 配置Nacos：

    bootstrap.properties

    spring.application.name=my-service
    spring.cloud.nacos.config.server-addr=127.0.0.1:8848

    支持多配置文件

    spring.cloud.nacos.config.extension-configs[0].data-id=database.properties
    spring.cloud.nacos.config.extension-configs[0].group=DEFAULT_GROUP
    spring.cloud.nacos.config.extension-configs[0].refresh=true

  3. 使用配置：

    @RestController
    @RefreshScope
    public class ConfigController {

    复制代码 
     @Value("${useLocalCache:false}")
 private boolean useLocalCache;
 
 @GetMapping("/cache")
 public boolean getUseLocalCache() {
     return useLocalCache;
 }

    }

优缺点

优点

  • 与Spring Cloud Alibaba生态无缝集成
  • 配置和服务发现功能二合一
  • 轻量级，易于部署和使用
  • 支持配置的动态刷新和监听

缺点

  • 部分高级功能不如Apollo丰富
  • 需要额外维护Nacos服务器
  • 需要使用bootstrap配置机制

9. Spring Boot Admin与Actuator结合

Spring Boot Admin提供了Web UI来管理和监控Spring Boot应用，结合Actuator的环境端点可以实现配置的可视化管理。

实现步骤

  1. 设置Spring Boot Admin服务器：

    <dependency> <groupId>de.codecentric</groupId> <artifactId>spring-boot-admin-starter-server</artifactId> <version>2.7.0</version> </dependency>

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

  2. 配置客户端应用：

    <dependency> <groupId>de.codecentric</groupId> <artifactId>spring-boot-admin-starter-client</artifactId> <version>2.7.0</version> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency>

    spring.boot.admin.client.url=http://localhost:8080
    management.endpoints.web.exposure.include=*
    management.endpoint.env.post.enabled=true

  3. 通过Spring Boot Admin UI修改配置

Spring Boot Admin提供UI界面，可以查看和修改应用的环境属性。通过发送POST请求到/actuator/env端点修改配置。

优缺点

优点

  • 提供可视化操作界面
  • 与Spring Boot自身监控功能集成
  • 无需额外的配置中心组件

缺点

  • 修改的配置不持久化，应用重启后丢失
  • 安全性较弱，需要额外加强保护
  • 不适合大规模生产环境的配置管理

10. 使用@ConfigurationProperties结合EventListener

利用Spring的事件机制和@ConfigurationProperties绑定功能，实现配置的动态更新。

实现方案

  1. 定义配置属性类：

    @Component
    @ConfigurationProperties(prefix = "app")
    @Setter
    @Getter
    public class ApplicationProperties {

    复制代码 
     private int connectionTimeout;
 private int readTimeout;
 private int maxConnections;
 private Map<String, String> features = new HashMap<>();
 
 // 初始化客户端的方法
 public HttpClient buildHttpClient() {
     return HttpClient.newBuilder()
             .connectTimeout(Duration.ofMillis(connectionTimeout))
             .build();
 }

    }

  2. 添加配置刷新机制：

    @Component
    @RequiredArgsConstructor
    public class ConfigRefresher {

    复制代码 
     private final ApplicationProperties properties;
 private final ApplicationContext applicationContext;
 private HttpClient httpClient;
 
 @PostConstruct
 public void init() {
     refreshHttpClient();
 }
 
 @EventListener(EnvironmentChangeEvent.class)
 public void onEnvironmentChange() {
     refreshHttpClient();
 }
 
 private void refreshHttpClient() {
     httpClient = properties.buildHttpClient();
     System.out.println("HttpClient refreshed with timeout: " + properties.getConnectionTimeout());
 }
 
 public HttpClient getHttpClient() {
     return this.httpClient;
 }
 
 // 手动触发配置刷新的方法
 public void refreshProperties(Map<String, Object> newProps) {
     PropertiesPropertySource propertySource = new PropertiesPropertySource(
             "dynamic", convertToProperties(newProps));
     
     ConfigurableEnvironment env = (ConfigurableEnvironment) applicationContext.getEnvironment();
     env.getPropertySources().addFirst(propertySource);
     
     // 触发环境变更事件
     applicationContext.publishEvent(new EnvironmentChangeEvent(newProps.keySet()));
 }
 
 private Properties convertToProperties(Map<String, Object> map) {
     Properties properties = new Properties();
     for (Map.Entry<String, Object> entry : map.entrySet()) {
         properties.put(entry.getKey(), entry.getValue().toString());
     }
     return properties;
 }

    }

优缺点

优点

  • 强类型的配置绑定
  • 利用Spring内置机制，无需额外组件
  • 灵活性高，可与其他配置源结合

缺点

  • 需要编写较多代码
  • 配置变更通知需要额外实现
  • 不适合大规模或跨服务的配置管理

方法比较与选择指南

方法 易用性 功能完整性 适用规模 实时性
@RefreshScope+Actuator ★★★★★ ★★ 小型 手动触发
Spring Cloud Config ★★★ ★★★★ 中大型 需配置
数据库存储 ★★★★ ★★★ 中型 定时刷新
ZooKeeper ★★★ ★★★ 中型 实时
Redis发布订阅 ★★★★ ★★★ 中型 实时
自定义配置加载器 ★★ ★★★ 小型 定时刷新
Apollo ★★★ ★★★★★ 中大型 实时
Nacos ★★★★ ★★★★ 中大型 实时
Spring Boot Admin ★★★★ ★★ 小型 手动触发
@ConfigurationProperties+事件 ★★★ ★★★ 小型 事件触发

总结

动态配置修改能够提升系统的灵活性和可管理性，选择合适的动态配置方案应综合考虑应用规模、团队熟悉度、基础设施现状和业务需求。

无论选择哪种方案，确保配置的安全性、一致性和可追溯性都是至关重要的。

相关推荐
banzhenfei2 分钟前
xp_cmdshell bcp 导出文件
java·数据库·sql
tonngw2 分钟前
【Mac 从 0 到 1 保姆级配置教程 12】- 安装配置万能的编辑器 VSCode 以及常用插件
git·vscode·后端·macos·开源·编辑器·github
带刺的坐椅4 分钟前
SpringBoot3 使用 SolonMCP 开发 MCP
java·ai·springboot·solon·mcp
胡斌附体36 分钟前
微服务调试问题总结
java·微服务·架构·调试·本地·夸微服务联调
bing_1581 小时前
Spring MVC HttpMessageConverter 的作用是什么？
java·spring·mvc
笨蛋不要掉眼泪1 小时前
SpringAOP
java·数据库·spring·log4j
noravinsc1 小时前
InforSuite RDS 与django结合
后端·python·django
oioihoii1 小时前
C++23 新增的查找算法详解：ranges::find_last 系列函数
java·算法·c++23
酷炫码神2 小时前
C#数据类型
java·服务器·c#
Brookty2 小时前
【MySQL】基础知识
后端·学习·mysql
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05Coze扣子平台完整体验和实践（附国内和国际版对比）06DeepSeek各版本说明与优缺点分析07【解决】Android Gradle Sync 报错 Could not read workspace metadata08YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU09苍穹外卖面试总结10yolov10来了！用yolov10训练自己的数据集（原理、训练、部署、应用）