什么是循环依赖
循环依赖也是循环引用，就是两个或多个Bean之间存在依赖关系，形成闭环
当Spring容器在创建A时，会发现其引用了B,从而会去创建B。同样的，在创建B时，会先创建C,而在创建C时，又先去创建A。最后A、B和C之间相互等待，谁都没有创建成功。
如何检测到存在循环依赖
可以Bean在创建的时候给其打个标记，如果递归调用回来发现正在创建的话，即可说明循环依赖
如何解决
Spring的循环依赖的理论实际上是基于Java的引用传递，当我们获取到对象的引用时，对象的field属性是可以延后设置的（但是构造器必须是在获取引用之前）
在上篇文章讲解Bean的加载时，就使用到了循环依赖问题，但没有细讲。
在上文中也提到在依赖注入时有两个重要的方法。
- createBeanInstance: 实例化，其实也就是调用对象的构造方法实例化对象
- populateBean: 填充属性，这一步主要是多bean的依赖属性进行填充
Spring 仅为单例模式下的Bean进行循环依赖的解决，但没有为原型模式下的Bean提供解决方法，会直接报错。
要解决循环依赖问题应该从初始化过程入手，对于单例而言，在Spring整个生命周期内，有且只有一个对象，所以很容易想到这个对象应该存放在Cache中，Spirng为了解决单例模式下的循环依赖问题，使用了三级缓存
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/** Cache of singleton objects: bean name --> bean instance */
private final Map singletonObjects = new ConcurrentHashMap<>(256); /** Cache of singleton factories: bean name --> ObjectFactory */
private final Map> singletonFactories = new HashMap<>(16); /** Cache of early singleton objects: bean name --> bean instance */
private final Map earlySingletonObjects = new HashMap<>(16);
- singletonFactories: 一级缓存，用于存放完全初始化好的bean
- earlySingletonObjects：二级缓存，存放原始的bean对象（还没有填充属性），用于解决循环依赖
- singletonFactories: 三级缓存，存放bean工厂对象，用于解决循环依赖
在getSingleton()中对单例bean的获取时就考虑到循环问题的解决。
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
Object singletonObject = this.singletonObjects.get(beanName);
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) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
先解释一下中间代码的一个判别方法 isSingletonCurrentlyInCreation(beanName)
它会判断当前的单例bean是否正字创建中，也就是还没有初始化完成。
比如：A的构造器依赖了B对象所以要先去创建B对象，或者在Ade populateBean过程中依赖了B对象，也要先去创建B对象，此时的A就是处于创建中的状态。
在整个过程中，Spring会先从一级缓存singletonObjects中尝试获取缓存的bean,如果没有，
则从二级缓存earlySingletonObjects中获取。
如果还没有且允许可以从singletonFactories中通过getObjects获取对象时，
则从三级缓存singletonFactories中获得该bean的工厂类，并通过getObjects（）方法获取到。
如果从第三缓存中获取到，则需要将该bean从singletonFactories移除，并加入到earlySingletonObjects中，也就说该bean从第三缓存降到了第二缓存。
此时，可能会有疑问，那个第三缓存中的bean的factory类是什么时候创建存储的呢，实际上在上面文章中也有提到，在本文中再仔细讲解一下，加强前后的逻辑性。
在创建bean时会调用AbstractAutowireCapableBeanFactory.doCreateBean()：
中间这一一步：
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
/**
* getEarlyBeanReference(beanName, mbd, bean)方法：
* 对bean再一次依赖引用，主要应用SmartInstantiationAwareBeanPostProcessor
* 其中我们熟知的AOP就是在这里将advice动态织入bean中，若没有则直接返回bean，不做任何处理
*/
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
return exposedObject;
}
在 getEarlyBeanReference 函数中并没有太多的逻辑处理，或者说除了后处理器的调用外没有别的处理工作。