Spring动态监听Nacos配置中心key值变更的实现方法

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ConfigListener {
 
    /**
     * 待监听的key或key前缀
     */
    String key();
 
}

@Slf4j
@Configuration
public class RefreshEnvironmentConfig implements ApplicationListener<EnvironmentChangeEvent>, EnvironmentAware, BeanPostProcessor {
 
    private Environment environment;
 
    private final Map<String, Map<Method, Object>> listeners = new ConcurrentHashMap<>(64);
 
    private final Set<Class<?>> nonAnnotatedClasses = Collections.newSetFromMap(new ConcurrentHashMap<>(64));
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (!this.nonAnnotatedClasses.contains(bean.getClass())) {
            Class<?> targetClass = AopUtils.getTargetClass(bean);
            Map<Method, ConfigListener> annotatedMethods = MethodIntrospector.selectMethods(targetClass, this::findListenerAnnotations);
            if (!annotatedMethods.isEmpty()) {
                for (Map.Entry<Method, ConfigListener> entry : annotatedMethods.entrySet()) {
                    listeners.computeIfAbsent(entry.getValue().key(), k -> new HashMap<>()).put(entry.getKey(), bean);
                    log.info("Register @ConfigListener methods processed on bean {} listener key {}", beanName, entry.getValue().key());
                }
            }
            this.nonAnnotatedClasses.add(bean.getClass());
        }
        return bean;
 
    }
 
    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        Set<String> keys = event.getKeys();
        keys.forEach(key -> {
            String value = environment.getProperty(key);
            int index = 0;
            do {
                index = key.indexOf(".", index + 1);
                String subKey = index > 0 ? key.substring(0, index) : key;
                Map<Method, Object> methodMap = listeners.get(subKey);
                if (methodMap != null) {
                    methodMap.forEach((method, bean) -> {
                        try {
                            method.invoke(bean, key, value);
                        } catch (IllegalAccessException | InvocationTargetException e) {
                            log.error("Refresh @ConfigListener {}, error {}", bean, e.getMessage(), e);
                        }
                    });
                }
            } while (index > 0);
        });
    }
 
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }
 
 
    private ConfigListener findListenerAnnotations(Method method) {
        return findListenerAnnotationsByAnnotatedElement(method);
    }
 
    private ConfigListener findListenerAnnotationsByAnnotatedElement(AnnotatedElement element) {
        return AnnotationUtils.findAnnotation(element, ConfigListener.class);
    }
}

    @ConfigListener(key = "test.value")
    public void listener1(String key, String newValue) {
        log.info("listener1 listened {}-->{}", key, newValue);
    }
 
    @Async
    @ConfigListener(key = "test")
    public void listener2(String key, String newValue) {
        log.info("listener2 listened {}-->{}", key, newValue);
    }

    <properties>
        <spring-boot.version>2.4.2</spring-boot.version>
        <spring-cloud.version>2020.0.1</spring-cloud.version>
        <spring-cloud-alibaba.version>2021.1</spring-cloud-alibaba.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-bootstrap</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
    </dependencies>

server:
  port: 8080
---
spring:
  application:
  #需要指定
    name: gateway
  profiles:
    active: dev
---
spring:
  cloud:
    nacos:
      discovery:
      #需要配置
        server-addr: 192.168.56.150:8848
        group: DEFAULT_GROUP
      config:
            #需要配置
        server-addr: 192.168.56.150:8848
        group: DEFAULT_GROUP
        file-extension: yaml
        extension-configs:
          - data-id: gateway-routes.yaml
            group: DEFAULT_GROUP
            refresh: true
          - data-id: other.yaml
            group: DEFAULT_GROUP
            refresh: true

@RefreshScope//Bean 在运行时刷新
@ConfigurationProperties(prefix = "other")//要绑定外部属性的前缀
@Configuration//设置为bean
public class Config {
	//映射other.yaml ->oher.name
    private String name;
    
    //映射other.yaml ->oher.age
    private String age;
    
    //启动后定时打印当前bean中的值,不推荐这种方式,做测试方法
    @PostConstruct
    public void testValueIsChange() {
        new Thread(() -> {
            int i = 1;
            do {
                Config bean = SpringBeanUtil.getBean(Config.class);
                System.out.println("--- >" + i + "-->当前bean值: " + "name:" + bean.getName() + "|age:" + bean.getAge());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                i++;
            } while (true);
        }).start();
    }
    
   //....get/set方法
}  

@Component
public class OtherListen {

    @Resource//注入NacosConfigManager
    public void nacosListen(NacosConfigManager nacosConfigManager) {
    	//获取配置中心服务
        ConfigService configService = nacosConfigManager.getConfigService();
        try {
        	//对配置中心添加监听(配置文件的dataId,group)
            configService.addListener("other.yaml", "DEFAULT_GROUP", new AbstractConfigChangeListener() {
            	//监听后的处理逻辑
                @Override
                public void receiveConfigChange(ConfigChangeEvent configChangeEvent) {
                    for (ConfigChangeItem changeItem : configChangeEvent.getChangeItems()) {
                        System.out.println("nacos方式监听" + changeItem.getKey() + "-----" + changeItem.getNewValue());
                    }
                }
            });
        } catch (NacosException e) {
            throw new RuntimeException(e);
        }
    }
    
	//注解监听spring.cloud环境下需要添加额外依赖,可以参考官方文档,这里不做演示
    @NacosConfigListener(dataId = "other.yaml")
    public void onReceived(String value) {
        System.out.println("onReceived : " + value);
    }
}

@Component
public class OtherListen implements ApplicationListener<EnvironmentChangeEvent> {
    @Resource
    private ConfigurableEnvironment environment;
    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        for (String key : event.getKeys()) {
            System.out.println("spring方式监听: key:" + key + "value:" + environment.getProperty(key));
        }
    }
}