--- theme: cyanosis --- ## 参考资料 * [Spring IoC 进阶之循环依赖 | Java 全栈知识体系](https://pdai.tech/md/spring/spring-x-framework-ioc-source-3.html) * [Spring为什么使用三级缓存而不是两级](https://www.zhihu.com/question/445446018) * [Spring三级缓存机制](https://www.cnblogs.com/semi-sub/p/13548479.html) ## 前言 **Spring 中使用了三级缓存的设计，来解决单例模式下的属性循环依赖问题。** 这句话有两点需要注意 1. 解决问题的方法是「三级缓存的设计」 2. 解决的只是单例模式下的 Bean 属性循环依赖问题，对于多例 Bean 和 Prototype 作用域的 Bean的循环依赖问题，并不能使用三级缓存设计解决。 ## Bean 的生命周期 Spring Bean 的生命周期可以简单概括为 4 个阶段 1. 实例化（Instantiation） 2. 属性赋值（Populate） 3. 初始化（Initialization） 4. 销毁（Destruction） ## 什么是循环依赖 ```java 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 的缓存池，采用了三级缓存设计，如下代码所示。 ```java /** 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); ``` | 缓存层级 | 名称 | 描述 | |-------------|-------------------|----------------------------------------| | 第一层缓存 | `singletonObjects` | 单例对象缓存池，存放的 Bean 已经实例化、属性赋值、完全初始化好（成品）| | 第二层缓存 | `earlySingletonObjects` | 早期单例对象缓存池，存放的 Bean 已经实例化但尚未属性赋值、未执行 `init` 方法（半成品） | | 第三层缓存 | `singletonFactories` | 单例工厂的缓存 | ## 使用三级缓存解决循环依赖 ### getSingleton方法中三级缓存的使用 ```java 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` 接口，定义如下 ```java public interface ObjectFactory { T getObject() throws BeansException; } ``` 在 Bean 建立过程当中，有两处比较重要的匿名内部类实现了该接口。一处是 Spring 利用其建立 Bean 的时候，另外一处就是在 `addSingletonFactory` 方法中，如下代码所示。 ```java addSingletonFactory(beanName, new ObjectFactory