什么是循环依赖
循环依赖其实是循环引用，也就是两个或则两个以上的 bean 互相持有对方，最终形成闭环。比如A依赖于B，B依赖于C，C又依赖于A。如下图所示：
注意，这里不是函数的循环调用，是对象的相互依赖关系。循环调用其实就是一个死循环，除非有终结条件。
Spring 中循环依赖场景有：
- 构造器的循环依赖
- field 属性的循环依赖
对于构造器的循环依赖，Spring 是无法解决的，只能抛出 BeanCurrentlyInCreationException 异常表示循环依赖，所以下面我们分析的都是基于 field 属性的循环依赖。
Spring 只解决 scope 为 singleton 的循环依赖，对于scope 为 prototype 的 bean Spring 无法解决，直接抛出 BeanCurrentlyInCreationException 异常。
如何检测循环依赖
检测循环依赖相对比较容易，Bean 在创建的时候可以给该 Bean 做标记，如果递归调用回来发现正在创建中的话，即说明了循环依赖了。
解决循环依赖
我们先从加载 bean 最初始的方法 doGetBean() 开始，该方法位于 AbstractBeanFactory 类中。
在 doGetBean() 中，首先通过 transformedBeanName(name)获取 beanName，然后调用 DefaultSingletonBeanRegistry 类中 getSingleton()方法，该方法会根据 beanName 从单例 bean 缓存中获取，如果不为空则直接返回。
protected Object getSingleton(String beanName, boolean allowEarlyReference) { Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) { synchronized(this.singletonObjects) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null && allowEarlyReference) { ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName); if (singletonFactory != null) { singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } return singletonObject; } 复制代码
这个方法主要是从三个缓存中获取，分别是：singletonObjects、earlySingletonObjects、singletonFactories，三者定义如下：
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); 复制代码
它们就是 Spring 解决 singleton bean 的关键因素所在，被称为三级缓存，第一级为 singletonObjects，第二级为 earlySingletonObjects，第三级为 singletonFactories。这里我们可以通过 getSingleton() 看到他们是如何配合的，在分析该方法之前，提下其中的 isSingletonCurrentlyInCreation() 和 allowEarlyReference。
isSingletonCurrentlyInCreation()：判断当前 singleton bean 是否处于创建中。即是否包含在 singletonsCurrentlyInCreation 中。bean 处于创建中也就是说 bean 在初始化但是没有完成初始化，有一个这样的过程其实和 Spring 解决 bean 循环依赖的理念相辅相成，因为 Spring 解决 singleton bean 的核心就在于提前曝光 bean。- allowEarlyReference：从字面意思上理解就是允许提前拿到引用。其实真正的意思是是否允许从 singletonFactories 缓存中通过 getObject()拿到对象，为什么会有这样一个字段呢？原因在于 singletonFactories 才是 Spring 解决 singleton bean 的诀窍所在，这个我们后续分析。
getSingleton() 整个过程如下： 首先从一级缓存 singletonObjects 中获取，如果没有且当前指定的 beanName 正在创建，就再从二级缓存中 earlySingletonObjects 获取，如果还是没有获取到且 allowEarlyReference 为 true，则从三级缓存 singletonFactories 中获取指定 beanName 对应的 singletonFactory，如果获取到则通过 singletonFactory# getObject() 获取对象，并将其加入到二级缓存 earlySingletonObjects 中，然后从三级缓存 singletonFactories 中删除获取到的 singletonFactory。如下：
singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName); 复制代码
这样就从三级缓存升级到二级缓存了。
上面是从缓存中获取，但是缓存中的数据从哪里添加进来的呢？继续查看 doGetBean()中的代码 一直往下跟会发现有这么一段代码：
if (mbd.isSingleton()) { sharedInstance = this.getSingleton(beanName, () -> { try { return this.createBean(beanName, mbd, args); } catch (BeansException var5) { this.destroySingleton(beanName); throw var5; } }); bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } 复制代码
其中 createBean()就是用来创建 bean 的，其详细定义在 AbstractAutowireCapableBeanFactory 类中，我们主要为了查询缓存中的数据是怎么添加进来的，所以这里对于代码不进行过多的分析，后续章节会对其进行讲述。在 createBean()方法中有个 doCreateBean() 方法，当中有这么一段代码：
boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName); if (earlySingletonExposure) { if (this.logger.isTraceEnabled()) { this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } this.addSingletonFactory(beanName, () -> { return this.getEarlyBeanReference(beanName, mbd, bean); }); } 复制代码
如果 earlySingletonExposure == true 的话，则调用 addSingletonFactory() 将他们添加到缓存中，但是一个 bean 要具备如下条件才会添加至缓存中：
- 单例
- 运行提前暴露 bean
- 当前 bean 正在创建中
其中 allowCircularReferences 属性用来设置是否在 bean 之间允许循环引用，并自动尝试解决它们，默认值为 true。
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); } } } 复制代码
从这段代码我们可以看出 singletonFactories 这个三级缓存才是解决 Spring Bean 循环依赖的诀窍所在。同时这段代码发生在 createBeanInstance() 方法之后，也就是说这个 bean 其实已经被创建出来了，但是它还不是很完美（没有进行属性填充和初始化），但是对于其他依赖它的对象而言已经足够了（可以根据对象引用定位到堆中对象），能够被认出来了，所以 Spring 在这个时候选择将该对象提前曝光出来让大家认识认识。
该段代码添加 singletonFactory 到三级缓存中时，且会删除二级缓存中 beanName 对应的内容，这个逻辑不是很清楚，在测试案例中进行调试的时候也没发现什么端倪，如果有大神了解这部分的逻辑，望不吝赐教。
介绍到这里我们发现三级缓存 singletonFactories 和 二级缓存 earlySingletonObjects 中的值都有出处了，那一级缓存在哪里设置的呢？在类 DefaultSingletonBeanRegistry 中可以发现这个 addSingleton() 方法，源码如下：
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 的链路中有哪个地方引用呢？在 doGetBean() 处理不同 scope 时，如果是 singleton，则调用 getSingleton()，如下：
if (mbd.isSingleton()) { sharedInstance = this.getSingleton(beanName, () -> { try { return this.createBean(beanName, mbd, args); } catch (BeansException var5) { this.destroySingleton(beanName); throw var5; } }); bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } 复制代码
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) { Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { //.... try { singletonObject = singletonFactory.getObject(); newSingleton = true; } //..... if (newSingleton) { addSingleton(beanName, singletonObject); } } return singletonObject; } } 复制代码
至此，Spring 关于 singleton bean 循环依赖已经分析完毕了。所以我们基本上可以确定 Spring 解决循环依赖的方案了：Spring 在创建 bean 的时候并不是等它完全完成，而是在创建过程中将创建中的 bean 的 ObjectFactory 提前曝光（即加入到 singletonFactories 缓存中），这样一旦下一个 bean 创建的时候需要依赖 bean ，则直接使用 ObjectFactory 的 getObject() 获取了，也就是 getSingleton()中的代码片段了。
实例分析
新建三个 bean 类，相互之间构成引用关系。
Person类
public class Person { private String name; private AbstractCar car; private String desc; public String getName() { return name; } public void setName(String name) { this.name = name; } public AbstractCar getCar() { return car; } public void setCar(AbstractCar car) { this.car = car; } public String getDesc() { return desc; } public void setDesc(String desc) { this.desc = desc; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", 拥有一辆car=" + car + '}'; } } 复制代码
AbstractCar 类
public class AbstractCar { private String brand ; private Money money; public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public Money getMoney() { return money; } public void setMoney(Money money) { this.money = money; } @Override public String toString() { return "AbstractCar{" + "brand='" + brand + '\'' + ", money=" + money + '}'; } } 复制代码
Money 类
public class Money { private String classification; private Person person; public String getClassification() { return classification; } public void setClassification(String classification) { this.classification = classification; } public Person getPerson() { return person; } public void setPerson(Person person) { this.person = person; } @Override public String toString() { return "Money{" + "classification='" + classification + '\'' + ", person=" + person.getName() + '}'; } } 复制代码
beans.xml 文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="car" class="com.msdn.bean.AbstractCar" p:brand="宝马" p:money-ref="money" /> <bean id="person" class="com.msdn.bean.Person" p:name="herish" p:car-ref="car" /> <bean id="money" class="com.msdn.bean.Money" p:classification="工资" p:person-ref="person" /> </beans> 复制代码
测试代码
@Test public void cycleRely(){ ClassPathResource resource = new ClassPathResource("config/beans.xml"); BeanFactory beanFactory = new XmlBeanFactory(resource); Person person = (Person) beanFactory.getBean("person"); System.out.println(person); } 复制代码
运行结果为：
Person{name='herish', 拥有一辆car=AbstractCar{brand='宝马', money=Money{classification='工资', person=herish}}} 复制代码
分析
关于上述代码用图解的形式表示如下：
对测试代码进行调试，大概了解其中的逻辑跳转。首先是 beanFactory.getBean("person")，该方法最终会定位在 doGetBean("person")，执行 getSingleton(beanName, allowEarlyReference)返回结果为 null，继续向下执行，如果 scope 为 单例的情况下，执行 createBean(beanName, mbd, args)方法，具体实现在 AbstractAutowireCapableBeanFactory 类中，然后调用 doCreateBean()，在该方法中，createBeanInstance()方法会先初始化对象赋零值，然后在 addSingletonFactory()中将”person“添加到三级缓存中，接着在 populateBean()方法中给对象添加属性内容，该部分的关键代码为 applyPropertyValues()方法，当发现有一个 Car 的引用属性，然后在 BeanDefinitionValueResolver 类中的 resolveValueIfNecessary()方法内跳转到 resolveReference()，进而调用 doGetBean("car")方法。
同上述过程一致，进而调用 doGetBean("money")方法，因为 Monery 类中有对 Person 的引用，所以最后又会执行 doGetBean("person")方法。关于这点就像递归调用一样，我们假设最初的 doGetBean("person")为第一层，则最后的为第四层，我们接下来要做的就是不断返回到上一层。此时 beanFactory 关于缓存的结果为：
再次进入到 getSingleton(beanName, allowEarlyReference)方法时，二级缓存中会添加”person“，三级缓存并删除它。接着会执行 getObjectForBeanInstance()方法，然后返回 person 对象。
在 DefaultSingletonBeanRegistry 类中的 registerDependentBean()方法会记录 bean 之间的引用关系，然后返回第三层，在第三层的 populateBean()执行完毕之后，最后 doCreateBean()方法会返回这样的结果：
在 createBean()执行结束后，接着会执行 getSingleton(beanName,singletonFactory)，该方法会将 money 对象加入到一级缓存中。在返回 money 对象后，返回第二层。第二层返回结果为：
将 car 对象加入到一级缓存之后，来到了第一层。第一层返回结果为：
然后将 person 对象加入到一级缓存中，再把 singletonsCurrentlyInCreation 清空。最后得到的 beanFactory 结果为：
到这里，关于 Spring 解决 bean 循环依赖就已经分析完毕了。最后来描述下就上面那个循环依赖 Spring 解决的过程(A为person，B为car，C为money)：首先 A 完成初始化第一步并将自己提前曝光出来（通过 ObjectFactory 将自己提前曝光），在初始化的时候，发现自己依赖对象 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 完成初始化。到这里整个链路就已经完成了初始化过程了。
备注：测试案例也尝试了将 bean 之间的关系设置为依赖关系，但是执行结果报错。
参考文献
https://www.cnblogs.com/java-chen-hao/p/11139887.html
