前言

Spring 中使用了三级缓存的设计，来解决单例模式下的属性循环依赖问题。

这句话有两点需要注意

1. 解决问题的方法是「三级缓存的设计」

2. 解决的只是单例模式下的 Bean 属性循环依赖问题，对于多例 Bean 和 Prototype 作用域的 Bean的循环依赖问题，并不能使用三级缓存设计解决。

Bean 的生命周期

Spring Bean 的生命周期可以简单概括为 4 个阶段

1. 实例化（Instantiation）

2. 属性赋值（Populate）

3. 初始化（Initialization）

4. 销毁（Destruction）

什么是循环依赖

 public class A {
 
     @Autowired
     private B b;
 
 }
 
 public class B {
 
     @Autowired
     private A a;
 
 }

如上代码所示，即 A 里面注入 B，B 里面又注入 A。此时，就发生了「循环依赖」。

三级缓存

Spring 中，单例 Bean 在创建后会被放入 IoC 容器的缓存池中，并触发 Spring 对该 Bean 的生命周期管理。

单例模式下，在第一次使用 Bean 时，会创建一个 Bean 对象，并放入 IoC 容器的缓存池中。后续再使用该 Bean 对象时，会直接从缓存池中获取。

保存单例模式 Bean 的缓存池，采用了三级缓存设计，如下代码所示。

/** Cache of singleton objects: bean name --> bean instance */
 
 /** 一级缓存：用于存放完全初始化好的 bean **/
 
 private final Map singletonObjects = new ConcurrentHashMap(256);
 /** Cache of early singleton objects: bean name --> bean instance */
 /** 二级缓存：存放原始的 bean 对象（尚未填充属性），用于解决循环依赖 */
 private final Map earlySingletonObjects = new HashMap(16);
 /** Cache of singleton factories: bean name --> ObjectFactory */
 /** 三级级缓存：存放 bean 工厂对象，用于解决循环依赖 */
 private final Map> singletonFactories = new HashMap>(16);

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

getSingleton方法中三级缓存的使用

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   // Spring首先从singletonObjects（一级缓存）中尝试获取
 
  Object singletonObject = this.singletonObjects.get(beanName);
   // 若是获取不到而且对象在建立中，则尝试从earlySingletonObjects(二级缓存)中获取
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
     synchronized (this.singletonObjects) {
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
          ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
           if (singletonFactory != null) {
             //若是仍是获取不到而且允许从singletonFactories经过getObject获取，则经过singletonFactory.getObject()(三级缓存)获取
               singletonObject = singletonFactory.getObject();
               //若是获取到了则将singletonObject放入到earlySingletonObjects,也就是将三级缓存提高到二级缓存中
 
              this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
          }
        }
    }
 
  }
 
   return (singletonObject != NULL_OBJECT ? singletonObject : null);
 
 }

getSingleton() 方法中

• isSingletonCurrentlyInCreation() 方法用于判断当前单例 Bean 是否正在创建中，即「还没有执行初始化方法」。比如，A 的构造器依赖了 B 对象因此要先去创建 B 对象，或者在 A 的属性装配过程中依赖了 B 对象因此要先创建 B 对象，这时 A 就是处于创建中的状态。

• allowEarlyReference 变量表示是否允许从三级缓存 singletonFactories 中经过 singletonFactory 的 getObject() 方法获取 Bean 对象。

分析 getSingleton() 的整个过程，可知三级缓存的使用过程如下

1. Spring 会先从一级缓存 singletonObjects 中尝试获取 Bean。

2. 若是获取不到，而且对象正在建立中，就会尝试从二级缓存 earlySingletonObjects 中获取 Bean。

3. 若还是获取不到，且允许从三级缓存 singletonFactories 中经过 singletonFactory 的 getObject() 方法获取 Bean 对象，就会尝试从三级缓存 singletonFactories 中获取 Bean。

4. 若是在三级缓存中获取到了 Bean，会将该 Bean 存放到二级缓存中。

第三级缓存为什么可以解决循环依赖

Spring 解决循环依赖的诀窍就在于 singletonFactories 这个三级缓存。 三级缓存中使用到了ObjectFactory 接口，定义如下

 public interface ObjectFactory {
 
     T getObject() throws BeansException;
 
 }
 

在 Bean 建立过程当中，有两处比较重要的匿名内部类实现了该接口。一处是 Spring 利用其建立 Bean 的时候，另外一处就是在 addSingletonFactory 方法中，如下代码所示。

 addSingletonFactory(beanName, new ObjectFactory