Apollo 热更新配置

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

文章目录

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

前言

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

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

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

诞生背景：

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

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

一、Apollo热更新配置

1. @Value的方式

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

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

2. @RefreshScope

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

  1. @Configuration
  2. @EnableConfigurationProperties(ConfigProperties.class)
  3. @ConfigurationProperties(prefix = "config")
  4. @Setter
  5. @Getter
  6. @RefreshScope
  7. public class ConfigProperties {
  9.     private int configValue;
  10. }

3. 监听apollo配置更新事件

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

  1. @Slf4j
  2. @Component
  3. public class SpringBootApolloRefreshConfig {
  6.     private final ConfigProperties configProperties;
  7.     private final RefreshScope refreshScope;
  9.     public SpringBootApolloRefreshConfig(ConfigProperties configProperties, RefreshScope refreshScope) {
  11.         this. configProperties = configProperties;
  12.         this.refreshScope = refreshScope;
  13.     }
  15.     @ApolloConfigChangeListener(value = {
  16.     "namespace"}, interestedKeyPrefixes = {
  17.     "key_prefix"}, interestedKeys = {
  18.     "key_prefix.key"})
  19.     public void onChange(ConfigChangeEvent changeEvent) {
  21.         log.info("before refresh {}", configProperties.toString());
  22.         refreshScope.refresh("configProperties");
  23.         log.info("after refresh {}", configProperties.toString());
  24.     }
  25. }
  • 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,

    1.   ApplicationListener<ContextRefreshedEvent>, Ordered {
    3. ...
    4. @ManagedOperation(description = "Dispose of the current instance of bean name "
    5.       + "provided and force a refresh on next method execution.")
    6. public boolean refresh(String name) {
    8.    if (!name.startsWith(SCOPED_TARGET_PREFIX)) {
    10.       // User wants to refresh the bean with this name but that isn't the one in the
    11.       // cache...
    12.       name = SCOPED_TARGET_PREFIX + name;
    13.    }
    14.    // Ensure lifecycle is finished if bean was disposable
    15.    if (super.destroy(name)) {
    17.       // 发布配置刷新事件
    18.       this.context.publishEvent(new RefreshScopeRefreshedEvent(name));
    19.       return true;
    20.    }
    21.    return false;
    22. }

    }

2. RefreshEndpoint

  1. @Endpoint(id = "refresh")
  2. public class RefreshEndpoint {
  5.    private ContextRefresher contextRefresher;
  7.    public RefreshEndpoint(ContextRefresher contextRefresher) {
  9.       this.contextRefresher = contextRefresher;
  10.    }
  12.    @WriteOperation
  13.    public Collection<String> refresh() {
  15.       // 触发刷新环境变量
  16.       Set<String> keys = this.contextRefresher.refresh();
  17.       return keys;
  18.    }
  20. }

3. ContextRefresher

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

  • #refresh 触发入口

    public class ContextRefresher {

  1.    ...
  3.    private ConfigurableApplicationContext context;
  5.    private RefreshScope scope;
  7.    public ContextRefresher(ConfigurableApplicationContext context, RefreshScope scope) {
  9.       this.context = context;
  10.       this.scope = scope;
  11.    }
  13.    protected ConfigurableApplicationContext getContext() {
  15.       return this.context;
  16.    }
  18.    protected RefreshScope getScope() {
  20.       return this.scope;
  21.    }
  23.    // 刷新环境变量
  24.    public synchronized Set<String> refresh() {
  26.       Set<String> keys = refreshEnvironment();
  27.       this.scope.refreshAll();
  28.       return keys;
  29.    }
  31.    public synchronized Set<String> refreshEnvironment() {
  33.       // 获取旧的环境变量配置
  34.       Map<String, Object> before = extract(
  35.             this.context.getEnvironment().getPropertySources());
  36.       // 更新最新环境变量
  37.       addConfigFilesToEnvironment();
  38.       // 获取变更的变量key
  39.       Set<String> keys = changes(before,
  40.             extract(this.context.getEnvironment().getPropertySources())).keySet();
  41.       // 发布环境变量变更事件
  42.       this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys));
  43.       return keys;
  44.    }
  45. }

4. 配置刷新

  • #onApplicationEvent 方法监听环境变更事件

  • #rebind 方法遍历所有加 RefreshScope 注解的配置类，刷新配置

    @Component
    @ManagedResource
    public class ConfigurationPropertiesRebinder

    1.   implements ApplicationContextAware, ApplicationListener<EnvironmentChangeEvent> {
  1.    private ConfigurationPropertiesBeans beans;
  3.    private ApplicationContext applicationContext;
  5.    private Map<String, Exception> errors = new ConcurrentHashMap<>();
  7.    /**
  8.     * beans中包含所有加上RefreshScope注解的配置类实例
  9.     */
  10.    public ConfigurationPropertiesRebinder(ConfigurationPropertiesBeans beans) {
  12.       this.beans = beans;
  13.    }
  15.    ...
  17.    /**
  18.     * 遍历每一个加了RefreshScope注解的配置类，刷新配置
  19.     */
  20.    @ManagedOperation
  21.    public void rebind() {
  23.       this.errors.clear();
  24.       for (String name : this.beans.getBeanNames()) {
  26.          rebind(name);
  27.       }
  28.    }
  30.    @ManagedOperation
  31.    public boolean rebind(String name) {
  33.       if (!this.beans.getBeanNames().contains(name)) {
  35.          return false;
  36.       }
  37.       if (this.applicationContext != null) {
  39.          try {
  41.             Object bean = this.applicationContext.getBean(name);
  42.             if (AopUtils.isAopProxy(bean)) {
  44.                bean = ProxyUtils.getTargetObject(bean);
  45.             }
  46.             if (bean != null) {
  48.                // TODO: determine a more general approach to fix this.
  49.                // see https://github.com/spring-cloud/spring-cloud-commons/issues/571
  50.                if (getNeverRefreshable().contains(bean.getClass().getName())) {
  52.                   return false; // ignore
  53.                }
  54.                // 销毁旧的配置类实例
  55.                this.applicationContext.getAutowireCapableBeanFactory()
  56.                      .destroyBean(bean);
  57.                // 根据新的环境变量，重新初始化配置类
  58.                this.applicationContext.getAutowireCapableBeanFactory()
  59.                      .initializeBean(bean, name);
  60.                return true;
  61.             }
  62.          }
  63.          catch (RuntimeException e) {
  65.             this.errors.put(name, e);
  66.             throw e;
  67.          }
  68.          catch (Exception e) {
  70.             this.errors.put(name, e);
  71.             throw new IllegalStateException("Cannot rebind to " + name, e);
  72.          }
  73.       }
  74.       return false;
  75.    }
  77.    @ManagedAttribute
  78.    public Set<String> getNeverRefreshable() {
  80.       String neverRefresh = this.applicationContext.getEnvironment().getProperty(
  81.             "spring.cloud.refresh.never-refreshable",
  82.             "com.zaxxer.hikari.HikariDataSource");
  83.       return StringUtils.commaDelimitedListToSet(neverRefresh);
  84.    }
  86.    @ManagedAttribute
  87.    public Set<String> getBeanNames() {
  89.       return new HashSet<>(this.beans.getBeanNames());
  90.    }
  92.    /**
  93.     * 监听环境变量变更事件，重新绑定刷新配置
  94.     */
  95.    @Override
  96.    public void onApplicationEvent(EnvironmentChangeEvent event) {
  98.       if (this.applicationContext.equals(event.getSource())
  99.             // Backwards compatible
  100.             || event.getKeys().equals(event.getSource())) {
  102.          rebind();
  103.       }
  104.    }
  106. }

5. 配置类注册

  • 该类实现了BeanPostProcessor接口，在Bean初始化之前会进入postProcessBeforeInitialization方法

  • 加上RefreshScope注解的配置类会注册进beans map中，用于刷新配置

    @Component
    public class ConfigurationPropertiesBeans

    1.   implements BeanPostProcessor, ApplicationContextAware {
  1.    private Map<String, ConfigurationPropertiesBean> beans = new HashMap<>();
  3.    private ApplicationContext applicationContext;
  5.    private ConfigurableListableBeanFactory beanFactory;
  7.    private String refreshScope;
  9.    private boolean refreshScopeInitialized;
  11.    private ConfigurationPropertiesBeans parent;
  13.    ...
  15.    /**
  16.     * 在Bean初始化之前，会调用这里，用于注册配置类对象
  17.     */
  18.    @Override
  19.    public Object postProcessBeforeInitialization(Object bean, String beanName)
  20.          throws BeansException {
  22.       // 判断Bean是否加上了RefreshScope注解
  23.       if (isRefreshScoped(beanName)) {
  25.          return bean;
  26.       }
  27.       // 判断Bean是否加上了ConfigurationProperties注解
  28.       ConfigurationPropertiesBean propertiesBean = ConfigurationPropertiesBean
  29.             .get(this.applicationContext, bean, beanName);
  30.       // 将加上RefreshScope注解的配置类对象放在map中，用于刷新配置
  31.       if (propertiesBean != null) {
  33.          this.beans.put(beanName, propertiesBean);
  34.       }
  35.       return bean;
  36.    }
  38.    private boolean isRefreshScoped(String beanName) {
  40.       if (this.refreshScope == null && !this.refreshScopeInitialized) {
  42.          this.refreshScopeInitialized = true;
  43.          for (String scope : this.beanFactory.getRegisteredScopeNames()) {
  45.             if (this.beanFactory.getRegisteredScope(
  46.                   scope) instanceof org.springframework.cloud.context.scope.refresh.RefreshScope) {
  48.                this.refreshScope = scope;
  49.                break;
  50.             }
  51.          }
  52.       }
  53.       if (beanName == null || this.refreshScope == null) {
  55.          return false;
  56.       }
  57.       return this.beanFactory.containsBeanDefinition(beanName) && this.refreshScope
  58.             .equals(this.beanFactory.getBeanDefinition(beanName).getScope());
  59.    }
  61.    @Override
  62.    public Object postProcessAfterInitialization(Object bean, String beanName)
  63.          throws BeansException {
  65.       return bean;
  66.    }
  68.    public Set<String> getBeanNames() {
  70.       return new HashSet<String>(this.beans.keySet());
  71.    }
  73. }

发表评论

表情：
评论列表 （有 0 条评论，207人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Apollo配置中心使用及热更新

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

    痛定思痛。痛定思痛。/ 0 赞/ 404 阅读

    相关 热更新

    虽然有插件开发，但热更新少不了。 ![Center][] 当我们需要更新插件的时候使用的是插件开发，当我们需要更新宿主程序就需要使用热更新 热更新使用框架bsdif

    柔情只为你懂柔情只为你懂/ 0 赞/ 593 阅读