一、介绍
循环引用，也可以叫做循环依赖，就是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
相关推荐
如上所述，Spring默认允许循环依赖，但如果不想让Spring处理循环依赖，可以通过`setAllowCircularReferences(false)`来关闭这个功能。这样，当检测到循环依赖时，Spring会抛出异常，而不是尝试解决。 ### 总结 ...
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
Spring循环依赖debug源码图
在Spring框架中，循环依赖是指两个或多个Bean之间形成相互引用的闭环，导致Spring容器在创建这些Bean时陷入无限递归。Spring提供了多种策略来处理这种情况，以确保正常完成Bean的初始化。以下将详细介绍Spring解决...
在Spring框架中，循环依赖（Circular Dependency）是指两个或多个bean之间形成了一种相互引用的关系，使得它们在初始化过程中无法独立完成实例化。在上述案例中，`AuthorService`依赖于`BookService`，而`...
spring bean循环依赖时序图详细的描述了spring的循环依赖关系，帮我们快速了解spring是如何优雅的进行处理的
Spring循环依赖.vsdx
在Spring Boot应用中，...通过理解循环依赖的原理，以及利用如重构、`@Lazy`注解和setter注入等解决方案，我们可以有效地避免和解决这类问题。在设计系统时，尽量减少或避免循环依赖，可以提高系统的可维护性和稳定性。
Spring三级缓存解决循环依赖.pdf
Spring Ioc 源码分析系列--自动注入循环依赖的处理 本篇文章主要讲解了 Spring ...本篇文章详细分析了 Spring Ioc 源码分析系列中自动注入循环依赖的处理机制，帮助读者更好地理解 Spring 框架的设计思想和实现机制。
总结起来，Spring通过早引用、惰性初始化和三级缓存策略处理Singleton bean的循环依赖，但对于Prototype bean，需要开发者自行处理。理解和掌握这些原理对于优化代码和避免潜在问题至关重要。建议读者亲自研究Spring...
Spring5.0源码深度解析之SpringBean循环依赖问题解决方案 Spring5.0源码深度解析之SpringBean循环依赖问题解决方案是指在Spring框架中如何解决Bean的循环依赖问题。在Spring框架中，Bean的循环依赖指的是两个或多个...
Spring 循环依赖解决过程详解 Spring 框架中循环依赖是一个常见的问题，它指的是两个或多个 Bean 之间存在的相互依赖关系，例如 A 依赖 B，B 依赖 A，这种情况下，Spring 需要解决这个循环依赖关系，以便正确地实例...
Spring框架中，循环依赖是指两个或多个Bean相互引用，形成一个环。这篇文章主要介绍了Spring循环依赖的解决办法。在Spring中，循环依赖可以分为两种场景：构造器的循环依赖和属性的循环依赖。 一、constructors的...
Spring框架在处理循环依赖问题上展现出了其卓越的性能和灵活性。循环依赖是软件设计中常见的问题，特别是在大型Java企业应用中，它可能导致系统僵死或者运行时异常。Spring通过三级缓存机制和AOP代理巧妙地解决了这...
Spring Bean 的循环依赖完全掌握 在 Spring 框架中，Bean 的循环依赖是指多个 Bean 之间存在...通过搞清楚这四个问题，我们可以明白 Spring Bean 的循环依赖是如何工作的，并且可以更好地理解 Spring 框架的核心机制。
Spring的3级缓存和循环引用机制是Spring框架中处理依赖注入的重要组成部分，尤其是在处理单例bean的循环依赖时显得尤为重要。以下是对这些概念的详细解释： **一、循环依赖** 在Spring中，循环依赖指的是两个或多...
Spring框架在处理依赖注入时，会遇到一个棘手的问题，那就是循环依赖。循环依赖是指两个或多个bean之间形成一个依赖闭环，导致它们无法被正常初始化。本文将详细讲解Spring如何解决这一问题，以及为何它仅支持单例...
SpringBean 循环依赖问题与解决方案 SpringBean 循环依赖问题是指在 Spring 框架中，多个 Bean 之间存在相互依赖关系，导致 Bean 创建失败或无法正确注入的问题。这种问题常见于大型项目中，特别是在复杂的业务系统...
循环依赖通常发生在两个或多个bean之间存在互相引用的情况。当Spring尝试通过依赖注入创建bean时，如果发现依赖链形成一个闭环，就会抛出`BeanCurrentlyInCreationException`异常。在涉及到动态代理的情况下，这个...