目录
什么是循环依赖
概念
spring中多个bean互相引用
图示
代码示例
@Component
public class BeanA {
@Autowired
private BeanB beanB;
}
@Component
public class BeanB {
@Autowired
private BeanA beanA;
}
spring如何解决循环依赖？
注意
下属两种情况未解决循环依赖问题：
1.构造器注入
2.非单例
这个不用记，只是提一下。
言归正传，先说结论
用了一个map（这个map也就是常说的第三级缓存）：
不管有没有aop，都只用了这个map解决循环依赖。
你可能看其他资料说在有aop的情况下，使用了二级缓存来解决循环依赖，我认为这是错误的。
接下来会详解三级缓存，看完就明白为什么错了。
三级缓存介绍
// 1级缓存：属性赋值完成的bean，可以被spring拿来用了
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 2级缓存：调用3级缓存后，临时存放（不是每个bean都会调用第3级缓存的）
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
// 3级缓存：每个bean都会用到，在初始化bean之后，注入依赖前，会加入该map
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
源码简单分析
源码流程图
图1 循环依赖流程图
上面这幅图是某书里的，比较简洁，我再具体描述一下（暂时不讨论AOP，下文会说到）：
- 0.从缓存查找beanA，没有
- 1.初始化beanA（没有注入beanB）
- 2.beanA加入第3级缓存
- 3.populate()，开始填充beanB
- 3.0 从缓存查找beanB,没有
- 3.1 初始化beanB
- 3.2 beanB加入第3级缓存
- 3.3 poputele(),开始填充beanB
- 3.3.0 从缓存查找 beanA，发现beanA在创建中，于是可以掏出3级缓存，进行beanA的创建(注意，如果beanA被代理的话，其代理对象也是这一步创建的）
- 3.3.1 beanA创建完后，移动到第2级缓存（还没注入属性beanB）
- 3.4 beanB中的属性beanA注入完成
- 4 beanA中的属性beanB注入完成
详解循环依赖
上面的流程，应该算比较容易理解的。
大致意思就是：创建beanA的时候发现依赖beanB，于是创建beanB，此时又发现依赖beanA，于是又去创造beanA。
那么这是不是死循环了呢？
所以我们先看看循环终止条件：
循环终止条件在此方法里
看懂这个方法就能理解循环依赖了。
下面详细讲一下：
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从1级缓存拿
Object singletonObject = this.singletonObjects.get(beanName);
// 1级缓存拿不到，则去2级缓存拿
// 不要忽略isSingletonCurrentlyInCreation这个方法，得益于这个方法，我们才能终止循环，下文会详解
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从2级缓存拿
singletonObject = this.earlySingletonObjects.get(beanName);
// 从3级缓存拿.注意，如果allowEarlyReference是false，则不会进入
if (singletonObject == null && allowEarlyReference) {
// 则从3级缓存加载，最后移动到2级缓存
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 调用3级缓存，getEarlyBeanReference(beanName, mbd, bean)
singletonObject = singletonFactory.getObject();
// 放入2级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
上述代码我加了注释，应该比较容易理解，但是两个要注意的点：
1.isSingletonCurrentlyInCreation（循环终止条件判断）
如下图，如果一个bean存在于该set中，则开始调用第3级缓存中的方法，产生bean。
那beanName是什么时候加入这个set的呢？
在createBean之前()，会先将beanName添加进该set中，代表这个bean正在被创建。
这也就能理解，为什么spring创建bean的代码会像下图这样，用：（注意这个getSingleton和上面那个不一样，是重载方法）：
可能有人看不太懂这个写法，如下图，这是个函数式接口，里面只有一个方法：getObject()。
调用getObject()即可调用上图的createBean()。
下图中的beforeSingletonCreation()，就是set.add()的步骤。
而singletonFactory.getObject就会调用上图中的createBean()
那么使用set，来终止循环依赖，像不像一道经典算法题：
如何判断一个链表(或者图)成环？
2.allowEarlyReference
boolean类型的变量，
注意，
根据上面的代码，只有allowEarlyReference为true，才能调用第3级缓存！
而调用完第3级缓存，马上会移动到第2级缓存！
知道你们懒得回去翻，我直接再copy一次：
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 从1级缓存拿
Object singletonObject = this.singletonObjects.get(beanName);
// 1级缓存拿不到，则去2级缓存拿
// 不要忽略isSingletonCurrentlyInCreation这个方法，得益于这个方法，我们才能终止循环，下文会详解
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 从2级缓存拿
singletonObject = this.earlySingletonObjects.get(beanName);
// 从3级缓存拿.注意，如果allowEarlyReference是false，则不会进入
if (singletonObject == null && allowEarlyReference) {
// 则从3级缓存加载，最后移动到2级缓存
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 调用3级缓存，getEarlyBeanReference(beanName, mbd, bean)
singletonObject = singletonFactory.getObject();
// 放入2级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
而只有一个地方该参数是true：
其实这个调用的地方，再往上翻就回到了本小节最开头提到的地方（循环终止条件）：
所以这就说明了，当递归创建bean的时候，如果发现成环了，那么就开始调用第三级缓存。
所以并不是所有的bean都会用到第3级缓存，甚至只是少数bean才会用到。
那么为什么我要强调第3级缓存被调用的地方呢？
下面慢慢分析：
详解3级缓存
因为很多人理解上存在误区，觉得每个bean在创建的时候都要依赖第3级缓存，其实不是的，只有某条引用链上的尾结点（也就是头结点，循环引用嘛，最终会形成一个环形的依赖）才会通过第3级缓存创建bean，并在创建完后迅速移动到第2级缓存。
具体地说：
第3级缓存：保存了创建bean的方法。可以简单理解为：
如果待创建的bean：
（1）没有被aop代理的情况下，singletonFactory.getObject()调用map中的方法，返回原对象
（2）存在被aop代理的情况下,singletonFactory.getObject()会生成并返回代理对象。
通过第3级缓存创建出来的对象，直接就会移动到第2级缓存。
直接上图吧，可能会更清晰一些(不考虑aop)：
那么如果考虑aop。就比较复杂了。
下面分两种情况讨论：
比如A–>B–>C–>A
1.某条引用链尾结点存在aop(A节点有aop代理)
2.引用链中间节点存在aop(B或者C有aop代理)
为什么我要分两种情况呢？
因为这两者创建代理的时机是不一样的，很多资料说2级缓存是用来解决aop的，这种说法不全对。因为：
暂停一下，请翻开spring 5.0.x源码，找到
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
上图的exposedObject=bean，bean就是用构造器造出来的（当然也有别的创建方式，可以点进上面的方法进去看看）半成品对象。
暂停结束
如果是case 1：创建代理的时机就是我们上文讨论的一大篇。也就是用第3级缓存创建，然后转移到第2级缓存。这个时机其实是在populate(beanB)中就完成的。
但是还有问题，exposedObject和2级缓存中的对象，不是一个对象呀！是的，所以这种情况下，会执行上图中的第3步，从2级缓存拿beanA的代理对象，并替换原来创建的beanA。
如果是case 2：假设是beanB吧，创建代理的时机，是在上图中的第2步。这个第2步里面会执行很多aware以及BeanPost方法。
这个其实很简单，因为至始至终，代理beanB都没有用到2、3级缓存。
所以解答一个喜欢被问的面试题：
spring可不可以只用2级缓存（只用2个map）？
答：我觉得可以，首先分两种情况：
case2不必多说，当然可以，这缓存我们都没用过，简直是摆设。
在case1的情况下，我们是不是可以在创建代理对象的时候，也就是调用第3级缓存后，直接丢到第1级缓存去呢？
