Spring Framework循环依赖解决 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，各位观众老爷，欢迎来到今天的“Spring恋爱故事会”！今天我们要聊的，可不是什么霸道总裁爱上我的狗血剧情，而是Spring框架中一个让人头疼，但又不得不面对的“三角恋”——循环依赖！

开场白：缘，妙不可言，也可能很要命

在Spring的世界里，Bean就像一个个独立的个体，它们各有各的职责，各司其职。但有时候，它们之间会产生一些“化学反应”，彼此依赖，互相需要。这本来是好事，说明我们的应用模块化程度高，耦合紧密。但如果这种依赖变成了“你依赖我，我依赖他，他又依赖你”的死循环，那可就麻烦大了！这就像陷入了一个无解的三角恋，谁也离不开谁，谁也无法独立存在，最终导致整个系统崩溃。

第一幕：什么是循环依赖？“剪不断，理还乱”

让我们先来认识一下这位“三角恋”的主角——循环依赖。简单来说，循环依赖指的是两个或多个Bean之间相互依赖，形成一个环状依赖关系。

举个例子，假设我们有两个Bean：A 和 B。A 依赖 B，需要在 A 中注入 B 的实例；同时，B 也依赖 A，需要在 B 中注入 A 的实例。

@Component
public class A {

    @Autowired
    private B b;

    public A() {
        System.out.println("A 构造器");
    }

    public void doSomething() {
        System.out.println("A 调用 B 的方法：" + b.doSomethingElse());
    }
}

@Component
public class B {

    @Autowired
    private A a;

    public B() {
        System.out.println("B 构造器");
    }

    public String doSomethingElse() {
        return "B 正在工作，A 加油！";
    }
}

在这个例子中，A 的构造器需要 B 的实例，而 B 的构造器又需要 A 的实例。这就形成了一个死循环，Spring容器在创建Bean的时候会陷入无限循环，最终抛出 BeanCurrentlyInCreationException 异常。

第二幕：循环依赖的类型：三种“爱的姿势”

循环依赖可不是只有一种类型，根据依赖注入的方式，它可以分为三种：

构造器注入循环依赖（Constructor Injection）： 这是最常见，也是最难解决的一种循环依赖。就像上面 A 和 B 的例子，两个Bean的构造器互相依赖，Spring容器无法先创建其中任何一个Bean，导致循环依赖。
Setter注入循环依赖（Setter Injection）： 这种循环依赖相对容易解决一些。Spring容器可以先创建Bean的实例，然后再通过Setter方法注入依赖。
Field注入循环依赖（Field Injection）： 本质上和Setter注入类似，Spring容器也是先创建Bean的实例，然后再通过反射注入依赖。

为了更清晰地展示这三种类型，我们用一个表格来总结一下：

循环依赖类型	注入方式	解决难度	Spring解决方式	示例代码
构造器注入循环依赖	构造器	非常难	默认无法解决，会抛出 `BeanCurrentlyInCreationException` 异常。需要避免设计出这种依赖关系。	`java @Component public class A { private final B b; public A(B b) { this.b = b; } } @Component public class B { private final A a; public B(A a) { this.a = a; } }`
Setter注入循环依赖	Setter方法	较容易	Spring使用三级缓存解决。	`java @Component public class A { private B b; @Autowired public void setB(B b) { this.b = b; } } @Component public class B { private A a; @Autowired public void setA(A a) { this.a = a; } }`
Field注入循环依赖	字段	较容易	Spring使用三级缓存解决。	`java @Component public class A { @Autowired private B b; } @Component public class B { @Autowired private A a; }`

第三幕：Spring的三级缓存：拯救“三角恋”的秘密武器

Spring之所以能够解决Setter注入和Field注入的循环依赖，靠的是它的三级缓存。这就像一个“爱的缓冲带”，让Bean在创建过程中可以先“半成品”状态存在，等待依赖注入完成。

这三级缓存分别是：

一级缓存（singletonObjects）： 存放完整的、可以直接使用的单例Bean。
二级缓存（earlySingletonObjects）： 存放早期的Bean引用，这些Bean已经被创建，但是还没有完成属性注入。
三级缓存（singletonFactories）： 存放Bean工厂，用于创建早期的Bean引用。

Spring解决循环依赖的流程大致如下：

当Spring容器启动时，它会首先创建Bean A。
在创建Bean A的过程中，需要注入Bean B。
Spring容器发现Bean B还没有被创建，于是开始创建Bean B。
在创建Bean B的过程中，需要注入Bean A。
此时，Spring容器发现Bean A正在创建中，但是还没有完成。
Spring容器首先会从一级缓存中查找Bean A，如果找不到，则从二级缓存中查找，如果还找不到，则从三级缓存中查找。
如果三级缓存中存在Bean A的工厂，则使用该工厂创建一个早期的Bean A引用，并将其放入二级缓存中。
然后，将这个早期的Bean A引用注入到Bean B中。
Bean B创建完成后，将其放入一级缓存中。
返回到Bean A的创建过程，将Bean B注入到Bean A中。
Bean A创建完成后，将其放入一级缓存中。

简单来说，三级缓存的作用就是：当一个Bean正在创建中，但是需要依赖另一个正在创建中的Bean时，Spring容器可以先创建一个早期的Bean引用，并将其放入二级缓存中，以便其他Bean可以使用。等到这个Bean创建完成后，再将其放入一级缓存中。

第四幕：构造器注入循环依赖：无法挽回的“爱”？

但是，对于构造器注入的循环依赖，Spring默认是无法解决的。因为构造器是Bean创建的第一步，如果构造器需要依赖其他Bean，而这些Bean又依赖当前Bean，就会形成一个死锁。

想象一下，你和你的爱人手拉手，但是你们的手都被锁在了一起，谁也无法先松开手，那你们就永远无法分开，也无法做任何事情。这就是构造器注入循环依赖的困境。

第五幕：打破循环依赖：拯救“三角恋”的终极方案

既然循环依赖这么可怕，那我们应该如何避免或者解决它呢？这里有一些建议：

重新设计你的代码： 这是最根本的解决方案。仔细分析你的代码，看看是否存在不必要的依赖关系。尝试将一些Bean合并成一个，或者将一些功能提取到独立的组件中。
使用Setter注入或Field注入： 如果你无法避免循环依赖，那么尽量使用Setter注入或Field注入。这样Spring可以利用三级缓存来解决循环依赖。
使用@Lazy注解： 可以使用 @Lazy 注解来延迟Bean的初始化。这样，Spring容器会在真正需要使用Bean的时候才去创建它，从而打破循环依赖。

@Component
public class A {

    @Autowired
    @Lazy
    private B b;

    public A() {
        System.out.println("A 构造器");
    }

    public void doSomething() {
        System.out.println("A 调用 B 的方法：" + b.doSomethingElse());
    }
}

@Component
public class B {

    @Autowired
    @Lazy
    private A a;

    public B() {
        System.out.println("B 构造器");
    }

    public String doSomethingElse() {
        return "B 正在工作，A 加油！";
    }
}

使用@PostConstruct注解： 可以使用 @PostConstruct 注解来延迟Bean的初始化。 @PostConstruct 注解的方法会在Bean的构造器执行完成后执行。这样，我们可以在 @PostConstruct 注解的方法中注入依赖，从而打破循环依赖。

@Component
public class A {

    private B b;

    @Autowired
    public A(B b) {
        this.b = b;
    }

    @PostConstruct
    public void init() {
        this.b.setA(this);
    }

    public void doSomething() {
        System.out.println("A 调用 B 的方法：" + b.doSomethingElse());
    }
}

@Component
public class B {

    private A a;

    public B() {
        System.out.println("B 构造器");
    }

    public String doSomethingElse() {
        return "B 正在工作，A 加油！";
    }

    public void setA(A a) {
        this.a = a;
    }
}

使用ApplicationContextAware接口： 可以使用 ApplicationContextAware 接口来获取 Spring 容器的引用。这样，我们可以在 Bean 中手动获取其他 Bean 的实例，从而打破循环依赖。

@Component
public class A implements ApplicationContextAware {

    private B b;
    private ApplicationContext applicationContext;

    public A() {
        System.out.println("A 构造器");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @PostConstruct
    public void init() {
        this.b = applicationContext.getBean(B.class);
    }

    public void doSomething() {
        System.out.println("A 调用 B 的方法：" + b.doSomethingElse());
    }
}

@Component
public class B {

    public B() {
        System.out.println("B 构造器");
    }

    public String doSomethingElse() {
        return "B 正在工作，A 加油！";
    }
}

第六幕：总结：珍惜生命，远离循环依赖！

循环依赖是Spring开发中一个常见的问题，但也是一个需要避免的问题。它会导致系统性能下降，甚至崩溃。避免循环依赖的最佳方法是重新设计你的代码，减少不必要的依赖关系。如果你无法避免循环依赖，那么可以使用Setter注入或Field注入，或者使用@Lazy注解来解决。

记住，好的代码就像一段美好的爱情，应该简洁、清晰、易于理解。远离循环依赖，让你的代码更加健康、稳定！

结尾：下课！

好了，今天的“Spring恋爱故事会”就到这里。希望大家通过今天的讲解，能够对循环依赖有一个更深入的了解，并且能够在实际开发中避免或者解决它。感谢大家的观看！

发表回复 取消回复

发表回复取消回复