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 implementsSingletonBeanRegistry {
......private final Map singletonObjects = new ConcurrentHashMap(256);private final Map> singletonFactories = new HashMap(16);private final Map earlySingletonObjects = new HashMap(16);private final Set 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 doGetBean(String name, Class requiredType, final Object[] args, boolean typeCheckOnly) throwsBeansException {
......//重点1
Object sharedInstance = this.getSingleton(beanName);
......if(mbd.isSingleton()) {//重点2
sharedInstance = getSingleton(beanName, new ObjectFactory() {
@Overridepublic Object getObject() throwsBeansException {try{//重点3
returncreateBean(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);throwex;
}
}
});
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 voidbeforeSingletonCreation(String beanName) {//this.singletonsCurrentlyInCreation.add(beanName)
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {throw newBeanCurrentlyInCreationException(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, finalObject[] 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() {
@Overridepublic Object getObject() throwsBeansException {//重点3-3
returngetEarlyBeanReference(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, booleanallowEarlyReference) {
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 voidbeforeSingletonCreation(String beanName) {//this.singletonsCurrentlyInCreation.add(beanName)
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {throw newBeanCurrentlyInCreationException(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 doGetBean(String name, Class requiredType, final Object[] args, boolean typeCheckOnly) throwsBeansException {
......if(isPrototypeCurrentlyInCreation(beanName)) {throw newBeanCurrentlyInCreationException(beanName);
}
......
}//isPrototypeCurrentlyInCreation源码
protected booleanisPrototypeCurrentlyInCreation(String beanName) {
Object curVal= this.prototypesCurrentlyInCreation.get();return (curVal != null && (curVal.equals(beanName) || (curVal instanceof Set && ((Set>) curVal).contains(beanName))));
}
382
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
