一、什么是循環(huán)依賴？

循環(huán)依賴（Circular Dependency） 指兩個或多個 Bean 之間相互依賴，導致在創(chuàng)建 Bean 的過程中出現(xiàn)“死循環(huán)”，增加了對象依賴的混亂性，依賴關系變得錯綜復雜。

常見三種類型的循環(huán)依賴：

1. 構造器注入循環(huán)依賴（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，導致死循環(huán)，無法通過三級緩存提前暴露 Bean。

2. 字段（或 setter）注入循環(huán)依賴（Spring ?能自動解決）

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

? 結果：

Spring 能自動解決，應用成功啟動。

• 原因：Spring 會先構造出一個“空的 A 實例”，將其工廠加入三級緩存，B 注入 A 時就能拿到早期引用，從而打破循環(huán)。
• 前提：spring.main.allow-circular-references: true，必須開啟情況下才能自動解決。然Spring 6.0 起（包括 Spring Boot 3.x）默認為false

3. 原型作用域的循環(huán)依賴（Spring ?無法解決）

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

? 結果：

報錯：BeanCurrentlyInCreationException（創(chuàng)建過程中找不到可注入的 Bean）

原因：Spring 不緩存 prototype Bean 的創(chuàng)建過程，無法通過三級緩存解決依賴鏈，原型 Bean 不參與依賴管理。

二、Spring 如何解決循環(huán)依賴（基于單例 Bean）

Spring 采用一種經(jīng)典的 三級緩存機制（3-level cache） 來解決循環(huán)依賴。這個機制存在于DefaultSingletonBeanRegistry中。

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

1. Bean 創(chuàng)建流程概覽（以 A → B → A 為例）

? Step-by-step：

創(chuàng)建 A 實例（構造函數(shù)執(zhí)行）；

A被標記為“正在創(chuàng)建”，并將一個工廠（ObjectFactory）放入三級緩存；

A 依賴 B → Spring 創(chuàng)建 B；

B 構造完成，發(fā)現(xiàn)依賴 A → 嘗試獲取 A；

Spring 發(fā)現(xiàn) A 正在創(chuàng)建 → 從三級緩存拿到 ObjectFactory 生成早期 A 對象 → 放入二級緩存；

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

回到 A，完成初始化。

整個過程中 Spring 使用緩存提前暴露未完成的 A 實例，從而打破了循環(huán)。

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<>();

• 在創(chuàng)建 Bean 前：Spring 把一個生成 Bean 的工廠方法放入三級緩存。
• 在注入依賴時：發(fā)現(xiàn)依賴的是一個“正在創(chuàng)建”的 Bean，就會去三級緩存中拿工廠生產(chǎn)早期對象。
• 最后再完成依賴注入，放入一級緩存，清除早期引用。

三、業(yè)務開發(fā)者解決循環(huán)依賴的方法

1、使用@Lazy懶加載依賴

使用`@Lazy`注解延遲注入依賴屬性。

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

2、將依賴的代碼移入新類，打破依賴閉環(huán)。

A → MiddleService → B

3、在方法中動態(tài)調用spring容器的getBean方法獲取依賴，達到延遲獲取bean，避免類中直接注入循環(huán)依賴的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 {
    private B b;
    @Autowired
    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循環(huán)依賴（不推薦，除非必要）。

spring:
    main:
        allow-circular-references: true

到此這篇關于Springboot怎么解決循環(huán)依賴(基于單例 Bean)的文章就介紹到這了,更多相關Springboot循環(huán)依賴內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論