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

Myth丶恋晨 2023-10-09 18:11 48阅读 0赞

## 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如何解决循环依赖问题 ###