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));
        }
    }
}