循环依赖

定义

什么是循环依赖？循环依赖就是循环引用，就是两个或者多个bean相互之间的持有对方，比如TestA引用TestB，TestB引用TestC，TestC引用TestA，这样它们最终反映为一个环。这里需要强调一点，此情形不是循环调用，循环调用是方法之间的环调用。循环引用如下图：

循环调用是无法解决的，除非有终结条件，否则就是死循环，最终导致内存溢出错误。

Spring如何解决循环依赖

Spring容器循环依赖包括构造器循环依赖和setter循环依赖，Spring是如何解决这些循环依赖的呢？首先让我们定义循环引用类：

public class TestA {

    private TestB testB;

    public  TestA(TestB testB){
        this.testB = testB;
    }

    public TestA(){

    }

    public TestB getTestB() {
        return testB;
    }

    public void setTestB(TestB testB) {
        this.testB = testB;
    }
}

public class TestB {
    private TestC testC;

    public  TestB(TestC testC){
        this.testC = testC;
    }
    public TestB(){

    }

    public TestC getTestC() {
        return testC;
    }

    public void setTestC(TestC testC) {
        this.testC = testC;
    }
}

public class TestC {

    private TestA testA;

    public  TestC(TestA testA){
        this.testA = testA;
    }

    public TestC(){

    }

    public TestA getTestA() {
        return testA;
    }

    public void setTestA(TestA testA) {
        this.testA = testA;
    }
}

（1）构造器循环依赖

表示通过构造器注入构成的循环依赖，此依赖是无法解决的，只能抛出BeanCurrentlyInCreationException 异常表示循环依赖。

你想：在创建TestA类时，发现构造器需要TestB，那就去创建TestB，在创建TestB的时候又发现需要TestC，则又去创建TestC，最终在创建TestC时发现又需要TestA，这样就形成了一个环，没有办法创建。

我们先通过一个直观的测试用例来进行分析：

    <bean id="testA" class="com.joe.mytag.circle.TestA">
        <constructor-arg index="0" ref="testB"/>
    </bean>

    <bean id="testB" class="com.joe.mytag.circle.TestB">
        <constructor-arg index="0" ref="testC"/>
    </bean>

    <bean id="testC" class="com.joe.mytag.circle.TestC">
        <constructor-arg index="0" ref="testA"/>
    </bean>

建立测试类：

 public static void main(String[] args){
        try{
            new ClassPathXmlApplicationContext("spring.xml");
        }catch (Exception e){
            //因为要在创建时抛出
            e.printStackTrace();
        }
    }

输出结果：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'testB' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'testC' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'testC' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'testA' while setting constructor argument; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'testA': Requested bean is currently in creation: Is there an unresolvable circular reference?
。。。。。。

可以看出抛出了异常。

针对上述代码进行分析：

　　❤ Spring容器创建"testA" bean，首先去“当前创建bean池”查找是否当前bean正在创建，如果没发现，则继续准备其需要的构造器参数“testB”，并将“testA”标识符放到“当前创建bean池”；

　　❤ Spring容器创建“testB” bean，首先去“当前创建bean池”查找是否当前bean正在创建，如果没发现，则继续准备其需要的构造器参数“testC”，并将“testB”标识符放到“当前创建bean池”；

　　❤ Spring容器创建“testC” bean，首先去“当前创建bean池”查找是否当前bean正在创建，如果没发现，则继续准备其需要的构造器参数“testA”，并将“testC”标识符放到“当前创建bean池”；

　　❤ 到止为止Spring容器要去创建“testA” bean，发现该bean标识符在“当前创建bean池”中，表示循环依赖，抛出 BeanCurrentlyCreationException。

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

（2）setter循环依赖（默认方式：单例）

表示通过setter注入方式构成的循环依赖。对于setter注入造成的依赖是通过Spring容器提前暴露刚完成构造器注入但未完成其他步骤（如setter注入）的bean来完成的，而且只能解决单例作用域的bean循环依赖。先来看一张Spring中bean的实例化步骤图：

从图中可以看出：Spring是将bean实例化之后，再设置对象属性的。，此时的对象A还没有完成属性注入，属于早期对象，此时Spring会将这个实例化结束的对象放到一个Map中，并且Spring提供了获取这个未设置属性的实例化对象引用的方法。

 还是先通过直观的测试来进行分析：

修改配置文件为：

    <bean id="testA" class="com.joe.mytag.circle.TestA">
        <property name="testB" ref="testB"/>
    </bean>

    <bean id="testB" class="com.joe.mytag.circle.TestB">
        <property name="testC" ref="testC"/>
    </bean>

    <bean id="testC" class="com.joe.mytag.circle.TestC">
        <property name="testA" ref="testA"/>
    </bean>

 测试：

public static void main(String[] args){
        try{
            ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
            System.out.println(context.getBean("testA", TestA.class));

        }catch (Exception e){
            e.printStackTrace();
        }
    }

输出结果：

com.joe.mytag.circle.TestA@e25b2fe

发现，没有报错，分析一下上面代码的执行步骤：

　　❤  Spring容器创建单例“testA” bean，首先根据无参构造器创建bean，并暴露一个“ObjectFactory”用于返回一个提前暴露一个创建中的bean，并将“testA”标识符放到“当前创建bean池”，然后通过setter注入“testB”；

　　❤ Spring容器创建单例“testB” bean，首先根据无参构造器创建bean，并暴露一个“ObjectFactory”用于返回一个提前暴露一个创建中的bean，并将“testB”标识符放到“当前创建bean池”，然后通过setter注入“testC”；

　　❤ Spring容器创建单例“testC” bean，首先根据无参构造器创建bean，并暴露一个“ObjectFactory”用于返回一个提前暴露一个创建中的bean，并将“testC”标识符放到“当前创建bean池”，然后通过setter注入“testA”，在进行注入“testA”时由于提前暴露了“ObjectFactory”工厂，从而使用它返回提前暴露一个创建中的bean。

　　❤ 最后再依赖注入“testB”和“testC”，完成setter注入。

对于“singleton”作用域bean，可以通过“setAllowCircularReferences(false)”，来禁止循环引用。

（3）setter方式原型（prototype）

 还是按照通过测试类来直观的进行分析：

将配置文件修改为：

　　<bean id="testA" class="com.joe.mytag.circle.TestA" scope="prototype">
        <property name="testB" ref="testB"/>
    </bean>

    <bean id="testB" class="com.joe.mytag.circle.TestB" scope="prototype">
        <property name="testC" ref="testC"/>
    </bean>

    <bean id="testC" class="com.joe.mytag.circle.TestC" scope="prototype">
        <property name="testA" ref="testA"/>
    </bean>

scope="prototype" 意思是：每次请求都会创建一个实例对象。两者的区别是：有状态的bean都使用Prototype作用域，无状态的一般都使用singleton单例作用域。

测试类与上一致，这里就不贴代码了，测试结果：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'testA' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'testB' while setting bean property 'testB'; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'testB' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'testC' while setting bean property 'testC'; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'testC' defined in class path resource [spring.xml]: Cannot resolve reference to bean 'testA' while setting bean property 'testA'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'testA': Requested bean is currently in creation: Is there an unresolvable circular reference?

发现报错了。

那为什么原型模式就报错了呢？

　　对于“prototype”作用域的bean，Spring容器无法完成依赖注入，因为“prototype”作用域的bean，Spring容器不对其进行提前暴露一个创建中的bean。

参考：《Spring源码深度解析》 郝佳 编著：

转载于:https://www.cnblogs.com/Joe-Go/p/10155338.html