springboot apollo 自动刷新

最新推荐文章于 2025-06-02 13:32:15 发布

北纬@叶枫

最新推荐文章于 2025-06-02 13:32:15 发布

阅读量1.9k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： java 文章标签： apollo 自动刷新

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.youkuaiyun.com/Farrell_zeng/article/details/103049394

java 专栏收录该内容

28 篇文章

订阅专栏

本文详细介绍如何使用Apollo配置中心实现应用配置的自动刷新。包括引入依赖、配置文件设置、自定义配置类、实现自动刷新逻辑及测试用例。通过Apollo，可以实现在不重启服务的情况下动态更新配置。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、引入依赖

        <dependency>
            <groupId>com.ctrip.framework.apollo</groupId>
            <artifactId>apollo-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.ctrip.framework.apollo</groupId>
            <artifactId>apollo-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-context</artifactId>
        </dependency>

2、配置文件

env:
  dev
app:
  id: common-dictionaries
apollo:
  meta: http://127.0.0.1:26008
  autoUpdateInjectedSpringProperties: true
  bootstrap:
    enabled: true
    namespaces: application,jdbc,redis

3、设置配置文件

redis.single.host = 127.0.0.1
redis.single.database = 101
redis.single.testOnBorrow = true
redis.single.testOnReturn = true

4、需要自动刷新的类

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.cloud.context.config.annotation.RefreshScope;

/**
 * 单机模式redis配置信息
 */
@Data
@RefreshScope
@Configuration
public class RedisSingleProperties {


    /**
     * 连接地址
     */
    @Value("${redis.single.host:#{null}}")
    private String host;

     /**
     * 端口号，默认6379
     */
     @Value("${redis.single.port:6379}")
    private int port;

    /**
     * 连接超时时间,单位毫秒，默认3秒
     */
    @Value("${redis.single.timeout:3000}")
    private int timeout;

    /**
     * 连接密码
     */
    @Value("${redis.single.password:#{null}}")
    private String password;

    /**
     * 连接的DB
     */
    @Value("${redis.single.database:0}")
    private int database;

    /**
     * 资源次最大连接数，默认8
     */
    @Value("${redis.single.maxTotal:8}")
    private int maxTotal = 8;

    /**
     * 资源池允许最大空闲连接数	，默认8
     */
    @Value("${redis.single.maxIdle:8}")
    private int maxIdle = 8;

    /**
     * 资源池确保最少空闲连接数	,默认0
     */
    @Value("${redis.single.minIdle:0}")
    private int minIdle = 0;

    /**
     * 是否开启jmx监控，可用于监控,默认为true，开启状态
     */
    @Value("${redis.single.jmxEnabled:true}")
    private boolean jmxEnabled;

    /**
     * 当资源池用尽后，调用者是否要等待。只有当为true时，下面的maxWaitMillis才会生效
     * 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
     */
    @Value("${redis.single.blockWhenExhausted:true}")
    private boolean blockWhenExhausted = true;

    /**
     * 当资源池连接用尽后，调用者的最大等待时间（单位毫秒）	-1：表示永不超时
     * 获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
     */
    @Value("${redis.single.maxWaitMillis:-1}")
    private long maxWaitMillis;

    /**
     * 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
     */
    @Value("${redis.single.minEvictableIdleTimeMillis:1800000}")
    private long minEvictableIdleTimeMillis;

    /**
     * 向资源池借用连接时是否做连接有效性检查(ping)，无效连接会被移除,默认false
     */
    @Value("${redis.single.testOnBorrow:false}")
    private boolean testOnBorrow = false;

    /**
     * 向资源池归还连接时是否做连接有效性测试(ping)，无效连接会被移除	默认false
     */
    @Value("${redis.single.testOnReturn:false}")
    private boolean testOnReturn = false;
}

5、实现自动刷新



import com.ctrip.framework.apollo.model.ConfigChange;
import com.ctrip.framework.apollo.model.ConfigChangeEvent;
import com.ctrip.framework.apollo.spring.annotation.ApolloConfigChangeListener;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.cloud.context.environment.EnvironmentChangeEvent;
import org.springframework.cloud.context.scope.refresh.RefreshScope;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 自动刷新apollo配置
 */
@Slf4j
@Component
public class ApolloConfigChanged implements ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Resource
    private RefreshScope refreshScope;

    @ApolloConfigChangeListener(value = {"application","jdbc","redis"})
    public void onChange(ConfigChangeEvent changeEvent){
        log.info("================Apollo 自动刷新值 开始 ===========================");

        for (String changeKey : changeEvent.changedKeys()){
            ConfigChange configChange = changeEvent.getChange(changeKey);
            String oldValue = configChange.getOldValue();
            String newValue = configChange.getNewValue();
            log.info("changedKey:【{}】,oldValue=【{}】, newValue:【{}】", changeKey, oldValue, newValue);
        }

        refreshProperties(changeEvent);

        log.info("================Apollo 自动刷新值 结束 ===========================");
    }

    private void refreshProperties(ConfigChangeEvent changeEvent) {
        this.applicationContext.publishEvent(new EnvironmentChangeEvent(changeEvent.changedKeys()));
        refreshScope.refreshAll();
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

6、测试用例


import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * 测试apollo自动刷新
 *
 */
@RefreshScope
@RestController
public class TestController {

    @Value("${application.name:applicationName}")
    private String applicationName;

    @Resource
    private RedisSingleProperties redisSingleProperties;


    @GetMapping("application")
    public String application(){
        return applicationName;
    }


    @GetMapping("redis")
    public String redis(){
        return redisSingleProperties.getHost();
    }


}