Spring中的循環(huán)依賴詳解

更新時間：2023年09月14日 08:47:52 作者：這堆干貨有點猛

這篇文章主要介紹了Spring中的循環(huán)依賴詳解, Spring 框架是一個流行的Java應用程序框架,它提供了許多強大的功能,如依賴注入和面向切面編程,然而在使用 Spring 框架時,我們可能會遇到循環(huán)依賴的問題,需要的朋友可以參考下

解決循環(huán)依賴的原理

在 Spring 框架中，當兩個或多個 Bean 之間相互依賴時， Spring 框架會創(chuàng)建一個代理對象，該代理對象負責管理這些 Bean 之間的依賴關系。這個代理對象被稱為“early proxy”或“exposed proxy”。

當一個 Bean 需要訪問另一個 Bean 時， Spring 框架會通過代理對象來獲取該 Bean。這個代理對象負責保證 Bean 的實例化順序，確保每個 Bean 都只被實例化一次，并且在所有依賴關系被滿足之前，不會暴露任何未實例化的 Bean 。

Spring 框架解決循環(huán)依賴的過程如下：

當 Spring 框架啟動時，它會掃描應用程序中的所有 Bean，并將它們注冊到一個 Bean Factory中。
當一個 Bean 被實例化時Spring 框架會檢查它是否有任何依賴關系。
如果 Bean 有依賴關系，則 Spring 框架會檢查這些依賴關系是否已經(jīng)被創(chuàng)建。
如果依賴關系已經(jīng)被創(chuàng)建，則 Spring 框架會將依賴關系注入到 Bean 中，并返回該 Bean 的實例。
如果依賴關系還沒有被創(chuàng)建，則 Spring 框架會創(chuàng)建一個代理對象(通過 getEarlyBeanReference 方法)，并將該代理對象暴露給該 Bean。
當依賴關系被創(chuàng)建時，Spring 框架會使用代理對象來獲取依賴關系，并將依賴關系注入到 Bean 中。
當所有依賴關系都被滿足時，Spring 框架會返回該 Bean 的實例。

源碼解析

為了更好地理解 Spring 框架如何解決循環(huán)依賴的問題，我們將分析 Spring 框架的源代碼。

下面是一個簡單的示例，演示了 Spring 框架如何解決循環(huán)依賴的問題。

public class A {
    private B b;
    public A() {}
    public void setB(B b) {
        this.b = b;
    }
}
public class B {
    private A a;
    public B() {}
    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();
    }
}

在這個示例中，類A依賴于類B，而類B又依賴于類A。因此，這個示例展示了一個循環(huán)依賴的情況。

當應用程序啟動時，Spring 框架會掃描所有的 Bean ，并將它們注冊到一個BeanFactory中。

當 BeanFactory創(chuàng)建 Bean 時，它會檢查 Bean 是否有任何依賴關系。

在這個示例中，當 BeanFactory 創(chuàng)建 A 和 B 時，它會檢查它們之間的依賴關系。由于 A 依賴于 B，而 B 又依賴于 A，因此存在循環(huán)依賴的問題。

為了解決這個問題，Spring 框架會創(chuàng)建一個代理對象，該代理對象負責管理A和B之間的依賴關系。在這個示例中，當 BeanFactory 創(chuàng)建 A 時，它會創(chuàng)建一個代理對象，并將該代理對象暴露給A。當BeanFactory創(chuàng)建B時，它會創(chuàng)建一個代理對象，并將該代理對象暴露給 B。這樣，A和B就可以通過代理對象來訪問彼此，而不會出現(xiàn)循環(huán)依賴的問題。

下面是 Spring 框架解決循環(huán)依賴的源碼示例：

首先 Spring 框架會從緩存中獲取需要的 bean:

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

上面代碼中，框架分別從 singletonObjects、earlySingletonObjects、singletonFactories 中獲取需要的實例，如果獲取不到，就就行創(chuàng)建，在創(chuàng)建的過程中如果發(fā)現(xiàn)需要處理循環(huán)依賴，就會調(diào)用下面方法獲取代理對象：

private Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                if (exposedObject == null) {
                    return exposedObject;
                }
            }
        }
    }
    return exposedObject;
}

在這個示例中，getEarlyBeanReference() 方法是 Spring 框架用來獲取代理對象的方法。該方法首先檢查 Bean 是否為合成的 Bean ，然后檢查該 Bean 是否有任何實例化后的 Bean 后處理器。如果 Bean 有實例化后的 Bean 后處理器，則 Spring 框架會使用這些 Bean 后處理器來獲取代理對象。