Bean的生命周期

在Spring中，由于IOC的控制反轉(zhuǎn)，創(chuàng)建對象不再是簡單的new出來，而是交給Spring去創(chuàng)建，會經(jīng)歷一系列Bean的生命周期才創(chuàng)建出相應(yīng)的對象。

而循環(huán)依賴問題也是由Bean的生命周期過程導致的問題，因此我們首先需要了解Bean的生命周期。

Bean的生命周期可以概括為4步：

實例化----屬性注入----初始化----銷毀

詳細的講，步驟如下：

實例化

1.定位：Spring容器會根據(jù)配置文件（如XML、注解等）或編程式配置來確定需要創(chuàng)建的Bean。

2.加載：Spring容器會加載配置文件并解析其中的Bean定義，將其轉(zhuǎn)換為內(nèi)部數(shù)據(jù)結(jié)構(gòu)，例如BeanDefinition。

3.實例化：在實例化階段，Spring容器會根據(jù)Bean定義中的信息創(chuàng)建Bean的實例。這個過程可以通過構(gòu)造函數(shù)實例化、工廠方法實例化或者通過反射機制來實現(xiàn)。

屬性注入

4.屬性注入：在實例化Bean之后，Spring容器會對Bean進行屬性注入。這可以通過setter方法注入、構(gòu)造函數(shù)參數(shù)注入或字段注入等方式來完成。

初始化

5.Aware接口回調(diào)：如果Bean實現(xiàn)了Spring的Aware接口，容器會通過回調(diào)方式將一些特殊的資源注入到Bean中。例如，如果Bean實現(xiàn)了BeanFactoryAware接口，容器會將當前的BeanFactory實例注入到Bean中。

6.初始化前回調(diào)：如果Bean實現(xiàn)了InitializingBean接口，容器會在初始化之前調(diào)用它的afterPropertiesSet()方法，給Bean一個機會執(zhí)行一些初始化操作。同時，Spring容器還支持使用自定義的初始化方法。

7.初始化后回調(diào)：如果Bean配置了初始化回調(diào)方法，容器會調(diào)用該方法進行一些自定義的初始化邏輯處理。

8.后置處理器（BeanPostProcessor）：Spring容器會調(diào)用注冊的Bean后置處理器對Bean進行加工和增強。例如，可以通過AOP技術(shù)在這個階段為Bean動態(tài)生成代理對象。

9.完成：至此，Bean已經(jīng)成功創(chuàng)建，并且已經(jīng)完成了所有的初始化過程。此時可以將Bean提供給其他對象使用。

銷毀

10.銷毀前回調(diào)（PreDestroy）：在容器關(guān)閉之前，調(diào)用Bean的銷毀前回調(diào)方法，執(zhí)行一些清理操作和釋放資源的任務(wù)。

11.銷毀：容器關(guān)閉時，銷毀所有Bean實例，包括調(diào)用相應(yīng)Bean的銷毀方法，進行最終的清理和資源釋放。

1、循環(huán)依賴問題

例如下面的代碼，A和B類就構(gòu)成了循環(huán)依賴，原因如下：

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

創(chuàng)建Bean的步驟：

1. Spring 掃描 class 得到 BeanDefinition；
2. 根據(jù)得到的 BeanDefinition 去生成 bean；
3. 首先根據(jù) class 推斷構(gòu)造方法；
4. 根據(jù)推斷出來的構(gòu)造方法，反射，得到一個對象（我們稱為原始對象）；
5. 填充原始對象中的屬性（依賴注入）；
6. 如果原始對象中的某個方法被 AOP 了，那么則需要根據(jù)原始對象生成一個代理對象；
7. 把最終生成的代理對象放入單例池（源碼中叫做 singletonObjects）中，下次 getBean 時就直接從單例池拿即可；

對于上述步驟的第4步，得到原始對象后需要注入屬性，A 類中存在一個 B 類的 b 屬性，此時就會根據(jù) b 屬性的類型和屬性名去 BeanFactory 中去獲取 B 類所對應(yīng)的單例bean。

如果此時 B 類在 BeanFactory 中還沒有生成對應(yīng)的 Bean，那么就需要去生成，就會經(jīng)過 B 的 Bean 的生命周期，也就會同樣的，需要A類的Bean，就發(fā)生了循環(huán)依賴，導致A和B的bean都創(chuàng)建不出來。

概括而言： A Bean創(chuàng)建–>依賴了 B 屬性–>觸發(fā) B Bean創(chuàng)建—>B 依賴了 A 屬性—>需要 A Bean（但A Bean還在創(chuàng)建過程中）

然而實際上，Spring通過三級緩存的方式自動解決了這個問題。

2、三級緩存的引入

2.1 非AOP情況下的解決方案

根據(jù)上文的分析我們發(fā)現(xiàn)，出現(xiàn)循環(huán)依賴的根本原因，是B的Bean需要注入A屬性的時候，Bean A還沒有創(chuàng)建出來，導致的。

那么相應(yīng)的，只要： 在進行依賴注入之前，先把 A 的原始 Bean 放入緩存（提早暴露，只要放到緩存了，其他 Bean 需要時就可以從緩存中拿了，這個緩存就應(yīng)該是earlySingletonObjects），放入緩存后，再進行依賴注入。

由于提前暴露，在創(chuàng)建B的Bean過程中，當需要注入A的屬性時，就可以從緩存中拿到A提前暴露的原始對象（還不是最終Bean），就解決了問題。

關(guān)鍵在于全程只有一個A的原始對象，其后續(xù)的生命周期沒有變化。

如下圖所示：

2.2 三級緩存具體

因此，對于不同時期的Bean，如原始Bean、完整周期的Bean，需要不同的緩存來存放，底層源碼中有三級緩存：

/** Cache of singleton objects: bean name –> bean instance */
private final Map singletonObjects = new ConcurrentHashMap(256);
 
/** Cache of singleton factories: bean name –> ObjectFactory */
private final Map> singletonFactories = new HashMap>(16);
 
/** Cache of early singleton objects: bean name –> bean instance */
private final Map earlySingletonObjects = new HashMap(16);

• 一級緩存：singletonObjects；緩存的是已經(jīng)經(jīng)歷了完整生命周期的bean對象。
• 二級緩存：earlySingletonObjects；比 singletonObjects 多了一個 early ，表示緩存的是早期的 bean對象（原始對象）。早期指的是 Bean 的生命周期還沒走完就把這個 Bean 放入了 earlySingletonObjects
• 三級緩存：singletonFactories；緩存的是 ObjectFactory，表示對象工廠，用來創(chuàng)建某個對象的。

3、有AOP情況下使用singletonFactories

3.1 引入三級緩存

看似我們只需要1、2級緩存就能夠解決問題了，為什么需要三級緩存呢？ 這就需要考慮到AOP代理對象的問題了：

上文的紅字提到，之所以能夠提前暴露，是因為假定的A的原始對象始終是同一個對象，但如果有AOP的情況下呢？我們考慮這樣的場景：

按照上文的分析，假設(shè)創(chuàng)建B的bean過程中，注入了A的原始對象屬性。

然后，A的原始對象采用AOP產(chǎn)生了一個代理對象，即，A的Bean變成了AOP 之后的代理對象。而B中的 屬性a對應(yīng)的并不是 AOP 之后的代理對象，而仍然是原始對象。

也就是說，這種情況下，B 依賴的 A 和最終的 A 不是同一個對象！

而解決這個問題的方法，就是引入三級緩存的singletonFactories

3.2 三級緩存具體解析

實際上，在有AOP的情況下，Spring并沒有像第2節(jié)所說，直接將示例緩存到二級緩存，而是生成完原始對象之后”多此一舉“地將實例先封裝到objectFactory中，在需要引用的時候再通過singletonFactory.getObject()獲取。

跟進getObject()方法，其實執(zhí)行了getEarlyBeanReference這個關(guān)鍵方法。

    this.addSingletonFactory(beanName, () -> {
		return this.getEarlyBeanReference(beanName, mbd, bean);
	});

也就是說，Spring將當前bean緩存到earlyProxyReferences中，標識提前曝光的bean。而wrapIfNecessary是用于Spring AOP自動代理的，也就是說在被提前引用前，進行了AOP代理，并得到了代理對象。 此時earlySingletonObjects緩存中的對象就是代理對象了！

因此，假設(shè)此時有其他對象依賴了A，就可以從earlySingletonObjects中獲取到A原始對象的代理對象了，并且和A是同一個對象，實現(xiàn)了目標。

3.3 后續(xù)依賴問題

當 B 創(chuàng)建完了之后，A 繼續(xù)進行生命周期，而 A 在完成屬性注入后，會按照它本身的邏輯去進行AOP，而此時我們知道 A 原始對象已經(jīng)經(jīng)歷過了 AOP ，所以對于 A 本身而言，不會再去進行 AOP了，那么怎么判斷一個對象是否經(jīng)歷過了 AOP 呢？

注意postProcessAfterInitialization方法，會當前beanName是否在earlyProxyReferences中，如果在就AOP過了，不在則執(zhí)行AOP方法。

此時對于Bean A對象而言已經(jīng)完成創(chuàng)建了，可以把它放入緩存singletonObjects中了，因此從earlySingletonObjects 中得到代理對象，然后入 singletonObjects 中。

至此，整個循環(huán)依賴解決完畢。

4、總結(jié)

這里用圖來說明具體流程：

對于三級緩存的singletonFactories，總結(jié)而言：

緩存的是一個 ObjectFactory ，主要用來去生成原始對象進行了 AOP之后得到的「代理對象」。

在每個 Bean 的生成過程中，都會提前暴露一個工廠，這個工廠可能用到，也可能用不到：

（1）如果沒有出現(xiàn)循環(huán)依賴依賴本 bean，那么這個工廠無用，本 bean 按照自己的生命周期執(zhí)行，執(zhí)行完后直接把本 bean 放入 singletonObjects 中即可（對應(yīng)本文章的第1節(jié)）

（2）如果出現(xiàn)了循環(huán)依賴依賴了本 bean，則：

• 如果有 AOP 的話，另外那個 bean 執(zhí)行 ObjectFactory 提交得到一個 AOP 之后的代理對象。（對應(yīng)本文章第3節(jié)）
• 如果無需 AOP ，則直接得到一個原始對象。（對應(yīng)本文章第2節(jié)）

到此這篇關(guān)于Spring的循環(huán)依賴、三級緩存解決方案源碼詳細解析的文章就介紹到這了,更多相關(guān)Spring循環(huán)依賴及三級緩存解決方案內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論