深入理解Spring是如何解决循环依赖的

1、简介循环依赖

在 Spring 框架中，循环依赖是指两个或多个 Bean 互相依赖，形成了一个闭环。例如，Bean A 依赖于 Bean B，而 Bean B 又依赖于 Bean A。这种依赖关系可能会导致初始化失败。Spring 提供了一种机制来解决这种循环依赖问题。

2、Spring 解决循环依赖的核心机制

Spring 使用三级缓存和提前暴露未完全初始化的 Bean 来解决循环依赖问题。具体来说，Spring 在创建 Bean 的过程中会将 Bean 的不同状态存储在三个缓存中：

1. 一级缓存（singletonObjects）

   • 存储已经完全初始化完成的单例 Bean。
   • 这些 Bean 已经完成了所有依赖注入，并且可以安全地使用。

2. 二级缓存（earlySingletonObjects）

   • 存储提前暴露的、尚未完全初始化的 Bean。
   • 当一个 Bean 正在创建过程中，但已经被其他 Bean 需要时，Spring 会将该 Bean 提前暴露到这个缓存中。

3. 三级缓存（singletonFactories）

   • 存储用于创建提前暴露 Bean 的工厂对象（ObjectFactory）。
   • 当一个 Bean 正在创建过程中，Spring 会将该 Bean 的工厂对象放入三级缓存，以便后续需要时可以通过工厂创建出提前暴露的 Bean。

3、循环依赖的解决过程

假设场景

• Bean A 依赖于 Bean B。
• Bean B 依赖于 Bean A。

具体步骤

1. 创建 Bean A

   • Spring 开始创建 Bean A。
   • 在实例化 Bean A 后，Spring 将其工厂对象（ObjectFactory）放入三级缓存（singletonFactories）中。
   • 接着，Spring 开始为 Bean A 注入依赖（即需要获取 Bean B）。

2. 创建 Bean B

   • Spring 发现 Bean A 需要 Bean B，于是开始创建 Bean B。
   • 在实例化 Bean B 后，Spring 将其工厂对象（ObjectFactory）放入三级缓存（singletonFactories）中。
   • 接着，Spring 开始为 Bean B 注入依赖（即需要获取 Bean A）。

3. 从缓存中获取 Bean A

   • Spring 发现 Bean B 需要 Bean A，而 Bean A 此时正在创建过程中。
   • Spring 从三级缓存（singletonFactories）中找到 Bean A 的工厂对象，并通过工厂对象创建出 Bean A 的早期引用（未完全初始化的 Bean A）。
   • Spring 将 Bean A 的早期引用放入二级缓存（earlySingletonObjects），并将其注入到 Bean B 中。

4. 完成 Bean B 的创建

   • Bean B 的依赖注入完成，Spring 将 Bean B 完全初始化后放入一级缓存（singletonObjects）。

5. 完成 Bean A 的创建

   • 回到 Bean A 的创建过程，Spring 将 Bean B 注入到 Bean A 中。
   • Bean A 的依赖注入完成，Spring 将 Bean A 完全初始化后放入一级缓存（singletonObjects）。

注意：

1. 仅支持单例 Bean 的循环依赖

   • Spring 的循环依赖解决方案仅适用于单例作用域（@Scope("singleton")）的 Bean。
   • 对于原型作用域（@Scope("prototype")）的 Bean，Spring 不会缓存它们，因此无法解决循环依赖。

2. 构造器注入可能导致循环依赖无法解决

   • 如果循环依赖是通过构造器注入实现的，Spring 可能无法解决这种循环依赖。
   • 这是因为构造器注入要求在实例化时就完成依赖注入，而此时 Bean 尚未被放入缓存。

3. 推荐避免循环依赖

   • 虽然 Spring 提供了循环依赖的解决方案，但循环依赖通常是设计上的问题。
   • 更好的做法是通过重构代码来避免循环依赖，例如引入中间层或使用接口解耦。