Springboot怎么解决循环依赖(基于单例 Bean)

目录

• 一、什么是循环依赖？
• 1. 构造器注入循环依赖（Spring ❌无法解决）
• 2. 字段（或 setter）注入循环依赖（Spring ✅能自动解决）
• 3. 原型作用域的循环依赖（Spring ❌无法解决）
• 二、Spring 如何解决循环依赖（基于单例 Bean）
• 1. Bean 创建流程概览（以 A → B → A 为例）
• 2. 三级缓存详解
• 3. 核心方法说明（来自源码）
• 三、业务开发者解决循环依赖的方法
• 1、使用@Lazy懒加载依赖
• 2、将依赖的代码移入新类，打破依赖闭环。
• 3、在方法中动态调用spring容器的getBean方法获取依赖，达到延迟获取bean，避免类中直接注入循环依赖的bean
• 4、改为 setter 或字段注入（避免构造器注入）
• 5、使用@PostConstruct 或 工厂方法延迟注入
• 6、开启Spring Boot循环依赖（不推荐，除非必要）。

一、什么是循环依赖？

循环依赖（Circular Dependency） 指两个或多个 Bean 之间相互依赖，导致在创建 Bean 的过程中出现“死循环”，增加了对象依赖的混乱性，依赖关系变得错综复杂。

常见三种类型的循环依赖：

1. 构造器注入循环依赖（Spring ❌无法解决）

@Component
public class A {
    private final B b;
    @Autowired
    public A(B b) {
        this.b = b;
    }
}
@Component
public class B {
    private final A a;
    @Autowired
    public B(A a) {
        this.a = a;
    }
}

❌ 结果：

报错：BeanCurrentlyInCreationException: Requested bean is currently in creation: Is there an unresolvable circular reference?

原因：Spring 必须先构造 A 才能注入 B，但 B 的构造又依赖 A，导致死循环，无法通过三级缓存提前暴露 Bean。

2. 字段（或 setter）注入循环依赖（Spring ✅能自动解决）

@Component
public class A {
    @Autowired
    private B b;
}
@Component
public class B {
    @Autowired
    private A a;
}

✅ 结果：

Spring 能自动解决，应用成功启动。

• 原因：Spring 会先构造出一个“空的 A 实例”，将其工厂加入三级缓存，B 注入 A 时就能拿到早期引用，从而打破循环。
• 前提：spring.main.allow-circular-references: true，必须开启情况下才能自动解决。然Spring 6.0 起（包括 Spring Boot 3.x）默认为false

3. 原型作用域的循环依赖（Spring ❌无法解决）

@Component
@Scope("prototype")
public class A {
    @Autowired
    private B b;
}
@Component
@Scope("prototypepython")
public class B {
    @Autowired
    private A a;
}

❌ 结果：

报错：BeanCurrentlyInCreationException（创建过程中找不到可注入的 Bean）

原因：Spring 不缓存 prototype Bean 的创建过程，无法通过三级缓存解决依赖链，原型 Bean 不参与依赖管理。

二、Spring 如何解决循环依赖（基于单例 Bean）

Spring 采用一种经典的 三级缓存机制（3-level cache） 来解决循环依赖。这个机制存在于DefaultSingletonBeanRegistry中。

前提：仅对 @Scope("singleton") 且使用字段或 setter 注入有效！

1. Bean 创建流程概览（以 A → B → A 为例）

✅ Step-by-step：

创建 A 实例（构造函数执行）；

A被标记为“正在创建”，并将一个工厂（ObjectFactory）放入三级缓存；

A 依赖 B → Spring 创建 B；

B 构造完成，发现依赖 A → 尝试获取 A；

Spring 发现 A 正在创建 → 从三级缓存拿到 ObjectFactory 生成早期 A 对象 → 放入二级缓存；

B 成功注入 A，初始化完成；

回到 A，完成初始化。

整个过程中 Spring 使用缓存提前暴露未完成的 A 实例，从而打破了循环。

2. 三级缓存详解

Spring 将 Bean 提前曝光的流程：

singletonFactories -> earlySingletonObjects -> singletonObjects

3. 核心方法说明（来自源码）

在 Spring 源码中，关键方法如下：

// DefaultSingletonBeanRegistry.Java
// 一级缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>();
// 二级缓存
private final Map<String, Object> earlySingletonObjects = new HashMap<>();
// 三级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>();

• 在创建 Bean 前：Spring 把一个生成 Bean 的工厂方法放入三级缓存。
• 在注入依赖时：发现依赖的是一个“正在创建”的 Bean，就会去三级缓存中拿工厂生产早期对象。
• 最后再完成依赖注入，放入一级缓存，清除早期引用。

三、业务开发者解决循环依赖的方法

1、使用@Lazy懒加载依赖

使用`@Lazy`注解延迟注入依赖属性。

@Componejsnt
public class A {
    @Autowired
    @Lazy
    private B b;
}

2、将依赖的代码移入新类，打破依赖闭环。

A → MiddleService → B

3、在方法中动态调用spring容器的getBean方法获取依赖，达到MlEqmIiFia延迟获取bean，避免类中直接注入循环依赖的bean

使用 ObjectFactory 或 ApplicationContext.getBean() 延迟获取 Bean

@Component
@Scope("prototype")
public class A {
    @Autowired
    private ObjectFactory<B> bFactory;
    public void use() {
        B b = bFactory.getObject(); // 延迟获取
    }
}

4、改为 setter 或字段注入（避免构造器注入）

构造器注入是“强依赖”，无法提前暴露：

@Component
public class A {http://www.devze.com
    private B b;
    @Autowired
 python   public void setB(B b) {
        this.b = b;
    }
}

5、使用@PostConstruct 或 工厂方法延迟注入

将依赖注入放到初始化之后：

@Component
public class A {
    private final B b;
    public A(B b) {
        this.b = b;
    }
    @PostConstruct
    public void init() {
        // 在这里安全使用 b
    }
}

6、开启Spring Boot循环依赖（不推荐，除非必要）。

spring:
    main:
        allow-circular-references: true

到此这篇关于Springboot怎么解决循环依赖(基于单例 Bean)的文章就介绍到这了,更多相关Springboot循环依赖内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！