Apollo 热更新配置

矫情吗；* 2024-04-06 12:04 10阅读 0赞

#### 文章目录 ####

*  前言
 *  一、Apollo热更新配置
 *   *  1. @Value的方式
     *  2. @RefreshScope
     *  3. 监听apollo配置更新事件
 *  二、源码解析
 *   *  1. RefreshScope\#refresh
     *  2. RefreshEndpoint
     *  3. ContextRefresher
     *  4. 配置刷新
     *  5. 配置类注册

--------------------

## 前言 ##

Apollo（阿波罗）是携程框架部门研发的开源配置管理中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性。

Apollo支持4个维度管理Key-Value格式的配置：

*  application (应用)
 *  environment (环境)
 *  cluster (集群)
 *  namespace (命名空间) 同时，Apollo基于开源模式开发，开源地址：[https://github.com/ctripcorp/apollo][https_github.com_ctripcorp_apollo]

诞生背景：

随着程序功能的日益复杂，程序的配置日益增多：各种功能的开关、参数的配置、服务器的地址……
    
    对程序配置的期望值也越来越高：配置修改后实时生效，灰度发布，分环境、分集群管理配置，完善的权限、审核机制……
    
    在这样的大环境下，传统的通过配置文件、数据库等方式已经越来越无法满足开发人员对配置管理的需求。
    
    Apollo配置中心应运而生！

简单来说，Apollo 是一个配置中心，可以非常方便管理公司所有项目配置，并支持热更新。本文主要讲解 Apollo 在 Spring 环境下的热更新操作。

--------------------

## 一、Apollo热更新配置 ##

### 1. @Value的方式 ###

这种方式不需要改任何代码，支持热更新

@Value(value = "${config_key}")
    private int configValue;

### 2. @RefreshScope ###

定义配置类，配置类中加上 `@RefreshScope` 注解，加上改注解的 Bean 能在运行时被`实时刷新`，即销毁然后重新创建，所有引用到该 Bean 的地方在下次访问时都会指向新的对象

@Configuration
    @EnableConfigurationProperties(ConfigProperties.class)
    @ConfigurationProperties(prefix = "config")
    @Setter
    @Getter
    @RefreshScope
    public class ConfigProperties {
        
        private int configValue;
    }

### 3. 监听apollo配置更新事件 ###

在方法上加 `@ApolloConfigChangeListener` 注解，监听 Apollo 配置变更事件。

@Slf4j
    @Component
    public class SpringBootApolloRefreshConfig {
        
    
        private final ConfigProperties configProperties;
        private final RefreshScope refreshScope;
    
        public SpringBootApolloRefreshConfig(ConfigProperties configProperties, RefreshScope refreshScope) {
        
            this. configProperties = configProperties;
            this.refreshScope = refreshScope;
        }
    
        @ApolloConfigChangeListener(value = {
        "namespace"}, interestedKeyPrefixes = {
        "key_prefix"}, interestedKeys = {
        "key_prefix.key"})
        public void onChange(ConfigChangeEvent changeEvent) {
        
            log.info("before refresh {}", configProperties.toString());
            refreshScope.refresh("configProperties");
            log.info("after refresh {}", configProperties.toString());
        }
    }

*  ApolloConfigChangeListener 注解，value 中的值为感兴趣的 namespace，interestedKeyPrefixes 中的值为感兴趣的 key 前缀（不指定表示全部），interestedKeys 表示具体对哪些 key 感兴趣（不指定表示全部）。
 *  当检测到 Apollo 配置变更时，`refreshScope.refresh("beanName")` 刷新配置。

## 二、源码解析 ##

### 1. RefreshScope\#refresh ###

方法如下：

*  调父类 GenericScope\#destroy 清空缓存（对应的 BeanLifecycleWrapper 缓存）
 *  发布 RefreshScopeRefreshedEvent 事件，该事件会最终会触发/refresh actuator endpoint

@ManagedResource
    public class RefreshScope extends GenericScope implements ApplicationContextAware,
          ApplicationListener<ContextRefreshedEvent>, Ordered {
        
        ...
        @ManagedOperation(description = "Dispose of the current instance of bean name "
              + "provided and force a refresh on next method execution.")
        public boolean refresh(String name) {
        
           if (!name.startsWith(SCOPED_TARGET_PREFIX)) {
        
              // User wants to refresh the bean with this name but that isn't the one in the
              // cache...
              name = SCOPED_TARGET_PREFIX + name;
           }
           // Ensure lifecycle is finished if bean was disposable
           if (super.destroy(name)) {
        
              // 发布配置刷新事件
              this.context.publishEvent(new RefreshScopeRefreshedEvent(name));
              return true;
           }
           return false;
        }
    }

### 2. RefreshEndpoint ###

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

### 3. ContextRefresher ###

刷新环境变量&发布变更事件

*  \#refresh 触发入口

public class ContextRefresher {
        
    
       ...
       
       private ConfigurableApplicationContext context;
    
       private RefreshScope scope;
    
       public ContextRefresher(ConfigurableApplicationContext context, RefreshScope scope) {
        
          this.context = context;
          this.scope = scope;
       }
    
       protected ConfigurableApplicationContext getContext() {
        
          return this.context;
       }
    
       protected RefreshScope getScope() {
        
          return this.scope;
       }
    
       // 刷新环境变量
       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();
          // 获取变更的变量key
          Set<String> keys = changes(before,
                extract(this.context.getEnvironment().getPropertySources())).keySet();
          // 发布环境变量变更事件
          this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys));
          return keys;
       }
    }

### 4. 配置刷新 ###

*  \#onApplicationEvent 方法监听环境变更事件
 *  \#rebind 方法遍历所有加 RefreshScope 注解的配置类，刷新配置

@Component
    @ManagedResource
    public class ConfigurationPropertiesRebinder
          implements ApplicationContextAware, ApplicationListener<EnvironmentChangeEvent> {
        
    
       private ConfigurationPropertiesBeans beans;
    
       private ApplicationContext applicationContext;
    
       private Map<String, Exception> errors = new ConcurrentHashMap<>();
    
       /**
        * beans中包含所有加上RefreshScope注解的配置类实例
        */
       public ConfigurationPropertiesRebinder(ConfigurationPropertiesBeans beans) {
        
          this.beans = beans;
       }
    
       ...
    
       /**
        * 遍历每一个加了RefreshScope注解的配置类，刷新配置
        */
       @ManagedOperation
       public void rebind() {
        
          this.errors.clear();
          for (String name : this.beans.getBeanNames()) {
        
             rebind(name);
          }
       }
    
       @ManagedOperation
       public boolean rebind(String name) {
        
          if (!this.beans.getBeanNames().contains(name)) {
        
             return false;
          }
          if (this.applicationContext != null) {
        
             try {
        
                Object bean = this.applicationContext.getBean(name);
                if (AopUtils.isAopProxy(bean)) {
        
                   bean = ProxyUtils.getTargetObject(bean);
                }
                if (bean != null) {
        
                   // TODO: determine a more general approach to fix this.
                   // see https://github.com/spring-cloud/spring-cloud-commons/issues/571
                   if (getNeverRefreshable().contains(bean.getClass().getName())) {
        
                      return false; // ignore
                   }
                   // 销毁旧的配置类实例
                   this.applicationContext.getAutowireCapableBeanFactory()
                         .destroyBean(bean);
                   // 根据新的环境变量，重新初始化配置类
                   this.applicationContext.getAutowireCapableBeanFactory()
                         .initializeBean(bean, name);
                   return true;
                }
             }
             catch (RuntimeException e) {
        
                this.errors.put(name, e);
                throw e;
             }
             catch (Exception e) {
        
                this.errors.put(name, e);
                throw new IllegalStateException("Cannot rebind to " + name, e);
             }
          }
          return false;
       }
    
       @ManagedAttribute
       public Set<String> getNeverRefreshable() {
        
          String neverRefresh = this.applicationContext.getEnvironment().getProperty(
                "spring.cloud.refresh.never-refreshable",
                "com.zaxxer.hikari.HikariDataSource");
          return StringUtils.commaDelimitedListToSet(neverRefresh);
       }
    
       @ManagedAttribute
       public Set<String> getBeanNames() {
        
          return new HashSet<>(this.beans.getBeanNames());
       }
    
       /**
        * 监听环境变量变更事件，重新绑定刷新配置
        */
       @Override
       public void onApplicationEvent(EnvironmentChangeEvent event) {
        
          if (this.applicationContext.equals(event.getSource())
                // Backwards compatible
                || event.getKeys().equals(event.getSource())) {
        
             rebind();
          }
       }
    
    }

### 5. 配置类注册 ###

*  该类实现了BeanPostProcessor接口，在Bean初始化之前会进入postProcessBeforeInitialization方法
 *  加上RefreshScope注解的配置类会注册进beans map中，用于刷新配置

@Component
    public class ConfigurationPropertiesBeans
          implements BeanPostProcessor, ApplicationContextAware {
        
    
       private Map<String, ConfigurationPropertiesBean> beans = new HashMap<>();
    
       private ApplicationContext applicationContext;
    
       private ConfigurableListableBeanFactory beanFactory;
    
       private String refreshScope;
    
       private boolean refreshScopeInitialized;
    
       private ConfigurationPropertiesBeans parent;
    
       ...
    
       /**
        * 在Bean初始化之前，会调用这里，用于注册配置类对象
        */
       @Override
       public Object postProcessBeforeInitialization(Object bean, String beanName)
             throws BeansException {
        
          // 判断Bean是否加上了RefreshScope注解
          if (isRefreshScoped(beanName)) {
        
             return bean;
          }
          // 判断Bean是否加上了ConfigurationProperties注解
          ConfigurationPropertiesBean propertiesBean = ConfigurationPropertiesBean
                .get(this.applicationContext, bean, beanName);
          // 将加上RefreshScope注解的配置类对象放在map中，用于刷新配置
          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());
       }
    
       @Override
       public Object postProcessAfterInitialization(Object bean, String beanName)
             throws BeansException {
        
          return bean;
       }
    
       public Set<String> getBeanNames() {
        
          return new HashSet<String>(this.beans.keySet());
       }
    
    }

[https_github.com_ctripcorp_apollo]: https://github.com/ctripcorp/apollo