Spring循环依赖处理分析

循环依赖就是N个类中循环嵌套引用，如果在日常开发中我们用new 对象的方式发生这种循环依赖的话程序会在运行时一直循环调用，直至内存溢出报错，如下图所示：

循环依赖的情况：

• 构造器参数依赖
• setter方式singleton单例
• setter方式prototype多例

1、构造器参数依赖

Spring容器会将每一个正在创建的Bean 标识符放在一个“当前创建Bean池”中，Bean标识符在创建过程中将一直保持在这个池中，因此如果在创建Bean过程中发现自己已经在“当前创建Bean池”里时将抛出
BeanCurrentlyInCreationException异常表示循环依赖；而对于创建完毕的Bean将从“当前创建Bean池”中清除掉。

public class StudentA {  
  
    private StudentB studentB ;  
  
    public void setStudentB(StudentB studentB) {  
        this.studentB = studentB;  
    }  
  
    public StudentA() {  
    }  
      
    public StudentA(StudentB studentB) {  
        this.studentB = studentB;  
    }  
} 
public class StudentB {  
  
    private StudentC studentC ;  
  
    public void setStudentC(StudentC studentC) {  
        this.studentC = studentC;  
    }  
      
    public StudentB() {  
    }  
  
    public StudentB(StudentC studentC) {  
        this.studentC = studentC;  
    }  
} 
public class StudentC {  
  
    private StudentA studentA ;  
  
    public void setStudentA(StudentA studentA) {  
        this.studentA = studentA;  
    }  
  
    public StudentC() {  
    }  
   
    public StudentC(StudentA studentA) {  
        this.studentA = studentA;  
    }  
}  

OK，上面是很基本的3个类，，StudentA有参构造是StudentB。StudentB的有参构造是StudentC，StudentC的有参构造是StudentA ，这样就产生了一个循环依赖的情况，我们都把这三个Bean交给Spring管理，并用有参构造实例化。

测试类：

public class Test {  
    public static void main(String[] args) {  
        ApplicationContext context = new ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");  
        //System.out.println(context.getBean("a", StudentA.class));  
    }  
}  

执行结果报错：

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException:   
    Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference? 

报错原因：
Spring容器先创建单例StudentA，StudentA依赖StudentB，然后将A放在“当前创建Bean池”中，此时创建StudentB,StudentB依赖StudentC ,然后将B放在“当前创建Bean池”中,此时创建StudentC，StudentC又依赖StudentA， 但是，此时Student已经在池中，所以会报错，，因为在池中的Bean都是未初始化完的，所以会依赖错误 ，（初始化完的Bean会从池中移除）

2、setter的singleton依赖

bean的生命周期如下图：

2.1缓存的定义

先看DefaultSingletonBeanRegistry关于缓存的定义

/** Cache of singleton objects: bean name --> bean instance */
private final Map singletonObjects = new ConcurrentHashMap(256);

/** Cache of singleton factories: bean name --> ObjectFactory */
private final Map> singletonFactories = new HashMap>(16);

/** Cache of early singleton objects: bean name --> bean instance */
private final Map earlySingletonObjects = new HashMap(16);
/** Names of beans that are currently in creation */
private final Set singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap(16));

功能介绍：

缓存	用途
singletonObjects	用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用
earlySingletonObjects	存放原始的 bean 对象（尚未填充属性），用于解决循环依赖
singletonFactories	存放 bean 工厂对象，用于解决循环依赖

可以把singletonObjects 看做一级缓存，bean创建时默认会先从singletonObjects中取bean，并且在创建后直接将对象放入singletonObjects中缓存；earlySingletonObjects看做二级缓存，在bean创建时提前将ObjectFactory暴露给singletonFactories，这样就可以在对象创建完成之前也可以获得对象的引用。

2.2bean创建的过程

实例化流程图如下：

从AbstarctBeanFactory的getBean开始，是个空壳方法，直接调用doGetBean(name, null, null, false)，该方法的分析如下(只分析了比较重要部分的代码，其他地方有所省略)：

protected  T doGetBean(
            final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
            throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean;

    // 在获取bean的时候优先从缓存中获取，对于新创建的对象，这里是无法获得值；对于依赖的对象，可能已经创建或者正在创建，
    //直接从缓存中获取，可以避免重复创建
    Object sharedInstance = getSingleton(beanName);①
    if (sharedInstance != null && args == null) {
        //判断你是否FactoryBean,如果是FactoryBean类型，则调用getObject方法注入的实际对象
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
        // 对于作用域为prototype的bean，每次请求都会创建一个实例对象，
        // 如果正在创建或已经创建，则异常，原因为：对于prototype作用域的bean，
        // Spring不会进行缓存，因此无法提前暴露一个创建中的bean
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        ...

        try {
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

            // 此处用于实例化bean的依赖，比如A依赖B，如果B还未实例化，则先实例化B；
            // 即调用getBean对B进行实例化
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    registerDependentBean(dep, beanName);
                    getBean(dep);
                }
            }

            // socpe="singleton"的情况
            if (mbd.isSingleton()) {
                // 此处的关键在于创建的匿名对象ObjectFactory及getObject方法，getObject为实际创建bean实例的地方
                sharedInstance = getSingleton(beanName, new ObjectFactory