目录
定义：
一个或多个Bean之间存在相互调用关系就会产生循环依赖。即：A调用B，B调用C，C调用A，这样会导致创建对象时依赖链过长，栈溢出。
循环依赖的后果：
环依赖可能会导致程序出现各种问题，比如编译错误、运行时错误、死锁等。因此，避免循环依赖是编写高质量软件的重要方面之一。
Spring为了解决循环依赖问题，引入了三级缓存，Bean的生命周期中我们可以知道Bean在实例化的时候会通过Bean的构造函数来实例化Bean和进行属性填充，所以就要在这一步之前对Bean进行一些操作。
一：三级缓存
解读源码流程之前，spring 内部的三级缓存逻辑必须了解，要不然后面看代码会蒙圈。
第一级缓存 ：singletonObjects，用于保存实例化、注入、初始化完成的 bean 实例；
第二级缓存 ：earlySingletonObjects，用于保存实例化完成的 bean 实例；
第三级缓存 ：singletonFactories，用于保存 bean 创建工厂，以便后面有机会创建代理对象。
这是最核心
执行逻辑为：
1、先从“第一级缓存”找对象a，有就返回，没有就找“二级缓存”；
2、找“二级缓存”，有就返回，没有就找“三级缓存”；
3、找“三级缓存”，a找到了，就获取对象，放到“二级缓存”，并把a从“三级缓存”移除。
下面是Bean中的三级缓存的过程源码：
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// Quick check for existing instance without full singleton lock
Object singletonObject = this.singletonObjects.get(beanName);
// 从一级缓存中获取
// 如果一级缓存里没有，且 Bean 正在创建中
// 就从二级缓存里获取
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
singletonObject = this.earlySingletonObjects.get(beanName);
// 二级缓存没有，就从三级缓存获取一个工厂
if (singletonObject == null && allowEarlyReference) {
synchronized (this.singletonObjects) {
// Consistent creation of early reference within full sin
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
// 能获取到工厂则创建 Bean
singletonObject = singletonFactory.getObject();
// 把实例存入二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
// 把工厂从三级缓存移除
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
1、大概的思路：
当我们需要创建 A 的的时候，会首先通过 Java 反射创建出来一个原始的 A，这个原始 A 可以简单理解为刚刚 new 出来还没设置任何属性的 A，此时，我们把这个 A 先存入到一个缓存池中。接下来给 A 的属性设置值和解决A A 的依赖，这时我们发现 A 依赖 B，那么就去创建 B 对象，结果创建 B 的时候，发现 B 依赖 A，那么此时就先从缓存池中取出来 A(半成品A，啥属性也没有) 先用着，然后继续 B 创建的后续流程，直到 B 创建完成后，将之赋值给 A，此时 A 和 B 就都创建完成了。
如下图：
注意：
这里拿到的半成品A是个引用对象，也就是说它是个地址，所以即使里面的属性赋值都没有做也没关系，后面运行调用时拿到的就是完整的A
2、执行过程：
A半完成：
我们在创建A的时候，会通过反射创建出原始的A，接下来检查一缓存中有没有Bean，如果没有，则首先向三级缓存中添加一条记录，记录的 key 就是当前 Bean 的 beanName，value 则是一个 Lambda 表达式 ObjectFactory，通过执行这个 Lambda 可以给当前 A 生成代理对象。然后如果二级缓存中存在当前 A Bean，则移除掉。
B完成：
这样，A的前半部分就完成了，接下来给A的各个属性赋值，赋值时发现需要B，就去创建B，B和A一样，经历到给属性赋值的阶段，发现需要A，就去一级缓存找A，找不到就去二级缓存，再去三级缓存，找到A的ObjectFactory，然后执行这里的 getObject 方法，这个方法在执行的过程中，会去判断是否需要生成一个代理对象，如果需要就生成代理对象返回，如果不需要生成代理对象，则将原始对象返回即可。
最后，把拿到手的对象存入到二级缓存中以备下次使用，同时删除掉三级缓存中对应的数据。这样 A 所依赖的 B 就创建好了。
A完成：
再去完善B，属性赋值，A也就完成了。
注：
这里的解决思路需要在有AOP的情况下才可以，这里的Bean有ObjectFactory对象，否则就只能用二级缓存来解决。
二级缓存的解决大体思路是一样的，不过要把A的半成品存放在二级缓存中，这样可以更早的被调用。
二：@Lazy
延迟加载可以通过将 bean 的依赖关系运行时进行注入，而不是在初始化阶段
@Service
public class AserviceImpl implements Aservice {
@Autowired
@Lazy
private Bservice bservice;
@Async
public void test(){
}
}
Lazy 延迟加载打破循环依赖，他会通过其它途径生成bservice 的lazy 的代理对象，不会去走创建B 的代理 对象 然后注入A 这套流程。这样创建A 的单例对象并放入到单例池中，B 的bean 在实例化后，注入A bean 属性就可以从单例池中加载到A 的真正的bean ，而不会出现bean 对象不一致的问题。
