什么是循环依赖问题
循环依赖其实就是循环引用，也就是两个或则两个以上的bean互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A。
Spring 如何解决循环依赖问题
简而言之Spring使用三级缓存来解决循环依赖的问题，三级缓存如下所示：
/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
三级缓存分别为
-
singletonObjects：单例Bean缓存；
-
singletonFactories：单例Bean工厂缓存；
-
earlySingletonObjects：提前曝光的单例Bean缓存；
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;
}
获取单例Bean的大致过程如下：
- 首先从一级缓存singletonObjects中通过beanName获取单例bean；
- 若一级缓存中不存在该bean，并且isSingletonCurrentlyInCreation返回为true，那么通过earlySingletonObjects获取提前曝光的bean；
- 若二级缓存中不存在该bean，并且允许通过singletonFactories获取对象，那么通过工厂来创建bean。
isSingletonCurrentlyInCreation表示当前bean是否正在创建中，例如对象A通过构造函数依赖B，获取对象A在填充属性的过程中，发现通过成员变量的形式依赖对象B，那么需要先对B进行实例化，这种情况下，对象A的状态就是在正在创建中。
要理解Spring如何解决循环依赖问题，还需要了解Spring Bean的初始化过程，spring bean 的初始化大致可以分为如下过程
- 调用构造方法进行实例化；
- 填充对象属性；
- 通过init方法进行初始化
创建Bean的过程中，完成第一步骤，对象已经被生产出来了，只是对象缺失了一些属性，但是对象已经能够被引用了。
解决循环依赖的关键就是三级缓存，其中三级缓存singletonFactories是在方法addSingletonFactory中进行填充的，
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);
}
}
}
该方法被AbstractAutowireCapableBeanFactory类中的doCreateBean调用，那么在bean实例化之后，即调用了构造函数之后，singletonFactories已经被注册，通过singletonFactories，spring将未完整初始化的对象暴露出来，供其他类使用。
若对象A通过成员变量的形式依赖对象B，对象B通过循环依赖的形式依赖对象A，我们来看一下Spring解决循环依赖的步骤
- 对象A进行初始化，首先通过构造函数进行实例化，然后填充属性，发现依赖的对象B没有进行加载；
- 对象B进行初始化，首先通过构造函数进行实例化，然后填充属性，此时对象A以被提前暴露出来，对象B完成初始化；
- 对象A通过对象B完成属性填充，完成初始化。
通过spring解决循环依赖的原理，可以看出，对于相互通过构造函数产生的循环依赖是无法解决的，如对象A通过构造函数依赖对象B，同时对象B通过构造函数依赖对象A，此时Spring就无能为力了，因为对象A和对象B，都无法通过构造函数完成初始化来提前暴露自身。
