Spring Cloud中@RefreshScope实现动态刷新的原理

在现代微服务架构中,Spring Cloud已经成为了一种流行的选择,它提供了许多用于构建和部署微服务的工具和库。其中,动态刷新配置是Spring Cloud中一个非常有用的特性,它允许我们在不重启服务的情况下更新配置。这个特性是通过@RefreshScope注解来实现的。在本文中,我们将深入探讨@RefreshScope在Spring Cloud中是如何工作的。

提升编程效率的利器: 解析Google Guava库之集合篇RangeSet范围集合(五)

一、@RefreshScope注解的作用

首先,让我们来了解一下@RefreshScope注解的作用。在Spring Cloud中,@RefreshScope是一个特殊的scope注解,它用于标记那些需要动态刷新的Bean。当一个Bean被@RefreshScope注解时,Spring容器会为这个Bean创建一个特殊的scope,称为refresh scope。这意味着,当配置发生变化时,Spring容器能够重新创建这个Bean的实例,并使用新的配置。

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Scope("refresh")
@Documented
public @interface RefreshScope {

	/**
	 * @see Scope#proxyMode()
	 * @return proxy mode
	 */
	ScopedProxyMode proxyMode() default ScopedProxyMode.TARGET_CLASS;

}
  • 上面是RefreshScope的源码,该注解被@Scope注解使用,@Scope用来比较Spring Bean的作用域。
  • 注解的属性proxyMode默认使用TARGET_CLASS作为代理。
  • @RefreshScope本质上是一个特殊的作用域,它通过继承GenericScope类并重写相关方法来实现配置刷新的逻辑。
  • @Scope注解的作用是指定RefreshScope作为一个新的作用域类型。具体来说,@RefreshScope注解内部使用了@Scope注解,并将其value属性设置为"refresh",这表示定义了一个新的作用域名为refresh。当Spring容器遇到@RefreshScope注解时,它会知道这是一个特殊的作用域,需要按照RefreshScope的逻辑来处理Bean的创建、缓存和销毁。

@Scope注解用于指定由Spring IoC容器管理的Bean的作用域。作用域决定了Bean的生命周期、创建时机以及存储方式。常见的Spring作用域包括singleton(单例)、prototype(原型)、request(请求)、session(会话)等。

二、@RefreshScope实现动态刷新的流程

在Spring Cloud中,@RefreshScope实现动态刷新的流程可以总结为以下几个步骤:

  1. 定义@RefreshScope注解: 开发者在需要动态刷新的Bean上使用@RefreshScope注解。这个注解内部使用了@Scope注解,并将其值设置为"refresh",定义了一个新的作用域名为refresh。

  2. Spring容器解析@RefreshScope: 当Spring容器启动时,它会解析所有的Bean定义,并遇到@RefreshScope注解时,Spring容器会知道这是一个特殊的作用域。它使用RefreshScope类(继承自GenericScope)来处理这些Bean的生命周期。

  3. Bean的创建和缓存: 当应用首次请求一个被@RefreshScope标记的Bean时,Spring容器会调用RefreshScope的get方法来创建Bean的实例。创建完成后,这个Bean实例会被缓存在RefreshScope中,以便后续快速获取。

  4. 配置更改: 在运行时,如果外部配置源中的配置发生了更改(比如通过Spring Cloud Config Server),客户端应用需要被通知到这些更改。

  5. 触发刷新事件: 客户端应用可以通过多种方式触发刷新事件,比如通过Spring Cloud Bus广播配置更改消息,或者直接调用/actuator/refresh端点。

  6. 更新本地的Environment对象: 在刷新事件被触发之前或之后,需要更新本地的Environment对象,以反映外部配置源中的最新配置。这通常是通过Environment的实现类(如StandardEnvironment或MutablePropertySources)来完成的。更新的方式可能是添加、修改或删除PropertySource,或者直接操作MutablePropertySources中的属性源列表。

  7. 刷新作用域中的Bean: 当Environment对象更新后,RefreshScope会遍历其缓存中的所有Bean,对它们进行销毁和重新创建。这是通过调用GenericScope提供的生命周期管理方法来完成的。旧的Bean实例被销毁,新的Bean实例根据最新的配置(从更新后的Environment中获取)被创建并缓存。

  8. 应用新的配置: 经过刷新操作后,应用中的Bean将使用新的配置。由于@RefreshScope仅影响标记了此注解的Bean,因此未标记的Bean不会受到影响。

总结一下,要实现动态刷新,主要达成以下两个核心目标:

  • 让Spring容器重新加载Environment环境配置变量
  • 让Spring Bean重新创建生成

三、源码解读

  1. 通过打断点查看堆栈,获取RefreshScope注解的Bean
    Spring Cloud中@RefreshScope实现动态刷新的原理_第1张图片

因为类被加上了@RefreshScope注解,那么这个BeanDefinition信息中的scope为"refresh",在getBean的的时候会单独处理逻辑

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

protected <T> T doGetBean(
   String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
   throws BeansException {

    // 如果scope是单例的情况, 这里不进行分析
    if (mbd.isSingleton()) {
     .....
    }
                // 如果scope是prototype的情况, 这里不进行分析
    else if (mbd.isPrototype()) {
     ......
    }
                // 如果scope是其他的情况,本例中是reresh
    else {
     String scopeName = mbd.getScope();
     if (!StringUtils.hasLength(scopeName)) {
      throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
     }
                    // 获取refresh scope的实现类RefreshScope,这个类在哪里注入,我们后面讲
     Scope scope = this.scopes.get(scopeName);
     if (scope == null) {
      throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
     }
     try {
                        // 这边是获取bean,调用的是RefreshScope中的的方法
      Object scopedInstance = scope.get(beanName, () -> {
       beforePrototypeCreation(beanName);
       try {
        return createBean(beanName, mbd, args);
       }
       finally {
        afterPrototypeCreation(beanName);
       }
      });
      beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
     }
     catch (IllegalStateException ex) {
      throw new ScopeNotActiveException(beanName, scopeName, ex);
     }
    }
   }
   catch (BeansException ex) {
    beanCreation.tag("exception", ex.getClass().toString());
    beanCreation.tag("message", String.valueOf(ex.getMessage()));
    cleanupAfterBeanCreationFailure(beanName);
    throw ex;
   }
   finally {
    beanCreation.end();
   }
  }

  return adaptBeanInstance(name, beanInstance, requiredType);
 }
    
}
  1. RefreshScope继承成了GenericScope,最终调用的的是GenericScope的get方法
public class GenericScope
  implements Scope, BeanFactoryPostProcessor, BeanDefinitionRegistryPostProcessor, DisposableBean {
                 @Override
 
  public Object get(String name, ObjectFactory<?> objectFactory) {
  // 将bean添加到缓存cache中
        BeanLifecycleWrapper value = this.cache.put(name, new BeanLifecycleWrapper(name, objectFactory));
  this.locks.putIfAbsent(name, new ReentrantReadWriteLock());
  try {
            // 调用下面的getBean方法
   return value.getBean();
  }
  catch (RuntimeException e) {
   this.errors.put(name, e);
   throw e;
  }
 }       

private static class BeanLifecycleWrapper {
        
  public Object getBean() {
            // 如果bean为空,则创建bean
   if (this.bean == null) {
    synchronized (this.name) {
     if (this.bean == null) {
      this.bean = this.objectFactory.getObject();
     }
    }
   }
            // 否则返回之前创建好的bean
   return this.bean;
  }
            }
        }

从Spring框架的源码中可以印证上述说法。对于使用@RefreshScope(或其他自定义作用域)的Bean,Spring容器在创建Bean实例后会将其缓存到相应作用域的cache中。在后续请求相同Bean时,Spring会优先从这个缓存中尝试获取Bean实例。

如果缓存中是null,说明Bean尚未被创建或者已经被销毁,此时Spring会重新走一遍创建Bean的流程,包括解析Bean定义、执行依赖注入等步骤,最终将新创建的Bean实例再次缓存到作用域中。

这种缓存机制确保了对于相同作用域和相同Bean定义的请求,Spring能够快速地提供Bean实例,而不必每次都重新创建。同时,对于像@RefreshScope这样的特殊作用域,它还允许在运行时动态地刷新Bean实例,以适应配置的变更。在刷新过程中,缓存中的旧Bean实例会被销毁,新的Bean实例会被创建并缓存起来,以供后续使用。

配置中心刷新后刷新Bean缓存

Spring Cloud中@RefreshScope实现动态刷新的原理_第2张图片

配置中心发生变化后,会收到一个RefreshEvent事件,RefreshEventListner监听器会监听到这个事件。

public class RefreshEventListener implements SmartApplicationListener {

 
........

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

}

// 这个是ContextRefresher类中的刷新方法
public synchronized Set<String> refresh() {
        // 刷新spring的envirionment 变量配置
  Set<String> keys = refreshEnvironment();
        // 刷新其他scope
  this.scope.refreshAll();
  return keys;
 }

refresh方法最终调用destroy方法,清空之前缓存的bean

public class RefreshScope extends GenericScope
  implements ApplicationContextAware, ApplicationListener<ContextRefreshedEvent>, Ordered {

 @ManagedOperation(description = "Dispose of the current instance of all beans "
   + "in this scope and force a refresh on next method execution.")
 public void refreshAll() {
  // 调用父类的destroy
        super.destroy();
  this.context.publishEvent(new RefreshScopeRefreshedEvent());
 }
}


@Override
 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 {
                    // 这里主要就是把之前的bean设置为null, 就会重新走createBean的流程了
     wrapper.destroy();
    }
    finally {
     lock.unlock();
    }
   }
   catch (RuntimeException e) {
    errors.add(e);
   }
  }
  if (!errors.isEmpty()) {
   throw wrapIfNecessary(errors.get(0));
  }
  this.errors.clear();
 }
  • 当配置中心发生配置更改时,通常会通过Spring Cloud Bus或Spring Cloud Config的监控机制来传播这些更改。一旦客户端应用检测到这些更改,它会触发一个刷新事件,通常是RefreshEvent。

  • RefreshEventListener类实现了SmartApplicationListener接口,用于监听RefreshEvent事件。当RefreshEvent被触发时,handle方法会被调用,进而执行刷新逻辑。

  • 在刷新逻辑中,首先会刷新Spring的Environment对象,这通常涉及重新加载配置属性。然后,会调用RefreshScope的refreshAll方法来刷新所有标记为@RefreshScope的Bean。

  • RefreshScope是GenericScope的一个扩展,它提供了额外的逻辑来处理配置刷新。在refreshAll方法中,通过调用父类的destroy方法来销毁当前作用域中缓存的所有Bean实例。这个销毁过程会将缓存中的Bean实例设置为null,并且释放相关的资源。一旦Bean实例被销毁,下次请求该Bean时,Spring容器将重新创建它。

  • 销毁完成后,RefreshScope会发布一个RefreshScopeRefreshedEvent事件,以通知其他监听器刷新操作已经完成。

总的来说,这个过程确保了当配置发生更改时,应用能够动态地更新其Environment和@RefreshScope标记的Bean,而无需重启整个应用。这是Spring Cloud提供的一个强大特性,使得微服务应用能够在运行时动态地响应配置更改。

四、总结

通过结合@RefreshScope注解、RefreshScope和GenericScope的实现,以及Spring容器对Bean生命周期的管理,Spring Cloud能够实现配置的动态刷新。这使得微服务应用能够在不重启整个应用的情况下,响应外部配置的更改,从而提高了系统的灵活性和响应速度。

需要注意的是,虽然动态刷新配置是一个非常有用的特性,但它也有一些限制和注意事项。例如,不是所有的Bean都适合被标记为@RefreshScope,因为重新创建Bean实例可能会导致一些状态丢失。此外,频繁的配置更改和刷新可能会对系统的性能和稳定性产生影响。因此,在使用动态刷新配置时,需要权衡利弊,并谨慎选择需要刷新的Bean和配置。

希望本文能够帮助您更好地理解Spring Cloud中@RefreshScope实现动态刷新的原理,并在实际项目中正确地应用这个特性。

你可能感兴趣的:(spring源码,spring,cloud,spring,后端,java,spring,boot,微服务,分布式)