背景
关于配置的热更新，apollo 通过`com.ctrip.framework.apollo.spring.annotation.SpringValueProcessor` 处理带@Value的方法或字段，通过监听变更事件，采用反射去更新对应的值
但这个功能仅仅用于单个属性，当我有一组有关联关系的配置时，需要对每一个属性都进行@Value注解标记，这样不利于统一管理配置，比如像下面定义xxljob任务的一些属性
@Datapublic static class FlushConfig {//sleep-interval-mills@Value("${xxl-sharding-job.common.sleep-interval-mills:-1}")private Integer sleepIntervalMills;//batch-size@Value("${xxl-sharding-job.common.batch-size:1000}")private Integer batchSize;//max-retry@Value("${xxl-sharding-job.common.max-retry:1000}")private Integer maxRetry;} |
如果有新加的字段，Apollo和本地代码都需要改动，而且需要检查新加的字段是否有漏加注解的情况
另外如果对某个任务需要自定义属性，比如对某个任务自定义定义batchSize，还要在构造配置类，配置名称不同的key，不利于复用和管理
配置绑定
针对这个问题，springboot提供了@ConfigurationProperties注解把一些配置与java对象的属性进行绑定,我们可以定义这样一个配置类
@ConfigurationProperties(prefix = "xxl-sharding-job")
@Component
public class XxlShardingConfig {private FlushConfig common;private Map<String, FlushConfig> custom;@Datapublic static class FlushConfig {private Integer sleepIntervalMills;private Integer batchSize;private Integer maxRetry;}public int getBatchSize(String xxlJobName) {FlushConfig flushConfig = getFlushConfig(xxlJobName);return Optional.ofNullable(flushConfig.batchSize).orElse(common.batchSize);}private FlushConfig getFlushConfig(String xxlJobName) {if(custom==null){return common;}return custom.getOrDefault(xxlJobName, common);}public int getMaxRetry(String xxlJobName) {FlushConfig flushConfig = getFlushConfig(xxlJobName);return Optional.ofNullable(flushConfig.maxRetry).orElse(common.maxRetry);}public int getSleepIntervalMills(String xxlJobName) {FlushConfig flushConfig = getFlushConfig(xxlJobName);return Optional.ofNullable(flushConfig.sleepIntervalMills).orElse(common.sleepIntervalMills);}
} |
同时配置文件定义如下属性，即可实现配置绑定到属性
xxl-sharding-job.common.sleep-interval-mills=-1 xxl-sharding-job.common.batch-size=1000 xxl-sharding-job.common.max-retry=3 #特殊任务自定义 xxl-sharding-job.custom.yourTask.max-retry=5 |
基于这种配置类的方式，在特殊任务自定义属性的场景，我们无需修改配置类代码，配置类能提供相关的功能方法，更内聚，但缺陷是无法实现热更新
配置类热更新Demo
查阅apollo相关代码，官网给了个demo
有如下配置类
@ConditionalOnProperty("redis.cache.enabled")
@ConfigurationProperties(prefix = "redis.cache")
@Component("sampleRedisConfig")
@RefreshScope
public class SampleRedisConfig {private static final Logger logger = LoggerFactory.getLogger(SampleRedisConfig.class);private int expireSeconds;private String clusterNodes;private int commandTimeout;private Map<String, String> someMap = Maps.newLinkedHashMap();private List<String> someList = Lists.newLinkedList();@PostConstructprivate void initialize() {logger.info("SampleRedisConfig initialized - expireSeconds: {}, clusterNodes: {}, commandTimeout: {}, someMap: {}, someList: {}",expireSeconds, clusterNodes, commandTimeout, someMap, someList);}public void setExpireSeconds(int expireSeconds) {this.expireSeconds = expireSeconds;}public void setClusterNodes(String clusterNodes) {this.clusterNodes = clusterNodes;}public void setCommandTimeout(int commandTimeout) {this.commandTimeout = commandTimeout;}public Map<String, String> getSomeMap() {return someMap;}public List<String> getSomeList() {return someList;}@Overridepublic String toString() {return String.format("[SampleRedisConfig] expireSeconds: %d, clusterNodes: %s, commandTimeout: %d, someMap: %s, someList: %s",expireSeconds, clusterNodes, commandTimeout, someMap, someList);}
} |
配置刷新类
@ConditionalOnProperty("redis.cache.enabled")
@Component
public class SpringBootApolloRefreshConfig {private static final Logger logger = LoggerFactory.getLogger(SpringBootApolloRefreshConfig.class);private final SampleRedisConfig sampleRedisConfig;private final RefreshScope refreshScope;public SpringBootApolloRefreshConfig(final SampleRedisConfig sampleRedisConfig,final RefreshScope refreshScope) {this.sampleRedisConfig = sampleRedisConfig;this.refreshScope = refreshScope;}@ApolloConfigChangeListener(value = {ConfigConsts.NAMESPACE_APPLICATION, "TEST1.apollo", "application.yaml"},interestedKeyPrefixes = {"redis.cache."})public void onChange(ConfigChangeEvent changeEvent) {logger.info("before refresh {}", sampleRedisConfig.toString());refreshScope.refresh("sampleRedisConfig");logger.info("after refresh {}", sampleRedisConfig.toString());}
} |
可以看到通过RefreshScope实现配置的刷新
这个类允许bean进行动态刷新(使用refresh/refreshAll方法)，再下一次访问时会新建bean实例
所有的生命周期方法都会应用到这个bean上，并支持序列化，本文主要对RefresScope的逻辑进行分析
RefreshScope浅析
Scope 作用域用于管理bean的生命周期和可见范围,比如默认的常见单例，原型，session级
GenericScope是springcloud包下的扩展作用域，为 Bean 提供一个通用的作用域管理机制，支持动态注册和销毁 Bean 实例，同时提供了对作用域生命周期的细粒度控制。
RefreshScope 定义，scope定义为refresh
@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Scope("refresh")
@Documented
public @interface RefreshScope {/*** @see Scope#proxyMode()*/ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;} |
初始化流程
spring会扫描对应的路径，构造bean定义—org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan
对于RefershScope标记的类，解析后ScopedProxyMode=TARGET_CLASS
org.springframework.context.annotation.AnnotationConfigUtils#applyScopedProxyMode
ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();if (scopedProxyMode.equals(ScopedProxyMode.NO)) {return definition;}boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass); |
会生成两个bean定义
一个为factoryBean的bean定义，会在refersh流程中进行初始化,名称为beanName
一个为实际配置类的bean定义，名称为scopedTarget.beanName
容器级扩展接口处理
容器启动流程里会调用 org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors ,这是一个容器级的扩展接口
会调用org.springframework.cloud.context.scope.GenericScope 里的后置处理方法
当对应bean的scope为refresh时，会更改其targetClass为LockedScopedProxyFactoryBean，用于创建 AOP代理对象，并为代理对象添加切面——执行相关方法加读写锁，防止与scope的refresh逻辑发生冲突
CreateBean
在初始化bean时，由于 上面设置targetClass为LockedScopedProxyFactoryBean，父类逻辑(org.springframework.aop.scope.ScopedProxyFactoryBean#setBeanFactory)生成scopedTarget.beanName代理对象并进行初始化操作
生成代理对象的同时也会对 refreshScope的 cache进行缓存初始化
ContextRefreshed
RefreshScope会监听contextRefreshed事件，做一个兜底初始化的动作，保证某个scope下的 bean都已初始化,纳入管理
//org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
Object scopedInstance = scope.get(beanName, () -> {beforePrototypeCreation(beanName);try {return createBean(beanName, mbd, args);}finally {afterPrototypeCreation(beanName);}});bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); |
scope get方法如下,其中org.springframework.cloud.context.scope.ScopeCache#put方法，相当于putIfAbsent方法，
BeanLifecycleWrapper value = this.cache.put(name,new BeanLifecycleWrapper(name, objectFactory));locks.putIfAbsent(name, new ReentrantReadWriteLock());try {return value.getBean();}catch (RuntimeException e) {this.errors.put(name, e);throw e;} |
其中wrapper的getBean方法如下，做bean的初始化
if (this.bean == null) {synchronized (this.name) {if (this.bean == null) {this.bean = this.objectFactory.getObject();}}}return this.bean; |
刷新处理
当调用org.springframework.cloud.context.scope.refresh.RefreshScope#refresh 方法时，会把该缓存清理掉
使用该对象时，由于持有的是代理对象，会走到 scope的处理逻辑，如果 scope中没有缓存该对象，同样会走一遍doGetBean的逻辑，重新加载 bean，从而拿到最新的bean
RefreshScope总结
RefreshScope的核心逻辑是通过自定义Scope去管理bean的生命周期，而factoryBean在初始化阶段生成该Scope对应的代理bean，当访问beanName对象时，走了代理逻辑，实际访问的是 beanName为scopedTarget.beanName的代理对象
在获取bean就走到scope逻辑，里面缓存了代理对象，当 refresh 时，会把代理对象删除，下次访问时会 createBean
优化使用方式
了解原理后，可以发现对每个配置类如果要实现更新，都需要写一个监听器并调用refresh方法，可以看到这个逻辑是公共的，并且@Configuration的prefix和apollo监听的前缀也是一致的，可以设计一个注解来减少这些重复工作
定义热更新注解
@ConfigurationProperties
@Component
@RefreshScope
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApolloRefreshConfig {/*** 配置类前缀* @return*/@AliasFor(annotation = ConfigurationProperties.class, value = "prefix")String prefix();/*** 默认监听的 namesapce* @return*/String[] namespaces() default {"application"};
} |
对于该注解标记的类，会注册一个内置的监听器
@Configuration(proxyBeanMethods = false)
public class ApolloConfigListenerRegister implements BeanDefinitionRegistryPostProcessor, EnvironmentAware {private static Environment environment;@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {for (String beanDefinitionName : registry.getBeanDefinitionNames()) {BeanDefinition beanDefinition = registry.getBeanDefinition(beanDefinitionName);if (beanDefinition instanceof AnnotatedBeanDefinition) {AnnotationMetadata metadata = ((AnnotatedBeanDefinition) beanDefinition).getMetadata();MergedAnnotation<ApolloRefreshConfig> mergedAnnotation = metadata.getAnnotations().get(ApolloRefreshConfig.class);if (mergedAnnotation.isPresent()) {AnnotationAttributes annotationAttributes = mergedAnnotation.asAnnotationAttributes();String listenName = beanDefinitionName + "-apollo-listener";RootBeanDefinition listenerBean = new RootBeanDefinition(DefaultConfigListener.class);listenerBean.setPropertyValues(new MutablePropertyValues().add("annotationAttributes", annotationAttributes).add("beanName", beanDefinitionName));registry.registerBeanDefinition(listenName, listenerBean);}}}}@Overridepublic void postProcessBeanFactory(@NotNull ConfigurableListableBeanFactory beanFactory) throws BeansException {//do nothing}@Overridepublic void setEnvironment(@NotNull Environment environment) {ApolloConfigListenerRegister.environment = environment;}@Setter@Slf4jstatic class DefaultConfigListener implements ConfigChangeListener {@Resourceprivate RefreshScope refreshScope;private String beanName;private AnnotationAttributes annotationAttributes;public void onChange(ConfigChangeEvent changeEvent) {LOGGER.info("bean:{},namespace:{} change", beanName, changeEvent.getNamespace());for (String changedKey : changeEvent.changedKeys()) {ConfigChange changedConfig = changeEvent.getChange(changedKey);LOGGER.info("key:{}, oldValue:{}, newValue:{}", changedConfig.getPropertyName(), changedConfig.getOldValue(), changedConfig.getNewValue());}refreshScope.refresh(beanName);}@PostConstructpublic void init() {String[] namespaces = annotationAttributes.getStringArray("namespaces");String[] annotatedInterestedKeyPrefixes = new String[]{annotationAttributes.getString("prefix")};Set<String> interestedKeyPrefixes = Sets.newHashSet(annotatedInterestedKeyPrefixes);for (String namespace : namespaces) {final String resolvedNamespace = environment.resolveRequiredPlaceholders(namespace);Config config = ConfigService.getConfig(resolvedNamespace);config.addChangeListener(this, null, interestedKeyPrefixes);}}}} |
当我们定义配置类时候，可以用这个注解实现配置类热更新
/*** #公共设置，本地文件预设* xxl-sharding-job.common.sleep-interval-mills=-1* xxl-sharding-job.common.batch-size=1000* xxl-sharding-job.common.max-retry=3* #特殊任务自定义* xxl-sharding-job.custom.yourTask.max-retry=3*/
@Data
@Slf4j
@ApolloRefreshConfig(prefix = "xxl-sharding-job")
public class XxlShardingConfig {private FlushConfig common;private Map<String, FlushConfig> custom;@Datapublic static class FlushConfig {//sleep-interval-millsprivate Integer sleepIntervalMills;//batch-sizeprivate Integer batchSize;//max-retryprivate Integer maxRetry;}public int getBatchSize(String xxlJobName) {FlushConfig flushConfig = getFlushConfig(xxlJobName);return Optional.ofNullable(flushConfig.batchSize).orElse(common.batchSize);}private FlushConfig getFlushConfig(String xxlJobName) {if(custom==null){return common;}return custom.getOrDefault(xxlJobName, common);}public int getMaxRetry(String xxlJobName) {FlushConfig flushConfig = getFlushConfig(xxlJobName);return Optional.ofNullable(flushConfig.maxRetry).orElse(common.maxRetry);}public int getSleepIntervalMills(String xxlJobName) {FlushConfig flushConfig = getFlushConfig(xxlJobName);return Optional.ofNullable(flushConfig.sleepIntervalMills).orElse(common.sleepIntervalMills);}
} |
实现效果
