一，背景
研究nacos时发现，springboot版本可使用@NacosValue实现配置的自动刷新，spring原生注解@Value则无法自动刷新
springcloud版本可采用两种方式实现自动刷新：
1.手动注入@NacosValue注解的处理器并使用该注解修饰相关字段或方法，这需要弄清楚底层的来龙去脉，比较麻烦，且不支持spring原生@Value注解。
2.借助@RefreshScope，将bean定义为RefreshScope。此方法也略显麻烦，每个存在配置需要刷新的类都要定义成RefreshScope。
本文为了解决上述问题而产生，实现@Value配置的自动刷新，
并且不是专门为nacos开发，只依赖springcloud的ContextRefresh机制（nacos的配置刷新也使用到了ContextRefresh）。
二，软件架构
基于springcloud的ContextRefresh机制，监听EnvironmentChangeEvent事件并重新注入@Value配置，需jdk1.8以上。
三，实现
package com.rutron.framework.conf;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.cloud.context.environment.EnvironmentChangeEvent;
import org.springframework.cloud.context.refresh.ContextRefresher;
import org.springframework.cloud.context.scope.refresh.RefreshScope;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Role;
import static org.springframework.beans.factory.config.BeanDefinition.ROLE_INFRASTRUCTURE;
/**
* 实现springcloud应用@Value配置的自动刷新
*
* @author lwc
*/
@Slf4j
@Configuration
@SuppressWarnings("ALL")
@ConditionalOnClass({ContextRefresher.class, RefreshScope.class, EnvironmentChangeEvent.class})
public class SpringValueAutoRefreshConfiguration {
public static final String PROCESSOR_BEAN_NAME = "com.rutron.framework.conf.SpringValueAutoRefreshProcessor";
@Role(ROLE_INFRASTRUCTURE)
@Bean(PROCESSOR_BEAN_NAME)
public BeanPostProcessor springValueAutoRefreshProcessor() {
return new SpringValueAutoRefreshProcessor();
}
}
package com.rutron.framework.conf;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.cloud.context.environment.EnvironmentChangeEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.BridgeMethodResolver;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.core.annotation.AnnotationAttributes;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
import java.beans.PropertyDescriptor;
import java.lang.annotation.Annotation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
/**
* 实现springcloud应用@Value配置的自动刷新
*
* @author lwc
*/
@Slf4j
@SuppressWarnings("ALL")
public class SpringValueAutoRefreshProcessor extends AutowiredAnnotationBeanPostProcessor implements BeanFactoryAware {
private ConfigurableListableBeanFactory beanFactory;
private final Class<? extends Annotation> refreshAnnotationType = Value.class;
private final Set<String> beanNamesNeedRefresh = new HashSet<>();
public SpringValueAutoRefreshProcessor() {
super.setAutowiredAnnotationType(this.refreshAnnotationType);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) {
super.setBeanFactory(beanFactory);
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
//do nothing
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) {
return pvs;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
this.processNeedRefresh(beanName, bean.getClass());
return bean;
}
@Override
public void setOrder(int order) {
super.setOrder(Ordered.LOWEST_PRECEDENCE - 1);
}
@EventListener(EnvironmentChangeEvent.class)
public void onApplicationEvent(EnvironmentChangeEvent event) {
final Set<String> keys = event.getKeys();
if (keys == null || keys.isEmpty()) {
return;
}
log.info("changed keys: {}", keys);
for (String beanName : beanNamesNeedRefresh) {
super.processInjection(beanFactory.getBean(beanName));
}
log.info("changed keys refresh finish");
}
private void processNeedRefresh(final String beanName, final Class<?> clazz) {
if (beanNamesNeedRefresh.contains(beanName)) {
return;
}
Class<?> targetClass = clazz;
do {
ReflectionUtils.doWithLocalFields(targetClass, field -> {
if (beanNamesNeedRefresh.contains(beanName) || Modifier.isStatic(field.getModifiers())) {
return;
}
AnnotationAttributes attributes = findAutowiredAnnotation(field);
if (Objects.nonNull(attributes)) {
beanNamesNeedRefresh.add(beanName);
}
});
if (!beanNamesNeedRefresh.isEmpty()) {
break;
}
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
if (beanNamesNeedRefresh.contains(beanName) ||
method.getParameterCount() == 0 || Modifier.isStatic(method.getModifiers())) {
return;
}
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
AnnotationAttributes attributes = findAutowiredAnnotation(bridgedMethod);
if (Objects.nonNull(attributes) && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
beanNamesNeedRefresh.add(beanName);
}
});
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
}
private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
if (ao.getAnnotations().length > 0) {
return AnnotatedElementUtils.getMergedAnnotationAttributes(ao, refreshAnnotationType);
}
return null;
}
}
