理解Spring循环引用(循环依赖)

一、介绍 循环引用,也可以叫做循环依赖,就是A类依赖了B类,B类又依赖A类,比如下面这种情况: class A { private B b; public B getB() { return b; } public void setB(B b) {...

一、介绍

循环引用,也可以叫做循环依赖,就是A类依赖了B类,B类又依赖A类,比如下面这种情况:

class A {

private B b;

public B getB() {

return b;

}

public void setB(B b) {

this.b = b;

}

}

class B {

private A a;

public B(A a) {

this.a = a;

}

public A getA() {

return a;

}

}

在Spring容器中,可以通过依赖注入的方式,将A注入给B,同时也将B注入给A,那么这时在该容器中,A和B就存在循环依赖。当存在循环依赖的时候,某些情况下Spring可以正确处理,某些情况下,Spring会抛出异常。下面就讲解一下什么情况可以正确处理,什么情况会抛出异常。

在开始介绍各种情况之前,首先要了解以下三个知识点:

Spring中依赖注入的方式有两种,属性注入与构造器注入。上面的代码中,类A就是通过属性注入的方式注入了B,类B是通过构造器注入的方式注入了A。

Spring中的bean根据作用域的不同,可以大体分为两类,singleton和prototype。singleton在一个容器中,只会有一个实例;而prototype在每次调用时,都会产生一个新的实例。

Spring中,单例bean有延迟加载和立即加载两种加载方式,其中立即加载模式会在容器启动的时候就创建bean,而延迟加载会在容器启动后,使用到bean的时候再加载它。本篇分析一律使用延迟加载,因为有时候单例bean的加载顺序,会影响到创建bean的成功或失败。

单利对象创建之初会保持引用,后面set的时候只要发现这个要set的有引用,不再创建只返回引用----打破循环创建,多例对象不会保存引用(保存引用就成了单利)--不保存引用后面set找不到之前创建的bean

引用者A自己创建,被注入bean这也会发起被注入的创建

A通过引用注入的bean,这个A可以先通过无参构造函数创建(保证自己被创建出来),然后由于引用创建bean的时候,无需等待这个bean的依赖创建好,直接用之前bean自己创建时保存的引用,最后依赖的可以最后通过引用信息找到然后set注入(懒加载用的时候注入),使用构造函数注入的bean,这个被注入的bean需要完全被创建好才可自己被创建好,这样就失败

默认函数创建对象的时候可以先不管对象中的引用属性是否准备好,用有参数构造方法创建的时候就需要,里面构造参数的注入的属性全部准备好才可完成本实例的创建

这里考虑延时加载情况

对于上述三点不了解的朋友,可以看一下Spring依赖、Spring作用域和Spring延迟加载。

二、循环依赖的bean都是通过构造器注入的情况

2.1 循环依赖的bean都是singleton

示例代码:

class A {

private B b;

public B getB() {

return b;

}

public A(B b) {

this.b = b;

}

}

class B {

private A a;

public A getA() {

return a;

}

public B(A a) {

this.a = a;

}

}

配置文件:

<bean id="singletonA" class="ccc.spring.circulardependencies.constructor.A" lazy-init="true">

<constructor-arg name="b" ref="singletonB"/>

</bean>

<bean id="singletonB" class="ccc.spring.circulardependencies.constructor.B" lazy-init="true">

<constructor-arg name="a" ref="singletonA"/>

</bean>

测试代码:

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

A a = (A) applicationContext.getBean("singletonA");

测试结果:

失败

org.springframework.beans.factory.BeanCreationException: 

Error creating bean with name 'singletonA' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'singletonB' while setting constructor argument; 

nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'singletonB' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'singletonA' while setting constructor argument; 

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

上面的代码中,singletonA和singletonB都是单例,并且通过构造器注入的方式依赖于对方,这种情况下获取任何一个bean的时候都会失败,Spring抛出BeanCreationException异常。

2.2 循环依赖的bean都是prototype

示例代码

和2.1节相同。

配置文件

<bean id="prototypeA" class="ccc.spring.circulardependencies.constructor.A" scope="prototype">

<constructor-arg name="b" ref="prototypeB"/>

</bean>

<bean id="prototypeB" class="ccc.spring.circulardependencies.constructor.B" scope="prototype">

<constructor-arg name="a" ref="prototypeA"/>

</bean>

测试代码

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

A a = (A) applicationContext.getBean("singletonA");

测试结果

失败

org.springframework.beans.factory.BeanCreationException: 

Error creating bean with name 'prototypeA' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'prototypeB' while setting constructor argument; 

nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'prototypeB' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'prototypeA' while setting constructor argument; 

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

该例中A和B都是prototype,并且通过构造器注入了对方。在获取bean的时候,同样抛出了BeanCreationException异常。

2.3 循环依赖的bean同时有singleton和prototype

实例代码

和2.1节相同。

配置文件

<bean id="mixSingletonA" class="ccc.spring.circulardependencies.constructor.A" lazy-init="true">

<constructor-arg name="b" ref="mixPrototypeB"/>

</bean>

<bean id="mixPrototypeB" class="ccc.spring.circulardependencies.constructor.B"  scope="prototype">

<constructor-arg name="a" ref="mixSingletonA"/>

</bean>

测试代码

先获取singleton的情况:

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

A a = (A) applicationContext.getBean("mixSingletonA");

先获取protytype的情况:

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

B b = (B) applicationContext.getBean("mixPrototypeB");

测试结果

先获取singleton的情况:

失败

org.springframework.beans.factory.BeanCreationException: 

Error creating bean with name 'mixSingletonA' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'mixPrototypeB' while setting constructor argument; 

nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'mixPrototypeB' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'mixSingletonA' while setting constructor argument; 

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

先获取protytype的情况:

失败

org.springframework.beans.factory.BeanCreationException: 

Error creating bean with name 'mixPrototypeB' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'mixSingletonA' while setting constructor argument; 

nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'mixSingletonA' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'mixPrototypeB' while setting constructor argument; 

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

该例中,mixSingletonA是singleton,mixPrototypeB是prototype,在Spring容器启动后,无论是先获得谁,获取bean都会失败,并抛出BeanCreationException。

2.4 小结

当循环依赖的bean都是通过构造器注入依赖的时候,无论这些bean是singleton还是prototype,在获取bean的时候都会失败。

三、循环依赖的bean都是通过属性注入的情况

3.1 循环依赖的bean都是singleton

示例代码

class A {

private B b;

public B getB() {

return b;

}

public void setB(B b) {

this.b = b;

}

}

class B {

private A a;

public A getA() {

return a;

}

public void setA(A a) {

this.a = a;

}

}

配置文件

<bean id="singletonA" class="ccc.spring.circulardependencies.field.A" lazy-init="true">

<property name="b" ref="singletonB"/>

</bean>

<bean id="singletonB" class="ccc.spring.circulardependencies.field.B" lazy-init="true">

<property name="a" ref="singletonA"/>

</bean>

测试代码

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

A a = (A) applicationContext.getBean("singletonA");

B b = (B) applicationContext.getBean("singletonB");

assertEquals(a, b.getA());

assertEquals(b, a.getB());

测试结果

运行成功。

该例中singletonA和singletonB都是singleton,并且通过属性注入的方式依赖对方,在Spring容器启动后,无论是先获得哪个bean,都会成功。

3.2 循环依赖的bean都是prototype

示例代码

和3.1节相同。

配置文件

<bean id="prototypeA" class="ccc.spring.circulardependencies.field.A" scope="prototype">

<property name="b" ref="prototypeB"/>

</bean>

<bean id="prototypeB" class="ccc.spring.circulardependencies.field.B" scope="prototype">

<property name="a" ref="prototypeA"/>

</bean>

测试代码

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

A a = (A) applicationContext.getBean("prototypeA");

测试结果

失败

org.springframework.beans.factory.BeanCreationException: 

Error creating bean with name 'prototypeA' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'prototypeB' while setting bean property 'b'; 

nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'prototypeB' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'prototypeA' while setting bean property 'a'; 

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

该例中,prototypeA和prototypeB都是protytype,并且通过属性注入的方式依赖对方,在Spring容器启动后,无论是先获得哪个bean,都会失败,并抛出BeanCreationException异常。

3.3 循环依赖的bean同时有singleton和prototype

示例代码

和3.1节相同。

配置文件

<bean id="mixSingletonA" class="ccc.spring.circulardependencies.field.A" lazy-init="true">

<property name="b" ref="mixPrototypeB"/>

</bean>

<bean id="mixPrototypeB" class="ccc.spring.circulardependencies.field.B" scope="prototype">

<property name="a" ref="mixSingletonA"/>

</bean>

测试代码

先获取singleton的情况:

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

A a = (A) applicationContext.getBean("mixSingletonA");

B b = (B) applicationContext.getBean("mixPrototypeB");

assertNotEquals(a.getB(), b);

assertEquals(b.getA(), a);

先获取protytype的情况:

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

expectedEx.expect(BeanCreationException.class);

B b = (B) applicationContext.getBean("mixPrototypeB");

测试结果

先获取singleton的情况:成功

先获取singleton的情况:失败

org.springframework.beans.factory.BeanCreationException: 

Error creating bean with name 'mixPrototypeB' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'mixSingletonA' while setting bean property 'a'; 

nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'mixSingletonA' defined in class path resource [ApplicationContext.xml]: Cannot resolve reference to bean 'mixPrototypeB' while setting bean property 'b'; 

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

该例中,mixSingletonA是singleton,mixPrototypeB是prototype,并且都通过属性注入的方式依赖的对方。

当容器启动后,如果先获取的是singleton,那么两个bean都能成功获得。但是如果先获取的是prototype,那么就会失败。注意本例中的mixSingletonA是延迟加载的,所以只有在真正获取该bean的时候Spring容器才会去创建bean。

3.4 小结

当循环依赖的bean都是通过属性注入依赖的时候,根据bean的作用域是singleton还是prototpye,会有不同的表现。

如果循环依赖的bean都是singleton,那么无论先获取哪个bean,都能成功。

如果循环依赖的bean都是prototype,那么无论先获取哪个bean,都会失败。

如果循环依赖的bean中有singleton,也有prototype,那么当先获取的那个bean是singleton时,就会成功,否则失败。

四、循环依赖的bean同时有属性注入和构造器注入的情况

当循环依赖的bean同时有属性注入和构造器注入的时候,情况有点多,就不一一详细,这里只介绍可以运行成功的情况。

4.1 循环依赖的bean都是singleton,且在容器启动后先去获取通过属性注入依赖的bean

实例代码

class A {

private B b;

public B getB() {

return b;

}

public A(B b) {

this.b = b;

}

}

class B {

private A a;

public A getA() {

return a;

}

public void setA(A a) {

this.a = a;

}

}

配置文件

<bean id="singletonA" class="ccc.spring.circulardependencies.mix.A" lazy-init="true">

<constructor-arg name="b" ref="singletonB"/>

</bean>

<bean id="singletonB" class="ccc.spring.circulardependencies.mix.B" lazy-init="true">

<property name="a" ref="singletonA"/>

</bean>

测试代码

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

B b = (B) applicationContext.getBean("singletonB");

A a = (A) applicationContext.getBean("singletonA");

assertEquals(a, b.getA());

assertEquals(b, a.getB());

测试结果

成功

该例中singletonA和singletonB都是单例,但是singletonA是通过构造器注入的singletonB,而singletonB是通过属性注入的singletonA。当Spring容器启动后,如果先获取singletonB就会成功。

4.2 循环依赖的bean有singleton和prototype,其中singleton是通过属性注入依赖,prototype是通过构造器注入依赖。在容器启动后先获取singleton。

实例代码

和4.1节相同。

配置文件

<bean id="mixPrototypeA" class="ccc.spring.circulardependencies.mix.A" scope="prototype">

<constructor-arg name="b" ref="mixSingletonB"/>

</bean>

<bean id="mixSingletonB" class="ccc.spring.circulardependencies.mix.B" lazy-init="true">

<property name="a" ref="mixPrototypeA"/>

</bean>

测试代码

ApplicationContext applicationContext =

new ClassPathXmlApplicationContext("ApplicationContext.xml");

B b = (B) applicationContext.getBean("mixSingletonB");

A a = (A) applicationContext.getBean("mixPrototypeA");

assertNotEquals(a, b.getA());

测试结果

成功

该例中mixPrototypeA是prototype,mixSingletonB都是singleton,但是mixPrototypeA是通过构造器注入的mixSingletonB,而mixSingletonB是通过属性注入的mixPrototypeA。当Spring容器启动后,如果先获取mixSingletonB就会成功。

五、结论

通过上面三节的例子来看,可以得出以下结论:

如果循环依赖的bean都是通过构造器注入依赖,那么不管它们是singleton还是prototype,都会失败。

如果循环依赖的bean都是prototype,那么不管它们是通过构造器注入依赖还是通过属性注入依赖,都会失败。

如果循环依赖的bean既有构造器注入也有属性注入,既有singleton也有prototype,在容器启动后,只有当获取的第一个bean是通过属性注入依赖的singleton时,才会成功,别的情况都会失败。

所以最终结论就是:

如果多个bean存在循环依赖,在Spring容器启动后,只有当获取的第一个bean是通过属性注入依赖的singleton时,才会成功,别的情况都会失败

六、分析

循环引用的bean之间必然会构成一个环,如下图所示,A、B、C之间构成了一个环形。

当Spring容器在创建A时,会发现其引用了B,从而会先去创建B。同样的,创建B时,会先去创建C,而创建C时,又先去创建A。最后A、B、C之间互相等待,谁都没法创建成功。

要想打破这个环,那么这个环中至少需要有一个bean可以在自身的依赖还没有得到满足前,就能够被创建出来(最起码要被实例化出来,可以先不注入其需要的依赖)。这种bean只能是通过属性注入依赖的类,因为它们可以先使用默认构造器创建出实例,然后再通过setter方法注入依赖。而通过构造器注入依赖的类,在它的依赖没有被满足前,无法被实例化。而且这个bean,还必须是singleton,不能是prototype。至于为什么不能是prototype呢,我们一起来回顾一下3.1节的例子:

3.1节中类A和类B都是通过属性注入依赖,并且他们都是singleton,配置文件如下:

<bean id="singletonA" class="ccc.spring.circulardependencies.field.A" lazy-init="true">

<property name="b" ref="singletonB"/>

</bean>

<bean id="singletonB" class="ccc.spring.circulardependencies.field.B" lazy-init="true">

<property name="a" ref="singletonA"/>

</bean>

Spring容器启动后,如果我们去获取singletonA,那么容器的操作步骤大致如下:

尝试创建bean singletonA,发现singletonA是singleton,且不是通过构造器注入依赖,那么先使用默认构造器创建一个A的实例,并保存对它的引用,并且将singletonA标记为“正在创建中的singleton”。然后发现singletonA依赖了singletonB,所以尝试创建singletonB。

尝试创建bean singletonB,发现singletonB是singleton,且不是通过构造器注入依赖,那么先使用默认构造器创建一个B的实例,并保存对它的引用,并且将singletonB标记为“正在创建中的singleton”。然后发现singletonB依赖了singletonA,所以尝试创建singletonA。

尝试创建singletonA,注意,这时Spring容器发现singletonA“正在创建中”,那么就不会再去创建singletonA,而是返回容器之前保存了的对singletonA的引用。

容器将singletonA通过setter方法注入到singletonB,从而singletonB完成创建。

容器将singletonB通过setter方法注入到singletonA,从而singletonA完成创建。

上述步骤,最重要的是第1步和第3步。在第1步中,容器会保存对singletonA的引用,在第3步中,再返回对singletonA的引用,从而可以成功创建那些依赖了singletonA的bean(本例中是singletonB)。这样,循环依赖的环就在singletonA这个点这里被打破。

那为什么prototype不能成为打破这个环的一个点呢?原因就在于Spring容器只会对singleton保存引用,而对于prototype,并不会对其保存引用,这就导致在第3步中并不能获得之前创建的bean(因为引用不到它)。

至于为什么容器不对prototype保存引用,那就涉及到singleton和portotpye的概念,如果也对prototype保存引用,那么其实它就变成了singleton。可以看一下Spring作用域。

按道理,在循环依赖的环里,只要有一个bean,是通过属性注入依赖,并且是singleton,那么这个环就可以被打破,无论获取他们的顺序是怎样。但是我们在第五节得出过结论“只有当获取的第一个bean是通过属性注入依赖的singleton时,才会成功”,为什么会这样呢?这就和Spring的实现有关了,当Spring容器遍历那些循环依赖的bean时,只要遍历到那种已经遍历过一次的bean,并且它们不是通过属性注入依赖的singleton时,就会直接抛出BeanCurrentlyInCreationException异常。

--------------------- 

原文:https://blog.csdn.net/chen2526264/article/details/80673598 

  • 发表于 2019-08-20 11:00
  • 阅读 ( 507 )
  • 分类:网络文章

条评论

请先 登录 后评论
不写代码的码农
小编

篇文章

作家榜 »

  1. 小编 文章
返回顶部
部分文章转自于网络,若有侵权请联系我们删除