Spring如何使用三级缓存解决循环依赖

1. 前言

在日常开发中，Bean之间的循环依赖非常常见，Spring 已经帮我们做到使用无感知处理，那么 Spring 是如何实现的呢？Es528资讯网——每日最新资讯28at.com

2. 循环依赖简介

2.1 什么是循环依赖

循环依赖是指两个或多个对象存在相互依赖、相互引用的关系，而这种引用形成一个环时，就会出现循环引用，如图:Es528资讯网——每日最新资讯28at.com

图片Es528资讯网——每日最新资讯28at.com

public class PersonA {   @Autowired  private PersonB personB;}

public class PersonB {  @Autowired  private PersonA personA;}

2.2 Spring 处理循环依赖的前提条件

1.相互依赖的 Bean 必须为单利;Es528资讯网——每日最新资讯28at.com

因为如果每次请求都创建一个 Bean，那么在处理循环依赖的时候，每次都会产生一个新的 Bean 实例，由于没有全局的实例 Bean 缓存，则无法处理循环依赖Es528资讯网——每日最新资讯28at.com

2.依赖注入的方式不能都是构造函数注入的方式。Es528资讯网——每日最新资讯28at.com

使用构造函数注入，Bean 实例在构造函数没有完全被调用时是不会创建的；因为 PersonA 引用 PersonB，PersonB 又引用 PersonA，两者都无法进行初始化，产生了死锁Es528资讯网——每日最新资讯28at.com

3. 三级缓存原理

3.1 什么是三级缓存

Spring 是通过三级缓存的方式处理循环依赖，三级缓存是 Spring Bean 在各个阶段的缓存Es528资讯网——每日最新资讯28at.com

一级缓存（SingletonObjects）:

存放已经完全实例化、初始化的bean，实现了单利bean只会实例化和初始化一次Es528资讯网——每日最新资讯28at.com

二级缓存（EarlySingletonObjects）:

存放早期暴露出来的Bean对象，bean的生命周期还未完成(未完成属性注入与初始化的bean)Es528资讯网——每日最新资讯28at.com

三级缓存（SingletonFactories）:

三级缓存中存储的是单利工厂缓存，通过调用该对象的 GetObject 方法，可以获取到早期暴露出去的 Bean；在该 Bean 要被其他 Bean 引用时，Spring 就会用工厂对象创建出该 Bean 的实例对象，最终当该 Bean 完成构造的所有步骤后就会将该 Bean 放入到一级缓存中Es528资讯网——每日最新资讯28at.com

/** 一级缓存 */private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);/** 二级缓存 */ private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16); /** 三级缓存 */ private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

3.2 三级缓存流程

图片Es528资讯网——每日最新资讯28at.com

3.3 三级缓存源码解析

创建 Bean 主要的方法是 AbstractBeanFactory.doGetBean 方法

protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {  // 获取bean的规范名称  String beanName = transformedBeanName(name);   Object bean;    // 从各级缓存中获取bean对象   Object sharedInstance = getSingleton(beanName);   // 跟factoryBean相关判断  if (sharedInstance != null && args == null) { ...  }   // 获取factorybean的真是bean  //若为普通bean则直接返回对象  bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } ......   // 创建单利bean对象   if (mbd.isSingleton()) {     sharedInstance = getSingleton(beanName, () -> {   try {    // 创建bean    return createBean(beanName, mbd, args);   } catch (BeansException ex) {     // Explicitly remove instance from singleton cache: It might have been put there     // eagerly by the creation process, to allow for circular reference resolution.     // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName);     throw ex;   } });   bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } ......    // 返回bean对象 return (T) bean; }

我们看两个比较重要获取 Bean 的方法 GetSingleton()

// 这个方法主要是三级缓存容器，思路大概是：从一级缓存查询，若找不到去二级缓存查询，还是不存在则去三级缓存，若三级缓存找到了，则将bean放入二级缓存中protected Object getSingleton(String beanName, boolean allowEarlyReference) {  // 从一级缓存中查找bean  Object singletonObject = this.singletonObjects.get(beanName);  // 判断一级缓存查找不到bean && bean是否处于创建中，成立，则进入循环依赖  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {    synchronized (this.singletonObjects) {    // 从二级缓存中查找    singletonObject = this.earlySingletonObjects.get(beanName);    // 二级缓存未查询到 && 是否允许获取早期引用    if (singletonObject == null && allowEarlyReference) {      // 从三级缓存查询      ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);      // 三级缓存存在bean      if (singletonFactory != null) {        // 获取bean实例        singletonObject = singletonFactory.getObject();        // 从三级缓存升级到二级缓存，        this.earlySingletonObjects.put(beanName, singletonObject);        // 三级缓存中移除        this.singletonFactories.remove(beanName);        }      }    }  }   // 返回bean  return singletonObject;}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {    Assert.notNull(beanName, "Bean name must not be null");    synchronized (this.singletonObjects) {          // 从一级缓存中获取对应bean   Object singletonObject = this.singletonObjects.get(beanName);        // 若bean不存在   if (singletonObject == null) {      // 当前正在销毁bean，不能创建    if (this.singletonsCurrentlyInDestruction) {        throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)");      }      if (logger.isDebugEnabled()) {        logger.debug("Creating shared instance of singleton bean '" + beanName + "'");      }    // 创建前检查，记录正在加载状态         beforeSingletonCreation(beanName);     boolean newSingleton = false;    boolean recordSuppressedExceptions = (this.suppressedExceptions == null);      // 如果当前没有异常，初始化异常集合    if (recordSuppressedExceptions) {        this.suppressedExceptions = new LinkedHashSet<>();      }      try {      // 执行匿名内部类方法       singletonObject = singletonFactory.getObject();       newSingleton = true;     }      catch(IllegalStateException ex){        // 执行getObject方法创建bean      singletonObject = this.singletonObjects.get(beanName);        if (singletonObject == null) {          throw ex;        }      } catch(BeanCreationException ex){        if (recordSuppressedExceptions) {          or (Exception suppressedException : this.suppressedExceptions) {           ex.addRelatedCause(suppressedException);        }      }        throw ex;      } finally{        if (recordSuppressedExceptions) {          this.suppressedExceptions = null;        }       // 单例bean创建完成后，容器移除bean      afterSingletonCreation(beanName);      }      // newSingleton为true时，表示bean创建成功      // 判断是否为新的完成整bean    if (newSingleton) {                  // 将bean存入一级缓存中      addSingleton(beanName, singletonObject);      }     }    return singletonObject;    }  }

添加与清理缓存

// 将bean放入一级缓存切清楚二级、三级缓存protected void addSingleton(String beanName, Object singletonObject) {  synchronized (this.singletonObjects) {xw    // 添加到一级缓存中     this.singletonObjects.put(beanName, singletonObject);     // 从三级缓存中移除     this.singletonFactories.remove(beanName);    // 从二级缓存中移除     this.earlySingletonObjects.remove(beanName);    // 放入已注册的单利池中    this.registeredSingletons.add(beanName);  }}

// 添加到三级缓存protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {  synchronized (this.singletonObjects) {  // 若一级缓存不存在bean实例  if (!this.singletonObjects.containsKey(beanName)) {    // 添加到三级缓存    this.singletonFactories.put(beanName, singletonFactory);    // 从第二级缓存删除    this.earlySingletonObjects.remove(beanName);    // 放入已注册的单例池里    this.registeredSingletons.add(beanName);  }}

4.总结

Spring 循环依赖是通过map缓存进行处理的，其中包括一级、二级、三级缓存，作用如下：Es528资讯网——每日最新资讯28at.com

• 一级缓存SingletonObjects实例化、初始化实例。
• 二级缓存EarlySingletonObjects存放的是早期的 Bean ，半成品还未初始化的 bean。
• 三级缓存SingletonFactories是一个对象工厂，用于创建对象，然后放入到二级缓存中。同时对象如果存在 Aop 代理，那么返回的对象就是代理对象。

参考文献

https://www.51cto.com/article/702892.htmlEs528资讯网——每日最新资讯28at.com

本文链接：http://www.28at.com/showinfo-26-44423-0.htmlSpring如何使用三级缓存解决循环依赖

声明：本网页内容旨在传播知识，若有侵权等问题请及时与本网联系，我们将在第一时间删除处理。邮件：2376512515@qq.com

上一篇： 在终端里输入 npm start 后都发生了啥

下一篇： 时尚更多元 三星 Galaxy Watch6 系列助你完美解锁冬日氛围感