Spring源码-循环依赖源码解读
笔者最近无论是看书还是从网上找资料，都没发现对Spring源码是怎么解决循环依赖这一问题的详解，大家都是解释了Spring解决循环依赖的想法（有的解释也不准确，在《Spring源码深度解析》作者也是看别人的博客说明了一下），没有从源码的角度分析是怎么解决循环依赖的，笔者就把自己看源码的过程写一下。
写这一篇文章算是个引路的，Spring为了程序的健壮性做了大量分析校验，调用的方法繁多复杂，我这篇文章为读者清理出解决循环依赖的流程。
Spring中对象可以配置成单例模式也可配置为原型模式（原型模式很值得一看）。
Spring中可以通过构造函数注入、setter注入的方式来解决对象与对象间的依赖。
对象间的循环依赖只能配置单例、setter注入的方式来解决，其他方法就会报错，下面我们通过源码分析一下。
一、单例、setter注入解决循环依赖
假如有TestA、TestB、TestC三个对象，其中TestA依赖TestB，TestB依赖TestC，TestC依赖TestA。
下面具体通过代码分析Spring是如何解决单例通过Setter注入的循环依赖。
在org.springframework.beans.factory.support.DefaultSingletonBeanRegistry类中有几个集合类型的成员变量，用来做缓存用的需要特别留意，源码如下：
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
......
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);
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16));
......
}
上面的代码中：
singletonsCurrentlyInCreation：保存对象的BeanName，在创建对象之前就会把对象的beanName保存起来。
singletonFactories：保存对象的BeanName和创建bean的工厂AbstractAutowireCapableBeanFactory(ObjectFactory)，（对象的构造函数是在这一步完成的）
earlySingletonObjects：保存对象BeanName和对象的早期实例（ObjectFactory#getObject得到的对象）（此时对象还没注入属性），此时可以作为对象填充依赖。
singletonObjects：保存BeanName和bean的实例（此时对象已经完成了属性注入）
通过Spring获取testA对象：
通过Spring获取testA对象
ApplicationContext factory=new ClassPathXmlApplicationContext("classpath:applicationContext-beans.xml");
TestA testA = (TestA) factory.getBean("testA");
System.out.println(testA);
factory.getBean最终调用的是org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
下面看doGetBean源码：
protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
......
//重点1
Object sharedInstance = this.getSingleton(beanName);
......
if (mbd.isSingleton()) {
//重点2
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
//重点3
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
}
在上面源码中：
1、重点1：
//重点1 根据beanName试图从缓存中获取已经创建的对象，第一次进入是肯定返回null，这个函数放在后面解释。
2、重点2：
在//重点2中才是真正创建TestA对象的方法，下面是//重点2 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton的源码：
//重点2
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
......
//重点2-1
beforeSingletonCreation(beanName);
......
try {
//重点2-2
singletonObject = singletonFactory.getObject();
newSingleton = true;
}catch (IllegalStateException ex) {
......
}catch (BeanCreationException ex) {
......
}
finally {
//重点2-3
afterSingletonCreation(beanName);
} }
}
在//重点2-1中beforeSingletonCreation方法中只做了一件事，就是保存beanName到singletonsCurrentlyInCreation（注意），这个时候testA就保存在singletonsCurrentlyInCreation里面了，源码如下：
//重点2-1
protected void beforeSingletonCreation(String beanName) {
//this.singletonsCurrentlyInCreation.add(beanName)
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
在 //重点2-2 会调用 //重点3 。
3、重点3：
在//重点3中org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean调用doCreateBean，doCreateBean方法源码：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
......
//重点3-1
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");
}
//重点3-2
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
//重点3-3
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
......
}
在//重点3-1判断testA必须是单例，并存在在singletonsCurrentlyInCreation中，此时才会调用//重点3-2的addSingletonFactory方法，//重点3-2的addSingletonFactory方法源码，
//重点3-2
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) { //重点3-2-1
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName); this.registeredSingletons.add(beanName);
}
}
}
在上面的代码中有一个singletonFactory的参数，这个参数是//重点3-3调用getEarlyBeanReference得到的，getEarlyBeanReference返回的就是ObjectFactory对象，是完成构造方法的。
在//重点3-2-1 向singletonFactories添加 ObjectFactory（注意），这个时候，testA和testA的ObjectFactory对象保存在singletonFactories，并移除earlySingletonObjects（现在earlySingletonObjects里面并没有testA）。
执行完//重点3-2,发现testA依赖TestB对象，此时会递归调用getBean获取TestB，testB执行步骤和上面testA一样，然后testB依赖TestC，递归调用TestC，此时singletonFactories里面保存的数据如下：
testA -> ObjectFactory(TestA)
testB -> ObjectFactory(TestB)
testC -> ObjectFactory(TestC)
创建testC过程中执行完//重点3-2，发现依赖testA，此时会递归调用getBean获取TestA，这时候执行到//重点1，下面开始解析//重点1 Object sharedInstance = getSingleton(beanName);方法。
4、重点1：
下面是调用//重点1 getSingleton(beanName)，调用getSingleton(beanName, true)的源码：
//重点1
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) {
//重点1-1
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) { //重点1-2
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject); this.singletonFactories.remove(beanName);
}
}
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
在上面代码中isSingletonCurrentlyInCreation就是判断对象（testA）是否被保存过（在//重点2-1的时候testA就被保存了）
在//重点1-1中，从singletonFactories缓存中获取到ObjectFactory(TestA)，
在//重点1-2并通过模板模式获取TestA对象，保存在earlySingletonObjects缓存中，并移除singletonFactories中的testA，
此时testC获取到TestA的早期对象，可以注入TestA对象，自此TestC完成依赖注入，并把testC保存到singletonObjects中。
TestC创建完成，返回给testB，testB也算是完成了创建，然后返回给testA，自此循环依赖算是完成了。
总结：
单例的setter注入，会先把创建testA、testB、testC对象的ObjectFactory（对象工厂）保存在singletonFactories里面，然后testC依赖testA，那就从singletonFactories缓存中拿到testA的ObjectFactory，通过ObjectFactory的getObject获取TestA的对象，并保存在earlySingletonObjects缓存中，清除singletonFactories缓存中的testA，此时testC就可以获取earlySingletonObjects缓存中TestA的对象，完成注入TestA的过程。TestC对象创建完成就可以注入到TestB对象中，然后TestB注入到TestA中。
singletonsCurrentlyInCreation就是用来保存是否试图创建某个对象的beanName，不管有没有创建成功，为后来从singletonFactories缓存中或earlySingletonObjects缓存中取值做个标识。
二、单利、构造函数注入循环依赖
假如有TestA、TestB两个对象，TestA依赖TestB，TestB依赖TestA；
构造函数注入和setter注入的不同在于，构造函数注入无法先调用构造函数实例化对象，当TestA依赖TestB，会先把testA保存到singletonsCurrentlyInCreation中，然后getBean("testB")，然后把testB保存到singletonsCurrentlyInCreation中，发现TestB依赖TestA，然后再getBean("testA")，此时执行下面的代码（和模块一，重点2是同一块代码）：
//重点2 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton的源码：
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
//重点2-0
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
......
//重点2-1
beforeSingletonCreation(beanName);
......
try {
//重点2-2
singletonObject = singletonFactory.getObject();
newSingleton = true;
}catch (IllegalStateException ex) {
......
}catch (BeanCreationException ex) {
......
}
finally {
//重点2-3
afterSingletonCreation(beanName);
} }
}
在上面的代码中 //重点2-0 Object singletonObject = this.singletonObjects.get(beanName); 此时singletonObject为空会执行beforeSingletonCreation方法，源码如下：
//重点2-1
protected void beforeSingletonCreation(String beanName) {
//this.singletonsCurrentlyInCreation.add(beanName)
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
}
结果发现singletonsCurrentlyInCreation已经存在testA，抛出BeanCurrentlyInCreationException。
setter注入为什么不会执行这一步呢，因为setter注入中会实例化TestA、TestB保存在缓存中，所以在执行 //重点2-0 Object singletonObject = this.singletonObjects.get(beanName); 时 singletonObject 不为空，并不会执行beforeSingletonCreation所以不会保存。
三、原型模式下循环依赖
假如有TestA、TestB两个对象，TestA依赖TestB，TestB依赖TestA，当调用getBean("testA")时,会先把beanName（testA）保存到isPrototypeCurrentlyInCreation里面，发现TestA依赖TestB，就会去getBean("testB")，然后把beanName（testB）也保存到isPrototypeCurrentlyInCreation里面，此时TestB发现依赖TestA，去getBean("testA")时，发现isPrototypeCurrentlyInCreation已经存在testA，就会抛出BeanCurrentlyInCreationException异常，具体代码如下
factory.getBean最终调用的是org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean，
下面看doGetBean源码：
protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
......
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
......
}
//isPrototypeCurrentlyInCreation源码
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
Object curVal = this.prototypesCurrentlyInCreation.get();
return (curVal != null && (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}