SpringCloud @RefreshScope实现原理原来这么简单
环境：spring cloud context2.2.8.RELEASE + spring boot 2.3.9.RELEASE
1 RefreshScope源码
@Target({ ElementType.TYPE, ElementType.METHOD }) @Retention(RetentionPolicy.RUNTIME) @Scope("refresh") @Documented public @interface RefreshScope { /** * @see Scope#proxyMode() * @return proxy mode */ ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS; }
该注解上添加了@Scope("refresh")注解指明了作用域名为refresh。
2 注册RefreshScope
public class RefreshAutoConfiguration { /** * Name of the refresh scope name. */ public static final String REFRESH_SCOPE_NAME = "refresh"; // 注册RefreshScope @Bean @ConditionalOnMissingBean(RefreshScope.class) public static RefreshScope refreshScope() { return new RefreshScope(); } // 主要功能是刷新配置文件，发布事件（事件监听程序接收到事件后会重写配置相关的配置类） @Bean @ConditionalOnMissingBean public ContextRefresher contextRefresher(ConfigurableApplicationContext context, RefreshScope scope) { return new ContextRefresher(context, scope); } // 监听上下文刷新事件 @Bean public RefreshEventListener refreshEventListener(ContextRefresher contextRefresher) { return new RefreshEventListener(contextRefresher); } }
RefreshScope类
该类的核心方法都在父类中实现
public class RefreshScope extends GenericScope implements ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, Ordered { public boolean refresh(String name) { if (!name.startsWith(SCOPED_TARGET_PREFIX)) { name = SCOPED_TARGET_PREFIX + name; } if (super.destroy(name)) { this.context.publishEvent(new RefreshScopeRefreshedEvent(name)); return true; } return false; } @ManagedOperation(description = "Dispose of the current instance of all beans " + "in this scope and force a refresh on next method execution.") public void refreshAll() { super.destroy(); this.context.publishEvent(new RefreshScopeRefreshedEvent()); } }
该类继承自GenericScope，而GenericScope继承BeanFactoryPostProcessor。
public class GenericScope implements Scope, BeanFactoryPostProcessor, BeanDefinitionRegistryPostProcessor, DisposableBean { @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { this.beanFactory = beanFactory; beanFactory.registerScope(this.name, this); setSerializationId(beanFactory); } }
在这里会注册RefreshScope。注册的Scope将会在AbstractBeanFactory#doGetBean方法中调用，该方法中会先拿到当前BeanDefinition中定义的Scope，通过scopeName从Map集合中拿到Scope类，最后调用Scope的get方法获取实例对象；详细参见15例，查看get方法调用时机。
添加了@RefreshScope注解的Bean对象会执行RefreshScope#get方法
public class GenericScope implements Scope, BeanFactoryPostProcessor, BeanDefinitionRegistryPostProcessor, DisposableBean { private BeanLifecycleWrapperCache cache = new BeanLifecycleWrapperCache(new StandardScopeCache()); // 将要获取的Bean缓存上 public Object get(String name, ObjectFactory<?> objectFactory) { BeanLifecycleWrapper value = this.cache.put(name, new BeanLifecycleWrapper(name, objectFactory)); this.locks.putIfAbsent(name, new ReentrantReadWriteLock()); try { return value.getBean(); } catch (RuntimeException e) { this.errors.put(name, e); throw e; } } }
3 Refresh端点触发时机
触发机制基于事件驱动，发布EnvironmentChangeEvent事件。
当调用/actuator/refresh端点时，执行如下refresh：
@Endpoint(id = "refresh") public class RefreshEndpoint { private ContextRefresher contextRefresher; public RefreshEndpoint(ContextRefresher contextRefresher) { this.contextRefresher = contextRefresher; } @WriteOperation public Collection<String> refresh() { Set<String> keys = this.contextRefresher.refresh(); return keys; } }
调用ContextRefresher#refresh方法
public class ContextRefresher { public synchronized Set<String> refresh() { Set<String> keys = refreshEnvironment(); this.scope.refreshAll(); return keys; } public synchronized Set<String> refreshEnvironment() { // 配置信息修改之前的值 Map<String, Object> before = extract(this.context.getEnvironment().getPropertySources()); // 重新加载读取配置信息 addConfigFilesToEnvironment(); // 获取所有改变的配置 Set<String> keys = changes(before, extract(this.context.getEnvironment().getPropertySources())).keySet(); // 发布事件(处理事件中所有配置类@ConfigurationProperties) this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys)); return keys; } }
在refreshEnvironment方法中会发布一个EnvironmentChangeEvent事件；查看该事件的监听器
public class ConfigurationPropertiesRebinder implements ApplicationContextAware, ApplicationListener<EnvironmentChangeEvent> { private ConfigurationPropertiesBeans beans; private ApplicationContext applicationContext; private Map<String, Exception> errors = new ConcurrentHashMap<>(); public ConfigurationPropertiesRebinder(ConfigurationPropertiesBeans beans) { this.beans = beans; } @ManagedOperation public void rebind() { this.errors.clear(); // 遍历所有的配置类（带有@ConfigurationProperties注解的类） for (String name : this.beans.getBeanNames()) { // 对每一个bean进行重新绑定 rebind(name); } } @ManagedOperation public boolean rebind(String name) { if (!this.beans.getBeanNames().contains(name)) { return false; } if (this.applicationContext != null) { Object bean = this.applicationContext.getBean(name); if (AopUtils.isAopProxy(bean)) { bean = ProxyUtils.getTargetObject(bean); } if (bean != null) { if (getNeverRefreshable().contains(bean.getClass().getName())) { return false; // ignore } // 销毁当前的bean this.applicationContext.getAutowireCapableBeanFactory().destroyBean(bean); // 初始化Bean this.applicationContext.getAutowireCapableBeanFactory().initializeBean(bean, name); return true; } } return false; } @ManagedAttribute public Set<String> getBeanNames() { return new HashSet<>(this.beans.getBeanNames()); } @Override public void onApplicationEvent(EnvironmentChangeEvent event) { if (this.applicationContext.equals(event.getSource()) || event.getKeys().equals(event.getSource())) { rebind(); } } }
当收到EnvironmentChangeEvent事件后执行rebind方法。在该类中的beans是通过构造函数传过来的，接下来先查看这个对象是如何被构造的
public class ConfigurationPropertiesRebinderAutoConfiguration implements ApplicationContextAware, SmartInitializingSingleton { @Bean @ConditionalOnMissingBean(search = SearchStrategy.CURRENT) public static ConfigurationPropertiesBeans configurationPropertiesBeans() { return new ConfigurationPropertiesBeans(); } @Bean @ConditionalOnMissingBean(search = SearchStrategy.CURRENT) public ConfigurationPropertiesRebinder configurationPropertiesRebinder(ConfigurationPropertiesBeans beans) { ConfigurationPropertiesRebinder rebinder = new ConfigurationPropertiesRebinder(beans); return rebinder; } }
在这个自动配置类中创建了
ConfigurationPropertiesRebinder并且将ConfigurationPropertiesBeans 注入。ConfigurationPropertiesBeans是个BeanPostProcessor处理器
@Component public class ConfigurationPropertiesBeans implements BeanPostProcessor, ApplicationContextAware { // 添加有@ConfigurationProperties注解的bean都将保存在该集合中 private Map<String, ConfigurationPropertiesBean> beans = new HashMap<>(); private ApplicationContext applicationContext; private ConfigurableListableBeanFactory beanFactory; private String refreshScope; private boolean refreshScopeInitialized; private ConfigurationPropertiesBeans parent; @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (isRefreshScoped(beanName)) { return bean; } ConfigurationPropertiesBean propertiesBean = ConfigurationPropertiesBean .get(this.applicationContext, bean, beanName); if (propertiesBean != null) { this.beans.put(beanName, propertiesBean); } return bean; } private boolean isRefreshScoped(String beanName) { if (this.refreshScope == null && !this.refreshScopeInitialized) { this.refreshScopeInitialized = true; for (String scope : this.beanFactory.getRegisteredScopeNames()) { if (this.beanFactory.getRegisteredScope( scope) instanceof org.springframework.cloud.context.scope.refresh.RefreshScope) { this.refreshScope = scope; break; } } } if (beanName == null || this.refreshScope == null) { return false; } return this.beanFactory.containsBeanDefinition(beanName) && this.refreshScope.equals(this.beanFactory.getBeanDefinition(beanName).getScope()); } public Set<String> getBeanNames() { return new HashSet<String>(this.beans.keySet()); } }
该BeanPostProcessor的
postProcessBeforeInitialization方法执行在初始化bean的时候执行在这里就会判断当前的Bean是否是RefreshScope Bean。
在isRefreshScoped方法中遍历注册的所有Scope并且判断是否是有RefreshScope，先从注册的所有Scope中查找RefreshScope，如果没有返回false，如果是则返回true。如果isRefreshScoped方法返回的false就判断当前Bean是否有@ConfigurationProperties注解如果有会被包装成
ConfigurationPropertiesBean存入当前的beans集合中（当有refresh发生时会重新绑定这些bean）。接下来继续进入到上面的ConfigurationPropertiesRebinder#rebind方法中。
rebind方法中会对所有带有@ConfigurationProperties注解的类进行刷新，rebind方法中会对bean进行销毁和初始化。
this.applicationContext.getAutowireCapableBeanFactory().destroyBean(bean);
this.applicationContext.getAutowireCapableBeanFactory().initializeBean(bean, name);4 RefreshScope刷新处理
当刷新refresh被调用后会执行RefreshScope#refreshAll方法
public class ContextRefresher { public synchronized Set<String> refresh() { Set<String> keys = refreshEnvironment(); this.scope.refreshAll(); return keys; } }
RefreshScope#refreshAll方法
public void refreshAll() { // 调用RefreshScope父类的destroy方法 super.destroy(); // 发布RefreshScopeRefreshedEvent事件，我们可以写个监听程序监听该事件 this.context.publishEvent(new RefreshScopeRefreshedEvent()); }
父类GenriceScope#destroy方法
public class GenericScope implements Scope, BeanFactoryPostProcessor, BeanDefinitionRegistryPostProcessor, DisposableBean {
@Override
public void destroy() {
List<Throwable> errors = new ArrayList<Throwable>();
Collection<BeanLifecycleWrapper> wrappers = this.cache.clear();
for (BeanLifecycleWrapper wrapper : wrappers) {
try {
Lock lock = this.locks.get(wrapper.getName()).writeLock();
lock.lock();
try {
wrapper.destroy();
} finally {
lock.unlock();
}
} catch (RuntimeException e) {
errors.add(e);
}
}
if (!errors.isEmpty()) {
throw wrapIfNecessary(errors.get(0));
}
this.errors.clear();
}
}
wrapper#destroy方法
private static class BeanLifecycleWrapper { private final String name; private final ObjectFactory<?> objectFactory; private Object bean; private Runnable callback; BeanLifecycleWrapper(String name, ObjectFactory<?> objectFactory) { this.name = name; this.objectFactory = objectFactory; } public Object getBean() { if (this.bean == null) { synchronized (this.name) { if (this.bean == null) { this.bean = this.objectFactory.getObject(); } } } return this.bean; } // 该方法就是清空上次创建的对象信息 public void destroy() { if (this.callback == null) { return; } synchronized (this.name) { Runnable callback = this.callback; if (callback != null) { callback.run(); } this.callback = null; this.bean = null; } } }
当前清空了缓存对象后，下次再进入注入的时候会再次调用ObjectFacotry#getObject方法创建新的对象。
总结：当触发了refresh后，所有的带有@ConfigurationProperties注解的Bean都会自动的刷新并不需要@RefreshScope注解。而有@RefreshScope注解的一般在应用在非配置类上，有成员属性使用@Value注解的，如下：
@RestController @RequestMapping("/refreshBeanProp") @RefreshScope public class RefreshScopeBeanPropController { @Value("${custom}") private String custom ; @GetMapping("/get") public String get() { return custom ; } }
在此种情况下，调用/actuator/refresh 可使custom动态刷新，在ContextRefresher#refresh中将缓存的Bean清空了后重新生成Bean。
完毕！！！
给个关注+转发呗谢谢
众：Springboot实战案例锦集
