看这篇告诉你Spring如何完美的解决循环依赖

创作内容丰富的干货文章很费心力，感谢点过此文章的读者，点一个关注鼓励一下作者，激励他分享更多的精彩好文，谢谢大家！

---

循环依赖，其实就是循环引用，就是两个或者两个以上的 bean 互相引用对方，最终形成一个闭环，如A 依赖 B，B 依赖 C，C 依赖 A。如下图所示：

Spring中的循环依赖，其实就是一个死循环的过程，在初始化 A 的时候发现依赖了 B，这时就会去初始化 B，然后又发现 B 依赖 C，跑去初始化 C，初始化C 的时候发现依赖了 A，则又会去初始化 A，依次循环永不退出，除非有终结条件。
一般来说，Spring 循环依赖的情况有两种：构造器的循环依赖和field 属性的循环依赖。
对于构造器的循环依赖，Spring 是无法解决的，只能抛出 BeanCurrentlyInCreationException 异
常表示循环依赖，基于 field 属性的循环依赖，也要分两种细分的情况来对待：

• scope 为 singleton 的循环依赖。
• scope 为 prototype 的循环依赖。Spring 无法解决，直接抛出BeanCurrentlyInCreationException 异常。

三级缓存解决方案
spring内部有三级缓存：

• 成品：一级缓存 singletonObjects ，用于保存实例化、注入、初始化完成的bean实例
• 半成品：二级缓存 earlySingletonObjects ，用于保存实例化完成的bean实例
• 原材料工厂： 三级缓存 singletonFactories ，用于保存bean的创建工厂，以便于后面扩展有机会创建代理对象。

三级缓存是singletonFactories ，但是是不完整的Bean的工厂Factory，是当一个Bean在new之后
（没有属性填充、初始化），就put进去。所以，是原材料工厂。二级缓存是对三级缓存的过渡性处理，只要通过 getObject() 方法从三级缓存的BeanFactory中取出Bean一次，原材料就变成半成品，之后put到二级缓存 ， 所以，二级缓存里边的bean，都是半成品。一级缓存里面是完整的Bean，是当一个Bean完全创建后（完成属性填充、彻底的完成初始化）才put进去， 所以是成品。

从源码解读，doGetBean的查找bean的次序
在AbstractBeanFactory 的 doGetBean() 方法中，我们根据BeanName去获取Singleton Bean的时
候，会先从缓存获取。代码如下：

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference)
{
    // 从一级缓存缓存 singletonObjects 中加载 bean
    Object singletonObject = this.singletonObjects.get(beanName);
    // 缓存中的 bean 为空，且当前 bean 正在创建
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 加锁
        synchronized (this.singletonObjects) {
            // 从二级缓存 earlySingletonObjects 中获取
            singletonObject = this.earlySingletonObjects.get(beanName);
            // earlySingletonObjects 中没有，且允许提前创建
            if (singletonObject == null && allowEarlyReference) {
                // 从 三级缓存 singletonFactories 中获取对应的 ObjectFactory
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    //从单例工厂中获取bean
                    singletonObject = singletonFactory.getObject();
                    // 添加到二级缓存
                    this.earlySingletonObjects.put(beanName,singletonObject);
                    // 从三级缓存中删除
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

getSingleton()的查找bean的次序比较清晰：
首先，尝试从一级缓存singletonObjects （成品仓库）中获取单例Bean。如果获取不到，则从二级缓存earlySingletonObjects （半成品仓库）中获取单例Bean。如果仍然获取不到，则从三级缓存singletonFactories（原材料工厂仓库）中获取单例BeanFactory原材料工厂。最后，如果从三级缓存中拿到了BeanFactory，则通过getObject()生产一个最原始的bean，可以理解为最原始的bean实例（原材料），没有进行属性填充，也没有完成初始化。但是，由于此处是提取bean，所以bean原材料已经被使用了一次，所以，顺手把Bean存入二级缓存中，并把该Bean的（原材料工厂）从三级缓存中删除。三级缓存（原材料工厂仓库）里边的（原材料工厂 ）在哪里设置呢？
在 AbstractAutowireCapableBeanFactory 的 doCreateBean() 方法中，有这么一段代码：

boolean earlySingletonExposure = (mbd.isSingleton() // 单例模式
&& this.allowCircularReferences // 允许循环依赖
&& isSingletonCurrentlyInCreation(beanName)); // 当前单例 bean 是否正在被创建
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
}
// 为了后期避免循环依赖，提前将创建的 bean 实例，加入到三级缓存 singletonFactories 中
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName,mbd, bean));

这段代码就是put三级缓存 singletonFactories 的地方，其核心逻辑是，当满足以下3个条件时，把
bean加入三级缓存中：

• 单例
• 允许循环依赖
• 当前单例Bean正在创建

addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) 方法，将原始
的bean匿名工厂 （原材料工厂）加入到三级缓存，代码如下：

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

从这段代码我们可以看出，singletonFactories 这个三级缓存才是解决 Spring Bean 循环依赖的关键。注意：这段代码发生在 createBeanInstance(...) 方法之后，也就是说这个 bean 其实已经被创建出来了，但是它还没有完善（没有进行属性填充和初始化）。

设置到三级缓存之后，对于其他依赖它的对象而言已经足够了（已经有内存地址了，可以根据对象引用定位到堆中对象），能够被认出来了。addSingletonFactory方法的第二参数，通过匿名对象的方式，创建了一个 ObjectFactory 工厂，这个工厂只有一个方法，源码如下：

@FunctionalInterface
public interface ObjectFactory<T> {
    T getObject() throws BeansException;
}

一级缓存在哪里设置呢？
到这里我们发现三级缓存 singletonFactories 和 二级缓存 earlySingletonObjects 中的值都有出处了，那一级缓存在哪里设置的呢？在类 DefaultSingletonBeanRegistry 中，可以发现这个 addSingleton(String beanName, Object singletonObject) 方法，代码如下：

protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        //添加至一级缓存，同时从二级、三级缓存中删除。
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}