Spring解决循环依赖源码分析

本文基于spring4.3.9

什么是循环依赖

在spring中一个bean依赖另外一个bean有两种方式，一是通过构造函数，二是通过字段注入。
用代码来解释循环依赖，那么就是以下场景

public class A{
  @Autowired
  B b;  

}

public class B{
  @Autowired
  A a;  

}

或者

public class A{
   public A(B b){
   }
}

public class B{
   public B(A a){
   }
}

也可以是

public class A{
   public A(B b){
   }
}

public class B{
  @Autowired
  A a;  
}

如何解决

循环依赖只存在于singleton类型bean之间

对于构造函数循环依赖的情况，spring无能为力，在获取bean前spring中会通过下面代码抛出异常

    protected void beforeSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

singletonsCurrentlyInCreation会保存当前正在构造中的beanName，错误产生逻辑大概如下:

1. 我们向BeanFactory获取A类型的bean
2. A类型bean准备构造，把beanName保存到singletonsCurrentlyInCreation
3. A类型通过构造函数实例化，依赖B类型的Bean，向BeanFactory请求B类型Bean
4. B类型bean准备构造，把beanName保存到singletonsCurrentlyInCreation
5. B类型通过构造函数实例化，依赖A类型的Bean，向BeanFactory请求A类型Bean
6. 在DefaultSingletonBeanRegistry#getSingleton#beforeSingletonCreation方法的检查singletonsCurrentlyInCreation是否已经包含当前请求的beanName，抛出异常

而对于字段注入类型或者字段注入和构造函数混合的循环依赖，spring通过缓存解决这个问题。因为其中一个对象是可实例化的！！

我们以字段注入类型的循环依赖为例

1. 我们向BeanFactory获取A类型的bean
2. A类型bean实例化，把未初始化的自己放到缓存中
3. A类型bean进行构造(populdateBean)，触发了依赖注入B
4. 我们向BeanFactory获取B类型的bean
5. B类型bean实例化，把未初始化的自己放到缓存中
6. B类型bean进行构造(populdateBean)，触发了依赖注入A
7. 从二级缓存中获取到未初始化的A
8. B类型bean进行初始化，返回给第3步的A进行依赖注入
9. A类型bean进行初始化
10. 返回给调用getBean的方法

这个缓存我们称它为三级缓存，它的代码如下，会在doGetBean的开头被调用

//DefaultSingletonBeanRegistry#getSingleton
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //singletonObjects 第一级缓存，BeanFactory的单例全存在singletonObjects中
    //保存的是已经初始化完全的单例
    Object singletonObject = this.singletonObjects.get(beanName);
            //isSingletonCurrentlyInCreation=true，代表beanName所代表的bean循环依赖了
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            //第二级缓存，保存的是未初始化完全的单例(只是实例化)
            singletonObject = this.earlySingletonObjects.get(beanName);
            //allowEarlyReference在当前场景下，默认为true
            if (singletonObject == null && allowEarlyReference) {
                //第三级缓存，不是真的缓存，缓存的是生成二级缓存的工厂方法
                ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    //通过三级缓存构造二级缓存
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

在我们实例化bean之后，会把获取当前bean的方式放入到三级缓存

//AbstractAutowireCapableBeanFactory#doCreateBean
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");
    }
    //添加三级缓存
    addSingletonFactory(beanName, new ObjectFactory