什么是循环依赖
循环依赖，其实就是循环引用，就是两个或者两个以上的 bean 互相引用对方，最终形成一个闭环，如 A 依赖 B，B 依赖 C，C 依赖 A。在初始化 A 的时候发现引用了 B，这时就会去初始化B，然后又发现 B 引用 C，跑去初始化 C，初始化 C 的时候发现引用了 A，则又会去初始化 A，依次循环永不退出，除非有终结条件。
Spring 循环依赖的场景有两种：
- 构造器的循环依赖：Spring无法解决
- field 属性的循环依赖：Spring只解决scope为singleton的循环依赖，解决singleton bean的核心就在于提前曝光 bean，对于scope 为 prototype 的 bean，Spring无法解决，直接抛出BeanCurrentlyInCreationException 异常。
解决方法
先从加载 bean最初始的方法 AbstractBeanFactory的#doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly) 方法开始。在#doGetBean(...) 方法中，首先会根据 beanName 从单例 bean 缓存中获取，如果不为空则直接返回。代码如下：
Object sharedInstance = getSingleton(beanName);
调用getSingleton方法，从单例缓存中获取
//这个方法主要是从三个缓存中获取，分别是：singletonObjects、earlySingletonObjects、singletonFactories
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从单例缓冲中加载 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();
// 添加 bean 到 earlySingletonObjects 中
this.earlySingletonObjects.put(beanName, singletonObject);
// 从 singletonFactories 中移除对应的 ObjectFactory
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
三级缓存定义：
/** 一级缓存，存放的是单例 bean 的映射,这里的 bean 是已经创建完成的
* 对应关系为 bean name --> bean instance
*/
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** 二级缓存，存放的是早期半成品（没有进行属性填充和初始化）的 bean
* 对应关系为 bean name --> bean instance
*/
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** 三级缓存，存放的是 ObjectFactory，可以理解为创建早期半成品bean的factory，最终添加到二级缓存
* 对应关系是 bean name --> ObjectFactory
*/
private final Map<String, Object> earlySingletonObjects =new ConcurrentHashMap<>(16);
singletonObject = singletonFactory.getObject();
从三级缓存 singletonFactories 获取。如果获取到，则通过其 #getObject() 方法，获取对象，那么是什么时候把缓存加入到singletonFactories呢？一直往下跟会发现在 #doCreateBean方法中，有这么一段代码：
// AbstractAutowireCapableBeanFactory.java
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));
}
//当一个 Bean 满足三个条件：单例、运行提前暴露bean、当前bean正在创建中，则调用#addSingletonFactory方法，将它添加到缓存中
// DefaultSingletonBeanRegistry.java
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 其实已经被创建出来了，但是它还不是很完美（没有进行属性填充和初始化），但是对于其他依赖它的对象而言已经足够了（可以根据对象引用定位到堆中对象），能够被认出来了。
20170912082357749.jpeg
- 首先 A 完成初始化第一步并将自己提前曝光出来（通过ObjectFactory 将自己提前曝光),在初始化的时候，发现自己依赖对象B，此时就会去尝试get(B)，这个时候发现B还没有被创建出来
- 然后 B 就走创建流程，在 B 初始化的时候，同样发现自己依赖 C，C 也没有被创建出来
- 这个时候 C 又开始初始化进程，但是在初始化的过程中发现自己依赖 A，于是尝试 get(A)，这个时候由于 A 已经添加至缓存中（一般都是添加至三级缓存 singletonFactories ），通过 ObjectFactory 提前曝光，所以可以通过 ObjectFactory#getObject() 方法来拿到 A 对象，C 拿到 A 对象后顺利完成初始化，然后将自己添加到一级缓存中
- 回到 B ，B 也可以拿到 C 对象，完成初始化，A 可以顺利拿到 B 完成初始化。到这里整个链路就已经完成了初始化过程了
循环依赖.png
