深谈Spring如何解决Bean的循环依赖

Posted 2023-04-17 qian-fen

1. 什么是循环依赖

Java循环依赖指的是两个或多个类之间的相互依赖，形成了一个循环的依赖关系，这会导致程序编译失败或运行时出现异常。下面小岳就带大家来详细分析下Java循环依赖。

简单来讲就是：假设有两个人是：A和B，A想要向B借钱，但B需要先向A借钱。这种情况就形成了循环依赖关系，无法解决借钱的问题。

接下来小岳用一个代码案例再来跟大家具体讲讲什么是循环依赖：

假设有两个Java类：A和B，A类依赖于B类，而B类又依赖于A类，代码如下：

// A.java
public class A 
private B b;
public void setB(B b) 
this.b = b;



// B.java
public class B 
private A a;
public void setA(A a) 
this.a = a;

在这个例子中，类A和类B之间形成了循环依赖关系，因为它们互相依赖对方。 如果我们在运行时创建一个A对象和一个B对象，并且尝试将它们互相设置为对方的属性，程序就会陷入无限循环中。

其实Java循环依赖是一个非常常见的问题，因为当两个类之间相互依赖时，就可能出现这种情况。

解决这个问题的一种方法是通过重构代码来消除循环依赖关系，使得类之间的依赖关系变得更清晰。另一种方法是使用依赖注入框架，如Spring，它可以自动处理依赖关系并避免循环依赖问题。 无论使用哪种方法，消除循环依赖关系都是很重要的，以确保程序的正确性和稳定性。

现在大家知道什么循环依赖了吧，在理解这个概念之后，我们回到正题：为什么被Spring容器管理的Bean对象会出现循环依赖问题呢？ 请大家继续往下看吧

2. Spring Bean的循环依赖问题

大家都清楚，被Spring容器管理的对象叫做Bean，那么为什么这个Bean对象会出现循环依赖的问题呢？

目前我们想要理解Bean的循环依赖问题，首先我们需要将这个被Spring容器管理的对象Bean给吃透了，这样对我们后续的理解会有很大帮助的，所以接下来就跟小岳一起来了解Bean的创建过程吧！

2.1 Bean的创建过程

在计算机编程中，“Bean”通常是指一个Java对象，它包含一些属性和对这些属性进行操作的方法。
Bean对象通常用于传递数据和在不同的组件之间共享数据。下面是创建一个Java Bean的基本步骤：

● 创建一个Java类：创建一个Java类并给它一个有意义的名称，例如，“PersonBean”或“EmployeeBean”。这个类应该具有一些属性和方法，用于获取和设置这些属性。

● 定义属性：在类中定义属性，例如，如果创建一个“PersonBean”，则应该定义“name”、“age”、“address”等属性。每个属性应该有一个数据类型和一个可选的初始值。

● 创建getter和setter方法：为每个属性创建一个getter方法和一个setter方法。getter方法用于获取属性的值，setter方法用于设置属性的值。

● 实现Serializable接口：如果需要将Bean对象序列化或将其存储在会话或应用程序范围内，则应实现Serializable接口。

● 添加构造函数：可以添加构造函数来初始化Bean对象的属性。

● 添加其他方法：可以添加其他方法来执行与Bean对象相关的其他操作。

概念性的知识点看起来确实会有点枯燥哈，接下来我们上代码，通过代码案例来加深下大家的印象：

假设有一个人叫做 Mr. Bean，他想要创建一个 Java Bean。他首先需要定义一个类来表示这个 Bean，我们给这个类取个名字叫做MyBean。下面是这个类的代码：

public class MyBean 
private String name;
private int age;

public MyBean(String name, int age) 
this.name = name;
this.age = age;


public String getName() 
return name;


public void setName(String name) 
this.name = name;


public int getAge() 
return age;


public void setAge(int age) 
this.age = age;

上面的代码定义了一个具有name和age属性的类MyBean。这个类有一个构造函数，可以用来创建对象，并且有一些getter和 setter方法来访问和修改这些属性。

现在，Mr. Bean想要创建一个MyBean对象。他需要先创建一个MyBean类的实例，然后通过调用 setter方法来设置属性的值。下面是他的代码。

MyBean myBean = new MyBean("Mr. Bean", 30);
myBean.setName("Rowan Atkinson");
myBean.setAge(66);

上面的代码首先创建了一个MyBean类的实例，名字为"Mr. Bean"，年龄为 30。然后，它通过调用setName和setAge方法来修改对象的属性。现在，这个对象的名字为 "Rowan Atkinson"，年龄为 66。

最后，Mr. Bean可以在程序的其他地方使用这个MyBean对象，例如将它传递给其他方法或存储在一个集合中。

简单的总结下：其实创建一个 Java Bean 就像给一个人起名字和年龄一样简单。只需要定义一个类，给它添加一些属性和方法，然后使用它创建对象即可，是不是很简单~

好啦，清楚了Bean对象之后，我们就来看看为什么Spring Bean会产生循环依赖的问题？

2.2 为什么Spring Bean会产生循环依赖问题？

其实我们通过上面对于循环依赖以及Bean对象的一个初步认识，大家需要认识到一个问题，那就是：循环依赖问题是指在Spring容器中，两个或多个Bean互相依赖对方，导致无法成功创建Bean实例的情况。这种问题通常是由于Bean之间的依赖关系复杂或者设计不合理引起的。

假设有两个人，一个名叫Tom，一个名叫Jerry，他们非常喜欢一起玩。Tom想要拿到Jerry手中的玩具，而Jerry也想要拿到Tom手中的糖果。于是，他们决定互相交换，但是交换的条件是必须同时完成。Tom不会放开玩具，除非他拿到了糖果；而Jerry也不会放开糖果，除非他拿到了玩具。他们一直在互相等待，最终谁也没有得到自己想要的东西。

在Java代码中，循环依赖的问题通常是由于Bean之间的构造函数或者setter方法相互依赖造成的。例如，假设我们有一个名为UserService的Bean和一个名为UserRepository的Bean，UserService需要UserRepository来进行数据库操作，而UserRepository需要UserService来进行用户权限验证。这时，如果我们使用构造函数注入，代码可能会像这样：

public class UserService 
private final UserRepository userRepository;
public UserService(UserRepository userRepository) 
this.userRepository = userRepository;



public class UserRepository 
private final UserService userService;
public UserRepository(UserService userService) 
this.userService = userService;

这段代码就存在循环依赖问题，因为UserService依赖UserRepository，而UserRepository又依赖UserService，两者之间形成了一个环。

为了解决这个问题，Spring提供了几种解决方案，包括使用setter注入、使用@Autowired注解、使用@Lazy注解、使用@DependsOn注解等。这些解决方案可以打破Bean之间的循环依赖，确保Bean能够被成功创建。

总的来说，循环依赖问题是Spring容器中常见的问题之一，但是使用正确的解决方案，我们可以轻松地避免这个问题的出现。同时，也希望大家能够像Tom和Jerry一样，互相理解，积极协作，让软件开发变得更加愉快！

2.3 循环依赖问题

2.3.1 Spring不能解决的循环依赖问题

在这里小岳跟大家讲一个要点，一定要记住哦！

其实，Spring 并不能解决所有循环依赖的问题哦，接下来就带大家看看什么情况下的循环依赖是不可以被解决的吧。

为了解释 Spring 不能解决所有循环依赖问题，小岳给大家讲一个小故事。

有一次，程序员 A 和程序员 B 在讨论循环依赖的问题。A 说：“我有一个类 A，它依赖于类 B；而类 B 又依赖于类 A。这就是一个典型的循环依赖问题。” B 说：“这很简单，我们只需要用 Spring 解决它。” A 同意了，于是他们把代码放进 Spring 容器里，结果......程序报了一个栈溢出错误！为什么呢？因为 Spring 在解决循环依赖时需要使用栈来保存对象的创建过程，如果循环依赖链过长，就会出现栈溢出的情况。

在看完上述的小故事后，小岳给大家带来一个简单的代码案例，它展示了一个不能被 Spring 解决的循环依赖问题。假设有两个类 A 和 B，它们相互依赖。A 依赖于 B 的实例，而 B 又依赖于 A 的实例。代码如下：

public class A 
private B b;
public A(B b) 
this.b = b;



public class B 
private A a;
public B(A a) 
this.a = a;

如果我们将这两个类放进 Spring 容器中，代码如下：

@Configuration
public class AppConfig 
@Bean
public A a() 
return new A(b());


@Bean
public B b() 
return new B(a());

当我们启动应用程序时，Spring 会尝试创建 A 和 B 的实例。但是，当创建 A 的实例时，它需要一个 B 的实例，于是 Spring 开始创建 B 的实例。但是，当创建 B 的实例时，它需要一个 A 的实例，于是 Spring 又开始创建 A 的实例。这样就形成了一个无限循环的依赖关系，最终导致栈溢出错误。

最后小岳又要来啰嗦了，尽管 Spring 可以解决大部分的循环依赖问题，但是在某些特殊场景下，仍然会出现无法解决的循环依赖问题。 比如上面的 Java 代码案例中，如果 A 和 B 之间的依赖关系比较复杂，就可能出现无法解决的情况。在这种情况下，我们就需要手动来调整代码了哦，或者使用其他的依赖注入框架来解决循环依赖问题。

说到这里肯定会有很多朋友说，你介绍了不能解决的，能不能吧能解决的也讲讲啊！当然可以，接下来就给大家总结下，Spring能解决什么场景下的循环依赖问题吧！

2.3.2 Spring能解决的循环依赖问题

构造器注入循环依赖：

我们可以通过将其中一个bean作为参数传递给另一个bean的构造函数，Spring可以在bean创建过程中进行解决。经常有人问：为什么Java开发人员都喜欢Spring？因为Spring可以帮助他们摆脱循环依赖的困扰啊。下面是小岳给大家带来的代码案例，大家认真学习哦！

public class A 
private B b;
public A(B b) 
this.b = b;



public class B 
private A a;
public B(A a) 
this.a = a;



@Configuration
public class AppConfig 
@Bean
public A a(B b) 
return new A(b);


@Bean
public B b(A a) 
return new B(a);

属性注入循环依赖：

通过使用Setter方法注入属性，Spring可以在bean创建过程中进行解决。搞笑的笑话：为什么程序员不喜欢循环依赖？因为它们像两个人彼此依赖却都不敢先开口。Java代码案例：

public class A 
private B b;
public void setB(B b) 
this.b = b;



public class B 
private A a;
public void setA(A a) 
this.a = a;



@Configuration
public class AppConfig 
@Bean
public A a() 
return new A();


@Bean
public B b() 
return new B();


@Autowired
public void setDependencies(A a, B b) 
a.setB(b);
b.setA(a);

Spring提供了多种方式来解决循环依赖问题，其中就包括构造器注入和属性注入。大家要记住使用Spring可以让我们更加轻松地处理循环依赖问题，提高开发效率哦！

现在关于循环依赖的问题，大家都了解的差不多了吧，大家跟着小岳就继续向下学习吧！

3. Spring如何解决循环依赖问题？

通过上文我们了解到了什么是循环依赖、为什么会产生循环依赖以及Spring能解决哪些循环依赖问题和不能解决哪些循环依赖问题，讲了这么多，最后我们就把咱们标题中的问题：Spring如何解决Bean循环依赖问题给大家做做总结吧：

在上述小岳带大家学习的过程中，大家都清楚了Spring是一个流行的Java框架，它提供了许多功能来帮助开发人员构建应用程序。其中一个重要功能是处理Bean之间的依赖关系。在Java应用程序中，可能会出现循环依赖的情况，这意味着两个或多个Bean之间互相依赖，形成了一个循环。这会导致应用程序无法正常启动或出现其他问题。Spring提供了一种机制来解决Bean之间的循环依赖。

当然为了让大家身临其境的学习这个问题，给大家讲几个笑话，让大家放松放松吧！

大家知道为什么计算机工程师总是困在电梯里？因为他们总是按下Ctrl-Alt-Del!

大家可能觉得有点冷哈，大家继续向下看吧！小岳来给大家解释解释这个笑话：

这个笑话其实就涉及到了一个循环依赖的问题。当你按下Ctrl-Alt-Del组合键时，你会发现计算机似乎卡住了。 这是因为按下这个组合键会触发一个系统操作，但是系统操作本身可能依赖于其他进程或程序，而这些进程或程序又依赖于系统操作。这就形成了一个循环依赖，导致系统无法继续执行。在这种情况下，我们需要打破循环依赖，以便系统可以正常工作。

这下大家明白了吗？是不是觉得没有那么枯燥啦！学习也可以很快乐的嘛！

很早之前我跟我的程序员好朋友咨询过一个问题：“为什么我总是在创建Bean时遇到了循环依赖的问题啊？好烦啊！”然后，我内个朋友回答：“因为你不善于解耦啊！”这个时候我还没太明白，就问他这是什么意思了，结果人家给我来句：“解耦就是像男女朋友一样，互相喜欢但是不会互相依赖。”这一句话直接给我当时干懵，不知道大家理解不！欢迎讨论哦！

其实为了解决这个循环依赖问题啊，Spring提供了这几种方式，大家跟着小岳继续来看吧！

● 方法一： 通过构造函数注入避免循环依赖问题

● 方法二： 使用@Lazy注解标记懒加载的Bean，延迟创建bean实例，以避免在创建bean的时候出现循环依赖

● 方法三： 使用@Autowired注解的属性或者构造函数参数

下面小岳带大家身临其境的理解一番Bean 循环依赖的问题：

两个 Bean 相互依赖，所以它们相互打了个招呼：

Bean 1: “你好，我需要 Bean 2 的帮助。”

Bean 2: “你好，我需要 Bean 1 的帮助。”

结果，它们都无法创建，并抛出 BeanCreationException 异常。

接下来我们使用一段代码案例来解释一番：

假设有两个类，A 和 B，它们互相依赖。如果 A 和 B 都使用构造函数注入，它们之间就会发生循环依赖。

class A 
private B b;

public A(B b) 
this.b = b;



class B 
private A a;

public B(A a) 
this.a = a;

这段代码就会抛出 BeanCreationException异常，主要是因为Spring无法解决 A 和 B 的循环依赖。

为了解决这个问题，我们可以使用 @Autowired注解在属性或者构造函数参数上来解决循环依赖。修改上面的代码如下：

class A 
@Autowired
private B b;


class B 
@Autowired
private A a;

这样，Spring 就能够正确地创建 A 和 B 实例，从而避免了循环依赖问题。

最后小岳给大家总结下，Spring 中解决 Bean 循环依赖问题的方法包括构造函数注入、使用@Lazy注解懒加载和@Autowired注解属性或者构造函数参数。在编写代码时应尽量避免循环依赖，如果无法避免，就可以使用上述方法来解决问题哦！

4. 总结

至此，Spring如何解决Bean的循环依赖问题就给大家解释完了，现在大家都记住了吗？最后把今天的重点给大家复习总结一下哦！

4.1 什么是循环依赖？

● 循环依赖是指两个或多个模块或对象之间互相依赖的情况。当一个模块或对象依赖另一个模块或对象时，循环依赖就会发生。例如，模块A依赖模块B，同时模块B又依赖模块A，这就是循环依赖的一种情况。

● 循环依赖可能会导致程序出现各种问题，比如编译错误、运行时错误、死锁等。因此，避免循环依赖是编写高质量软件的重要方面之一。

● 为了避免循环依赖，开发者需要优化模块或对象之间的依赖关系，可以通过重新设计代码结构或引入中间层来实现。另外，使用依赖注入、反转控制等技术也可以减少循环依赖的发生。

4.2 Spring如何解决循环依赖问题

● 方法一： 通过构造函数注入避免循环依赖问题

● 方法二： 使用@Lazy注解标记懒加载的Bean，延迟创建bean实例，以避免在创建bean的时候出现循环依赖

● 方法三： 使用@Autowired注解的属性或者构造函数参数

Spring是如何解决循环依赖的？

参考技术A

你需要我，我需要你就是循环依赖

在Spring中使用的三级缓存来解决循环依赖问题，这里的缓存其实就是Map对象

当获取一个Bean时会先从缓存中查找是否有相应的Bean。

1 创建A实例

2 将A实例（半初始化，属性没有填充）暴露放入缓存中

3 填充A实例的属性

4 A实例属性依赖B对象

5 创建B对象实例

6 填充B实例属性

7 B实例属性依赖A对象

8 将上面已经暴露到三级缓存中的A对象注入给B实例

在获取A对象的时候执行上面27.1中的getSingleton方法，会将三级缓存中A这个半初始化状态的对象移除，将其存入到二级缓存中。

9 B实例Bean的创建工作继续执行初始化方法

B如果需要AOP代理？最终B对象是个代理对象。B到此就完全的初始化完了，B的依赖对象A此时是个半初始化状态的对象

10 B实例对象保存到一级缓存

最终B实例创建，初始化都执行完后会将自身加入到一级缓存同时清除二级，三级缓存

11 A实例Bean创建继续执行

如果B是被AOP代理的那么此时的A实例注入的B对象就是一个代理对象。

12 A实例Bean执行初始化方法

13 A继续执行上面的10步骤

三级缓存解决问题：循环依赖+AOP问题

只用一，二级缓存：

从上面罗列的步骤看似乎很是完美解决了循环依赖问题，接下来我们看看加入AOP的场景

假如A，B两个对象最终都是要被AOP代理的

执行到这里，A中依赖的B是代理对象没有问题，但是B中依赖的A对象是原始对象；这就不正确了应该依赖的A也必须是代理对象才是。

引入三级缓存：

三级缓存引入了ObjectFactory对象，在获取对象的时候，是调用ObjectFactory#getObject方法。

而这个getObject方法的实现实际执行的是getEarlyBeanReference方法，再来回顾下：

在创建实例时先将其存入三级缓存中：

getEarlyBeanReference方法就是提前创建代理对象

如果开启了AOP代理后

通过getEarlyBeanReference方法提前创建代理对象。这样就解决了循环依赖时AOP代理问题。保证获取的都是同一个对象。

其实引入三级缓存还解决了一个问题就是延迟代理对象的创建，如果不应用ObjectFactory方式那么我们需要不管需不需要都要先创建代理对象，而引入ObjectFactory可以在注入的时候先暴露的是ObjectFactory只有在调用getObject方法的时候才去创建真正的代理对象（避免了所有Bean都强制创建代理对象）。当没有被代理时可以直接返回原始对象，如果被代理会提前创建代理对象。

不用二级直接是用一，三级缓存？

假设场景：A 依赖 B，B 依赖 A、C，C 依赖 A

如果这样会出现不同的代理对象，每次调用getObject都会创建不同的代理对象（在上面的场景中如果只用一，三级缓存那么 B 依赖 A会通过getObject获取一个代理对象Proxy$1，接着注入C的时候 C中又依赖A，那这时候又从getObject获取对象那么返回的将又会是一个新的代理对象Proxy$2；在这个过程中A对象就出现了2个不一样的对象了，这肯定是错误的）。而引入二级缓存也就解决了这个问题。只有二级缓存没有的时候才从三级缓存汇总获取（如果需要则创建代理对象，然后保存到二级缓存中，二级缓存中已经是提前创建了代理对象（如果需要代理））。

当一个Bean完全的创建完以后放入一级缓存中，此时会吧二级三级中的缓存清除。

完毕！！！！

SpringMVC参数统一验证方法
SpringBoot多数据源配置详解
SpringCloud Nacos 整合feign
Spring AOP动态代理失效的解决方法@Transactional为何会失效
SpringBoot配置文件你了解多少？
SpringBoot邮件发送示例 Springboot面试题整理附答案
SpringBoot项目查看线上日志
在Spring Cloud 中你还在使用Ribbon快来试试Load-Balancer
SpringBoot分库分表sharding-sphere3