前言：在doCreateBean方法中还遗留一个问题没有分析：循环依赖。循环依赖在Spring中是非常重要的一个知识点，因此单独进行分析。
什么是循环依赖
循环依赖就是循环引用，两个或两个以上的bean互相引用对方，最终形成一个闭环。如A依赖B，B依赖C，C依赖A。如下图所示：
循环依赖其实就是一个死循环的过程，在初始化A的时候发现引用了B，则就会去初始化B，然后发现B又引用C，则又去初始化C，在初始化C的时候，再次发现C引用了A，则又去初始化A，这样就处于死循环，除非有终结条件。
Spring中循环依赖的场景有两种：
- 构造器循环依赖。
- setter循环依赖。
构造器循环依赖
表示通过构造器注入构成的循环依赖，此依赖是无法解决的，只能抛出BeanCurrentlyInCreationException异常。
setter循环依赖
表示通过setter注入方式构成的循环依赖，对于setter注入造成的循环依赖，Spring只解决单例模式下的循环依赖，对于其他作用域的循环依赖，则抛出BeanCurrentlyInCreationException异常。为什么Spring只解决单例模式下的循环依赖呢，这里首先了解下Spring的几个作用域。
Spring的scope作用域
- singleton：默认的scope，每个scope是singleton的bean都会被定义一个单例对象，该对象的生命周期与Spring IOC容器一致的（但在第一次注入时才会创建）。
- prototype：如果为bean的作用域为prototype，则每次注入时都会创建一个新的对象。
- request：bean被定义为在每个HTTP请求 中创建一个单例对象，也就是说在单个请求中都会复用这个单例对象。
- session：bean被定义为在一个session的生命周期内创建一个单例对象。
- application：bean被定义为在ServletContext的生命周期中复用一个单例对象。
- websocket：bean被定义为在websocket的生命周期中复用一个单例对象。
从上面对Spring中scope作用域的介绍，也可大致了解为什么Spring中只解决单例模式下的循环依赖了，因为其他作用域对象的生命周期并不与Spring IOC容器一致，并且最主要的一点是Spring并不会对除了单例模式的bean做缓存，因此Spring只能解决单例模式下的循环依赖。
具体循环依赖解决流程
首先在看bean的加载的入口，在doGetBean方法中有如下代码：
首先会根据beanName从单例bean缓存中获取，如果不为空，则直接返回，前面已经分析了该方法，这里再次提出来。
// DefaultListableBeanFactory
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中移除对应的
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
分析：
这里注意isSingletonCurrentlyInCreation函数，判断当前bean是否正在被创建，这里就是判断beanName是否在singletonsCurrentlyInCreation集合中，那么正在被创建的bean是合适添加进去的呢？还是在doGetBean方法中
// DefaultSingletonBeanRegistry
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
// 做同步
synchronized (this.singletonObjects) {
// 从缓存中检查一遍
// 因为singlton模式其实已经复用了创建的bean，所以该步骤必须检查
Object singletonObject = this.singletonObjects.get(beanName);
// 为空，开始进行加载
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 加载前置处理 其实就是打一个标记
beforeSingletonCreation(beanName);
// 首先将新的newSingleton设置为false
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 初始化bean
// 该过程其实是调用createBean()方法 这里是一个回调方法
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 一堆异常处理后，进行后置处理 移除标志
afterSingletonCreation(beanName);
}
// 新的bean 加入缓存中
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
分析：
注意第20行代码beforeSingletonCreation函数。
// DefaultSingletonBeanRegistry
protected void beforeSingletonCreation(String beanName) {
// 这里会添加到正在创建bean的集合中
// 注意第一个条件，如果存在，则为false，直接短路
// 只有当第一个条件不存在[false]时，才会去进行添加操作
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
分析：
这里就会将正在创建的beanName添加到singletonsCurrentlyInCreation，如果出现构造函数的循环依赖bean注入，则会在此处抛出BeanCurrentlyCreationException异常，具体可以跟着代码调试一把，就可以更清楚的知晓流程。
接下来继续回到单例模式的循环依赖中：
在加载bean时，首先从单例缓存中获取bean对象。
- 首先从单例缓存中获取bean对象，如果缓存中存在bean对象则直接返回（单例模式的bean在创建过程中会进行缓存[singletonObjects]）。
- 如果缓存中bean对象为空，且当前bean正在创建，则从earlySingletonObjects中获取。
- 如果earlySingletonObjects集合中不存在，且允许提前创建bean，则从singletonFactories中获取单例工厂，若singleFactory不为空，则通过getObject方法获取bean，并将bean对象加入到earlySingletonObjects集合中，然后从singleFactory集合中移除对应的单例工厂对象。
注意这里涉及到三个集合：
- singletonObjects （一级）单例对象 Cache
- earlySingletonObjects （二级）提前曝光的单例对象 Cache
- singletonFactories （三级）单例对象工厂 Cache
/**
* Cache of singleton objects: bean name to bean instance.
* 存放的是单例 bean 的映射。
* <p>
* 对应关系为 bean name --> bean instance
*/
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); /**
* Cache of singleton factories: bean name to ObjectFactory.<br/>
* 存放的是 ObjectFactory，可以理解为创建单例 bean 的 factory 。
* <p>
* 对应关系是 bean name --> ObjectFactory
*/
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); /**
* Cache of early singleton objects: bean name to bean instance.<br/>
* 存放的是早期的 bean，对应关系也是 bean name --> bean instance。
* <p>
* 它与 {@link #singletonFactories} 区别在于 earlySingletonObjects 中存放的 bean 不一定是完整。
* <p>
* 从 {@link #getSingleton(String)} 方法中，我们可以了解，bean 在创建过程中就已经加入到 earlySingletonObjects 中了。
* 所以当在 bean 的创建过程中，就可以通过 getBean() 方法获取。
* <p>
* 这个 Map 也是【循环依赖】的关键所在。
*/
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
这三个缓存集合就是解决Spring中循环依赖的所在，具体流程：
- 首先从一级缓存singletonObjects中获取，如果为null，且当前bean正在被创建，则从二级缓存earlySingletonObjects中获取，如果还是为null，且允许singletonFactories通过getObject获取，则从三级缓存singletonFactories中获取，如果得到，则将其加入二级缓存earlySingletonObjects中，并从三级缓存singletonFactories中移除对应的工厂对象(因为单例模式的bean只会被创建一次)，这样三级缓存就升级到二级缓存了，所以二级缓存存在的意义就是缓存三级缓存中ObjectFactory#getObject的执行结果，提前曝光单例Bean对象。
如果从单例缓存中得到bean对象，则会调用getObjectForBeanInstance方法进一步处理，因为从缓存中得到的bean是最原始的bean，并不一定是最终所需要的bean对象。
上面分析了从缓存中获取bean对象，但是缓存中的值是从什么地方添加进来的呢？如果你调试过源码会发现这样一段代码：
// AbstractAutowireCapableBeanFactory
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));// 当前单例bean是否正在被创建
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 提前将创建的bean实例加入到singletonFactories中
// 为了后期避免循环依赖
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
分析：
当一个bean满足三个条件，则会被加入到缓存中。三个条件如下：
- 单例。
- 运行提前暴露bean。
- 当前bean正在被创建中。
DefaultSingletonBeanRegistry#addSingletonFactroy
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);
}
}
}
分析：
- 如果单例缓存中不存在beanName，则将singletonFactory进行缓存[singletonFactories集合]，注意这里还有一个earlySingletonObjects.remove操作，该操作是删除二级缓存（提前曝光的单例对象bean），因为二级缓存是从三级缓存转换而来的，因此在对三级缓存[singletonFactories]进行缓存时，需要remove二级缓存。
- 这段代码发生在createBeanInstance方法之后，也就是说这个bean其实已经被创建出来了，但它还是不是很完美（没有进行属性填充和初始化），但是对于其他依赖它的对象而言已经足够了（可根据对象引用定位到堆中对象），能够被认出来。所以Spring解决setter构造依赖的关键，就是对bean进行提前曝光。
上面介绍的了三级缓存[singletonFactories]与二级缓存[earlySingletonObjects]的出处，接下来看一级缓存的出处：
在DefaultSingletonBeanRegistry#getSingleton函数中：
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
// 做同步
synchronized (this.singletonObjects) {
// 从缓存中检查一遍
// 因为singlton模式其实已经复用了创建的bean，所以该步骤必须检查
Object singletonObject = this.singletonObjects.get(beanName);
// 为空，开始进行加载
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 加载前置处理 其实就是打一个标记
beforeSingletonCreation(beanName);
// 首先将新的newSingleton设置为false
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// 初始化bean
// 该过程其实是调用createBean()方法 这里是一个回调方法
singletonObject = singletonFactory.getObject();
newSingleton = true;
} catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
} catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
} finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
// 一堆异常处理后，进行后置处理 移除标志
afterSingletonCreation(beanName);
}
// 新的bean 加入缓存中
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
分析：
这里关注第54行处：addSingleton函数。
// DefaultSingletonBeanRegistry
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
分析：
这里就是将bean加入一级缓存中[singletonObjects]，同时remove二级缓存和三级缓存中值，因为bean已经被创建成功了，二级缓存与三级缓存也就不需要了。
总结
从上面分析过程可以知道为什么Spring只解决单例模式下的循环依赖了吧？
- Spring只对单例模式的bean进行了提前暴光[singletonFactories]，这也是由于其他scope域bean的特性所致。
单例模式下循环依赖解决流程：
- 首先A完成初始化第一步并将自己提前曝光出来（通过 ObjectFactory 将自己提前曝光），A在初始化的时候，发现自己依赖对象 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完成初始化。到这里整个链路就已经完成了初始化过程了。
如果你看过《Spring源码深度解析》这本书，还能发现如下流程图：
注：看图说话，笔者最为喜欢！其实去亲身调试一下循环依赖的代码，可能会有更加深刻的认识。
by Shawn Chen，2019.04.29，下午。