Spring Cloud Nacos 配置动态刷新

上一篇讲配置变更时会发布RefreshEvent事件，监听这个事件可以实现配置刷新。具体看一下。

1、监听RefreshEvent

//org.springframework.cloud.endpoint.event.RefreshEventListener#onApplicationEvent
public void onApplicationEvent(ApplicationEvent event) {
    if (event instanceof ApplicationReadyEvent) {
        handle((ApplicationReadyEvent) event);
    }
    else if (event instanceof RefreshEvent) {
        handle((RefreshEvent) event);
    }
}

//org.springframework.cloud.endpoint.event.RefreshEventListener#handle
public void handle(RefreshEvent event) {
   if (this.ready.get()) { // don't handle events before app is ready
      log.debug("Event received " + event.getEventDesc());
      //调用refresh
       Set<String> keys = this.refresh.refresh();
      log.info("Refresh keys changed: " + keys);
   }
}

//org.springframework.cloud.context.refresh.ContextRefresher#refresh
public synchronized Set<String> refresh() {
   Set<String> keys = refreshEnvironment();
   this.scope.refreshAll();
   return keys;
}

1.1、发布EnvironmentChangeEvent

//org.springframework.cloud.context.refresh.ContextRefresher#refreshEnvironment
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();
   this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys));
   return keys;
}

1.2、销毁beans

//org.springframework.cloud.context.scope.refresh.RefreshScope#refreshAll
public void refreshAll() {
    //销毁bean
   super.destroy();
    //发布事件，没什么实现
   this.context.publishEvent(new RefreshScopeRefreshedEvent());
}

循环销毁bean

//org.springframework.cloud.context.scope.GenericScope#destroy()
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();
}

2、监听EnvironmentChangeEvent

//org.springframework.cloud.context.properties.ConfigurationPropertiesRebinder#onApplicationEvent
public void onApplicationEvent(EnvironmentChangeEvent event) {
   if (this.applicationContext.equals(event.getSource())
         // Backwards compatible
         || event.getKeys().equals(event.getSource())) {
      rebind();
   }
}

重新绑定

//org.springframework.cloud.context.properties.ConfigurationPropertiesRebinder#rebind()
public void rebind() {
   this.errors.clear();
   for (String name : this.beans.getBeanNames()) {
      rebind(name);
   }
}

循环bean重新绑定

public boolean rebind(String name) {
   if (!this.beans.getBeanNames().contains(name)) {
      return false;
   }
   if (this.applicationContext != null) {
      try {
          //获取bean
         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
            }
             //销毁bean
            this.applicationContext.getAutowireCapableBeanFactory()
                  .destroyBean(bean);
             //初始化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;
}

通过将原来的bean销毁并且重新创建一个全新的bean来实现配置的刷新。这样做有个问题，和原来的bean绑定的bean，可能就不能用了。还有一些bean重的缓存，比如说数据库连接池，也被销毁了。