1.什么是循环依赖?

所谓的循环依赖就是A依赖B，B依赖A；或者是A依赖B，B依赖C，C依赖A

下面来看个实例：

public class InstanceA {
     
    private InstanceB instanceB; 
    // setter...
} 
public class InstanceB {
      
    private InstanceA instanceA; 
    // setter...
}

这里有两个类 A 和 B，A 中有一个成员变量 B，B 中有一个成员变量 A；然后我们在 xml 中通过构造这两个 bean，并通过 setter 来进行依赖注入：

<bean id="instanceA" class="com.tuling.circulardependencies.InstanceA">   
      <property name="instanceB" ref="intanceB"></property>  
</bean> 
    
<bean id="intanceB" class="com.tuling.circulardependencies.InstanceB">     
    <property name="instanceA" ref="instanceA"></property>  
</bean>

可能存在的问题：

IOC容器在创建Bean的时候，按照顺序，先去实例化instanceA。然后突然发现我的instanceA是依赖我的instanceB的。那么IOC容器接着去实例化intanceB，那么在intanceB的时候发现依赖instanceA。若容器不处理的， 那么IOC将无限的执行上述流程。直到内存异常程序奔溃

解决思路：

当然，Spring 是不会让这种情况发生的。在容器发现 beanB 依赖于 beanA 时，容器会获取 beanA 对象的一个早期的引用（early reference），并把这个早期引用注入到 beanB 中，让 beanB 先完成实例化。beanB 完成实例化，beanA 就可以获取到 beanB 的引用，beanA 随之完成实例化。

这里解释一下上面说的早期引用，实际就是说在 bean 完成初始化之前被引用

注：循环依赖在实际应用中也有，但不会太多，简单的应用场景是： controller注入service，service注入mapper，只有复杂的业务，可能service互相引用，有可能出现循环依赖

那循环依赖该怎么解决呢？

2.循环依赖解决方案

Spring 在启动过程中，使用到了三个 map，称为三级缓存

// 一级缓存：用于存放 beanName 和初始化好的 bean 对象(属性已经初始化好的)  
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256); 

 // 二级缓存：用于存放 beanName 和一个原始 bean 早期 bean(属性未初始化)  
private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16); 
 
// 三级缓存：存放 bean 工厂对象，用于解决 AOP 需要代理对象的循环依赖问题
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16); 

一级缓存就不用说了，缓存单例 bean 的。我们下面就来看看二级和三级缓存是如何解决循环依赖的？

首先，我们要清楚的是，在调用 getBean() 后的执行逻辑是

1. 创建 bean 实例 createBeanInstance()
2. 对 bean 进行依赖注入 populateBean()（循环依赖就出现在这里）
3. 对 bean 进行初始化 initializeBean()

2.1 二级缓存

所以，我们解决循环依赖的思路可以是，除了单例池（一级缓存）之外，再创建一个半成品池（二级缓存，earlySingletonObjects），即对象一创建就添加到半成品池

1. 对象 A 创建之后直接就放入半成品池
2. 对象 B 创建后，直接从半成品池中拿出 A 对象，然后注入到 B 中
3. 将注入后的 B 放入单例池
4. 将单例池中的 B 注入到对象 A 中
5. 将 A 添加到单例池，并移除半成品池中的 A

但是，问题来了如果 A 使用了 AOP，那么 B 要注入的对象就是 A 的代理对象，而不是 A 本身；所以，单例池以及半成品池，应该存放的是 bean 的代理对象，而不是 bean 本身；那该怎么办呢？

2.2 三级缓存

首先，我们来看看代理对象的创建的时机。

代理对象在 AbstractAutowireCapableBeanFactory#doCreateBean() 方法中创建的，具体调用逻辑是 initializeBean() -> BeanPostProcessor#postProcessAfterInitialization() -> createProxy()。

那么问题来了，入口 initializeBean() 都在依赖注入 populateBean() 之后了，那依赖注入时就根本拿不到代理对象啊…

所以，为了解决循环以依赖的问题，在 doCreateBean() 方法中，createBeanInstance() 之后，populateBean() 之前添加了一个工厂池（三级缓存，singletonFactories），这个工厂池里面缓存了许多 bean 的 FactoryBean，这些工厂不仅可以暴露早期 bean 还可以暴露代理 bean

1. 对象 A 创建
2. 由于 B 要提前引用 A，所以通过工厂池中 A 的 FactoryBean#getObject 创建 A 的代理对象，并将该代理对象放入半成品池
3. B 从半成品池中获取到 A 的代理对象，并完成依赖注入
4. 将注入后的 B 放入单例池
5. 将单例池中的 B 注入到对象 A 中
6. 将半成品池中 A 的代理对象移到单例池中
7. 将工厂池中的 A 移除

注：此时对于 A 来说，就没要再进行 BeanPostProcessor 后置处理了，因为已经提前创建过代理对象了

可能有同学要问了，既然三级缓存也能够获取到早期 bean，那就已经能解决循环依赖了，为什么还需要一个二级缓存？

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    
   // 检查缓存中是否有初始化好的bean 
   Object singletonObject = this.singletonObjects.get(beanName);
   // 判断 beanName 对应的 bean 是否正在创建中 
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    
       // 加锁，防止多线程并发创建 
      synchronized (this.singletonObjects) {
    
         // 从 earlySingletonObjects 中获取提前曝光的 bean 
         singletonObject = this.earlySingletonObjects.get(beanName);
         // 没拿到
         if (singletonObject == null && allowEarlyReference) {
    
            // 获取相应的 bean 工厂 
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
    
               // 提前曝光 bean 实例（raw bean）也是早期bean ，用于解决循环依赖 
               singletonObject = singletonFactory.getObject();
               // 将 singletonObject 放入缓存中，并将 singletonFactory 从缓存中移除 
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

可以从源码中看到，只有当二级缓存 earlySingletonObjects 获取不到提前曝光的 bean 时（主要出现于获取代理对象），才会走到三级缓存 singletonFactories 执行工厂的 getObject() 生成(获取)早期依赖，生成后就将早期对象放入二级缓存，并且删除当前 FactoryBean。

所以，二级缓存 earlySingletonObjects 更注重的是存储，而三级缓存 singletonFactories 更注重的是生产。

再放一个很好的视频参考链接（B站）：https://www.bilibili.com/video/BV1ET4y1N7Sp?p=1…