一文带你从零到一深入透析 @RefreshScope 结合 Nacos 动态刷新源码（下）

private void registerNacosListenersForApplications() {
  if (isRefreshEnabled()) {
    // 在这里获取 NacosPropertySourceLocator#locate 方法存入的动态刷新配置文件
    for (NacosPropertySource propertySource : NacosPropertySourceRepository.getAll()) {
      // 再次确认是否刷新
      if (!propertySource.isRefreshable()) {
        continue;
      }
      String dataId = propertySource.getDataId();
      // 注册监听器：以 dataId、group 为注册单元
      registerNacosListener(propertySource.getGroup(), dataId);
      log.info("listening config: dataId={}, group={}", dataId, propertySource.getGroup());
    }
  }
}

private void registerNacosListener(final String groupKey, final String dataKey) {
  String key = NacosPropertySourceRepository.getMapKey(dataKey, groupKey);
  Listener listener = listenerMap.computeIfAbsent(key,
         lst -> new AbstractSharedListener() {
          /**
           * 接收到消息
           */
          @Override
          public void innerReceive(String dataId, String group,
              String configInfo) {
            // 累加动态刷新的次数
            refreshCountIncrement();
            // 追加历史刷新记录，用于 endpoint 统计分析，最多存 15 条
            nacosRefreshHistory.addRefreshRecord(dataId, group, configInfo);
            // 发布刷新事件，会由 RefreshEventListener 监听器处理，该监听器又会发布 EnvironmentChangeEvent 事件，重新加载所有的环境配置信息
            applicationContext.publishEvent(
                new RefreshEvent(this, null, "Refresh Nacos config"));
            if (log.isDebugEnabled()) {
              log.debug(String.format(
                  "Refresh Nacos config group=%s,dataId=%s,configInfo=%s",
                  group, dataId, configInfo));
            }
          }
        });
  try {
    // Nacos 客户端的核心方法：NacosConfigService#addListener
    configService.addListener(dataKey, groupKey, listener);
  }
  catch (NacosException e) {
    log.warn(String.format(
      "register fail for nacos listener ,dataId=[%s],group=[%s]", dataKey,
      groupKey), e);
  }
}

config:
    info: I'm cloud-3377 version 1

// RefreshEventListener.java
public void onApplicationEvent(ApplicationEvent event) {
  // CAS 修改状态应用程序已准备就绪
  if (event instanceof ApplicationReadyEvent) {
    handle((ApplicationReadyEvent) event);
  }
  else if (event instanceof RefreshEvent) {
    handle((RefreshEvent) event);
  }
}
public void handle(ApplicationReadyEvent event) {
  // 更新原子状态，应用程序已经就绪
  this.ready.compareAndSet(false, true);
}
public void handle(RefreshEvent event) {
  // 防止在不处理事件之前，应用程序已经准备好了
  if (this.ready.get()) {
    log.debug("Event received " + event.getEventDesc());
    // ContextRefresher#refresh 方法
    Set<String> keys = this.refresh.refresh();
    log.info("Refresh keys changed: " + keys);
  }
}

// ContextRefresher.java
public synchronized Set<String> refresh() {
  // 刷新环境内属性变量值
  Set<String> keys = refreshEnvironment();
  // RefreshScope#refreshAll
  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();
  // 这里发布环境更改事件，对现有的属性源 Bean 销毁后，重新进行赋值操作
  this.context.publishEvent(new EnvironmentChangeEvent(this.context, keys));
  return keys;
}

public void refreshAll() {
  // 调用 GenericScope 销毁方法 
  super.destroy();
  this.context.publishEvent(new RefreshScopeRefreshedEvent());
}

public void destroy() {
  List<Throwable> errors = new ArrayList<Throwable>();
  // 清楚 ScopeCache#cache 集合里所有的元素
  Collection<BeanLifecycleWrapper> wrappers = this.cache.clear();
  for (BeanLifecycleWrapper wrapper : wrappers) {
    try {
      Lock lock = this.locks.get(wrapper.getName()).writeLock();
      lock.lock();
      try {
        // 销毁 refresh Bean 实例
        wrapper.destroy();
      }
      finally {
        lock.unlock();
      }
    }
    catch (RuntimeException e) {
      errors.add(e);
    }
  }
  if (!errors.isEmpty()) {
    throw wrapIfNecessary(errors.get(0));
  }
  this.errors.clear();
}

public Object invoke(MethodInvocation invocation) throws Throwable {
  Method method = invocation.getMethod();
  // equals、toString、hashCode、方法名称是 getTargetObject 跳过不作后续处理
  if (AopUtils.isEqualsMethod(method) || AopUtils.isToStringMethod(method)
      || AopUtils.isHashCodeMethod(method)
      || isScopedObjectGetTargetObject(method)) {
    return invocation.proceed();
  }
  // 获取父类 ScopedProxyFactoryBean 创建好的代理
  Object proxy = getObject();
  ReadWriteLock readWriteLock = this.scope.getLock(this.targetBeanName);
  if (readWriteLock == null) {
    if (logger.isDebugEnabled()) {
      logger.debug("For bean with name [" + this.targetBeanName
                   + "] there is no read write lock. Will create a new one to avoid NPE");
    }
    readWriteLock = new ReentrantReadWriteLock();
  }
  Lock lock = readWriteLock.readLock();
  lock.lock();
  try {
    // 满足
    if (proxy instanceof Advised) {
      Advised advised = (Advised) proxy;
      ReflectionUtils.makeAccessible(method);
      // advised.getTargetSource().getTarget()：主要的入口获取 Bean
      return ReflectionUtils.invokeMethod(method,
                                          advised.getTargetSource().getTarget(),
                                          invocation.getArguments());
    }
    return invocation.proceed();
  }
  // see gh-349. Throw the original exception rather than the
  // UndeclaredThrowableException
  catch (UndeclaredThrowableException e) {
    throw e.getUndeclaredThrowable();
  }
  finally {
    lock.unlock();
  }
}

public Object getTarget() throws Exception {
  return this.getBeanFactory().getBean(this.getTargetBeanName());
}