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)))); }