怎么进行SpringCloud配置刷新机制的简单分析

/**
 * @param environment The current Environment.
 * @return A PropertySource, or null if there is none.
 * @throws IllegalStateException if there is a fail-fast condition.
 */
PropertySource<?> locate(Environment environment);

/**
 * Nacos Group.
 */
private final String group;

/**
 * Nacos dataID.
 */
private final String dataId;

/**
 * timestamp the property get.
 */
private final Date timestamp;

/**
 * Whether to support dynamic refresh for this Property Source.
 */
private final boolean isRefreshable;

@Override
public PropertySource<?> locate(Environment env) {
 nacosConfigProperties.setEnvironment(env);
 // 获取nacos配置的服务类,http协议,访问nacos的api接口获得配置
 ConfigService configService = nacosConfigManager.getConfigService();

 if (null == configService) {
  log.warn("no instance of config service found, can't load config from nacos");
  return null;
 }
 long timeout = nacosConfigProperties.getTimeout();
 // 构建一个builder
 nacosPropertySourceBuilder = new NacosPropertySourceBuilder(configService,
   timeout);
 String name = nacosConfigProperties.getName();

 String dataIdPrefix = nacosConfigProperties.getPrefix();
 if (StringUtils.isEmpty(dataIdPrefix)) {
  dataIdPrefix = name;
 }

 if (StringUtils.isEmpty(dataIdPrefix)) {
  dataIdPrefix = env.getProperty("spring.application.name");
 }
    // 构建一个复合数据源
 CompositePropertySource composite = new CompositePropertySource(
   NACOS_PROPERTY_SOURCE_NAME);
    // 加载共享的配置
 loadSharedConfiguration(composite);
 // 加载扩展配置
 loadExtConfiguration(composite);
 // 加载应用配置,应用配置的优先级是最高,所以这里放在最后面来做,是因为添加配置的地方都是addFirst,所以最先的反而优先级最后
 loadApplicationConfiguration(composite, dataIdPrefix, nacosConfigProperties, env);

 return composite;
}

executor = Executors.newScheduledThreadPool(1, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r);
                t.setName("com.alibaba.nacos.client.Worker." + agent.getName());
                t.setDaemon(true);
                return t;
            }
        });

executorService = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors(), new ThreadFactory() {
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setName("com.alibaba.nacos.client.Worker.longPolling." + agent.getName());
        t.setDaemon(true);
        return t;
    }
});

executor.scheduleWithFixedDelay(new Runnable() {
    @Override
    public void run() {
        try {
            checkConfigInfo();
        } catch (Throwable e) {
            LOGGER.error("[" + agent.getName() + "] [sub-check] rotate check error", e);
        }
    }
}, 1L, 10L, TimeUnit.MILLISECONDS);

// com.alibaba.cloud.nacos.client.NacosPropertySourceBuilder#loadNacosData
private Map<String, Object> loadNacosData(String dataId, String group,
   String fileExtension) {
 String data = null;
 try {
  data = configService.getConfig(dataId, group, timeout);
  if (StringUtils.isEmpty(data)) {
   log.warn(
     "Ignore the empty nacos configuration and get it based on dataId[{}] & group[{}]",
     dataId, group);
   return EMPTY_MAP;
  }
  if (log.isDebugEnabled()) {
   log.debug(String.format(
     "Loading nacos data, dataId: '%s', group: '%s', data: %s", dataId,
     group, data));
  }
  Map<String, Object> dataMap = NacosDataParserHandler.getInstance()
    .parseNacosData(data, fileExtension);
  return dataMap == null ? EMPTY_MAP : dataMap;
 }
 catch (NacosException e) {
  log.error("get data from Nacos error,dataId:{}, ", dataId, e);
 }
 catch (Exception e) {
  log.error("parse data from Nacos error,dataId:{},data:{},", dataId, data, e);
 }
 return EMPTY_MAP;
}

org.springframework.cloud.bootstrap.BootstrapConfiguration=\
com.alibaba.cloud.nacos.NacosConfigBootstrapConfiguration

@Bean
public NacosConfigProperties nacosConfigProperties(ApplicationContext context) {
 if (context.getParent() != null
   && BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
     context.getParent(), NacosConfigProperties.class).length > 0) {
  return BeanFactoryUtils.beanOfTypeIncludingAncestors(context.getParent(),
    NacosConfigProperties.class);
 }
 return new NacosConfigProperties();
}

// 外层方法
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();
 this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys));
 return keys;
}

@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);
   // 获取source对象
   if (AopUtils.isAopProxy(bean)) {
    bean = ProxyUtils.getTargetObject(bean);
   }
   if (bean != null) {
    // 重新触发销毁和初始化的周期方法
    this.applicationContext.getAutowireCapableBeanFactory()
      .destroyBean(bean);
       // 因为触发初始化生命周期，就可以触发
       // org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor#postProcessBeforeInitialization
    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;
}

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
  throws BeansException {
 if (isRefreshScoped(beanName)) {
  return bean;
 }
 ConfigurationProperties annotation = AnnotationUtils
   .findAnnotation(bean.getClass(), ConfigurationProperties.class);
 if (annotation != null) {
  this.beans.put(beanName, bean);
 }
 else if (this.metaData != null) {
  annotation = this.metaData.findFactoryAnnotation(beanName,
    ConfigurationProperties.class);
  if (annotation != null) {
   this.beans.put(beanName, bean);
  }
 }
 return bean;
}

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

private static class BeanLifecycleWrapper {
    // bean的名字
 private final String name;
    // 获取bean
 private final ObjectFactory<?> objectFactory;
    // 真正的实例
 private Object bean;
    // 销毁函数
 private Runnable callback;
} 

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

String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
 Object scopedInstance = scope.get(beanName, () -> {
  beforePrototypeCreation(beanName);
  try {
   return createBean(beanName, mbd, args);
  }
  finally {
   afterPrototypeCreation(beanName);
  }
 });
 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}

public Object getBean() {
 if (this.bean == null) {
  synchronized (this.name) {
   if (this.bean == null) {
       // 因为bean为空，所以会触发一次bean的重新初始化，走了一遍生命周期流程所以配置又回来了
    this.bean = this.objectFactory.getObject();
   }
  }
 }
 return this.bean;
}