[[379347]]

前言

在研究 『 Spring 是如何解決循環(huán)依賴的 』 的時候，了解到 Spring 是借助三級緩存來解決循環(huán)依賴的。

同樣在上一節(jié)留下了疑問：

1. 循環(huán)依賴為什么要使用三級緩存?而不是使用二級緩存?
2. AOP 動態(tài)代理對循環(huán)依賴的有沒有什么影響?

本篇文章也是圍繞上面的內容進行展開。

筆記也在不斷整理，之前可能會有點雜亂。

循序漸進，看一看什么是循環(huán)依賴?

先來回顧一下三級緩存的概念。

• singletonObjects： 一級緩存，存儲單例對象，Bean 已經實例化，初始化完成。
• earlySingletonObjects： 二級緩存，存儲 singletonObject，這個 Bean 實例化了，還沒有初始化。
• singletonFactories： 三級緩存，存儲 singletonFactory。

Bean 的創(chuàng)建過程

@Service 
public class CircularServiceA { 
    private String fieldA = "字段 A"; 
} 

單例 Bean 的創(chuàng)建過程

 

通過上面的流程，可以看出 Spring 在創(chuàng)建 Bean 的過程中重點是在 AbstractAutowireCapableBeanFactory 中的以下三個步驟：

1. 實例化 createBeanInstance： 其中實例化 Bean 并對 Bean 進行賦值，像例子中的 fieldA 字段在這里就會賦值。
2. 屬性注入 populateBean： 可以理解為對 Bean 里面的屬性進行賦值。(會依賴其他 Bean)
3. 初始化 initializeBean： 執(zhí)行初始化和 Bean 的后置處理器。

實例化賦值源碼可以閱讀：

BeanUtils.instantiateClass(constructorToUse)

如果要依賴其他 Bean 呢?

那如果 CircularServiceA 依賴了其他 Bean 呢?

A 依賴了 B

 

當 A 依賴了 B 的時候，在 createBeanInstance 這一步，并不會對 B 進行屬性賦值。

而是在 populatedBean 這里查找依賴項，并創(chuàng)建 B。

循環(huán)依賴下的創(chuàng)建過程

循環(huán)依賴的場景，在上一篇文章已經有所講解，這里僅僅畫圖說明一下。

@Service 
public class CircularServiceA { 
 
    private String fieldA = "字段 A"; 
 
    @Autowired 
    private CircularServiceB circularServiceB; 
 
} 
@Service 
public class CircularServiceB { 
    @Autowired 
    private CircularServiceA circularServiceA; 

 

 

A B 循環(huán)依賴

 

 

在 A 和 B 循環(huán)依賴的場景中：

B populatedBean 查找依賴項 A 的時候，從一級緩存中雖然未獲取到 A，但是發(fā)現 A 在創(chuàng)建中。

此時，從三級緩存中獲取 A 的 singletonFactory 調用工廠方法，創(chuàng)建 getEarlyBeanReference A 的早期引用并返回。

B 引用到 A ，B 就可以初始化完畢，然后 A 同樣也可以初始化完畢了。

二級緩存能否解決循環(huán)依賴

通過上面的圖，仔細分析一下，其實把二級緩存拿掉，在 B 嘗試獲取 A 的時候直接返回 A 的實例，是不是也是可以的?

答案是：可以的!

但是為什么還是用三級緩存呢?

網上的很多資料說是和動態(tài)代理有關系，那就從動態(tài)代理的方面繼續(xù)往下分析分析。

動態(tài)代理的場景

在 JavaConfig(配置類) 上添加 @EnableAspectJAutoProxy 注解，開啟 AOP ，通過 Debug 循序漸進看一看動態(tài)代理對循環(huán)依賴的影響。

動態(tài)代理下，Bean 的創(chuàng)建過程

@Service 
public class CircularServiceA { 
    private String fieldA = "字段 A"; 
 
    public void methodA() { 
 
        System.out.println("方法 A 執(zhí)行"); 
 
    } 
} 
@Aspect 
@Component 
public class AspectA { 
 
    @Before("execution(public void com.liuzhihang.circular.CircularServiceA.methodA())") 
    public void beforeA() { 
        System.out.println("beforeA 執(zhí)行"); 
    } 
} 

只有 A 的情況下，給 A 添加切面，開始 Debug。

前面的流程都相同，在 initializeBean 開始出現差異。

這一步需要初始化 Bean 并執(zhí)行 Bean 的后置處理器。

 

執(zhí)行后置處理器

 

 

其中有一個處理器為：AnnotationAwareAspectJAutoProxyCreator 其實就是加的注解切面，會跳轉到 AbstractAutoProxyCreator 類的 postProcessAfterInitialization 方法

 

 

postProcessAfterInitialization

 

 

如圖所示：wrapIfNecessary 方法會判斷是否滿足代理條件，是的話返回一個代理對象，否則返回當前 Bean。

后續(xù)調用 getProxy 、createAopProxy 等等，最終執(zhí)行到下面一部分。

 

最終會執(zhí)行到這里，AOP 代理相關的就不細看了。

一路放行，直到 initializeBean 執(zhí)行結束。

A 被替換為了代理對象

 

此時發(fā)現：A 被替換為了代理對象。

所以 doCreateBean 返回，以及后面放到一級緩存中的都是代理對象。

紅框部分為差異

 

有循環(huán)依賴的動態(tài)代理

這一次把循環(huán)依賴打開：

@Service 
public class CircularServiceA { 
 
    private String fieldA = "字段 A"; 
 
    @Autowired 
    private CircularServiceB circularServiceB; 
 
    public void methodA() { 
 
        System.out.println("方法 A 執(zhí)行"); 
 
    } 
} 
@Aspect 
@Component 
public class AspectA { 
 
    @Before("execution(public void com.liuzhihang.circular.CircularServiceA.methodA())") 
    public void beforeA() { 
 
        System.out.println("beforeA 執(zhí)行"); 
 
    } 
 
} 
@Service 
public class CircularServiceB { 
 
    @Autowired 
    private CircularServiceA circularServiceA; 
 
    public void methodB() { 
 
    } 
} 
@Aspect 
@Component 
public class AspectB { 
     
    @Before("execution(public void com.liuzhihang.circular.CircularServiceB.methodB())") 
    public void beforeB() { 
 
        System.out.println("beforeB 執(zhí)行"); 
 
    } 
 
} 

開始 Debug，前面的一些列流程，都和正常的沒有什么區(qū)別。而唯一的區(qū)別在于，創(chuàng)建 B 的時候，需要從三級緩存獲取 A。

此時在 getSingleton 方法中會調用：singletonObject = singletonFactory.getObject();

B 屬性賦值時，從三級緩存獲取 A

 

有時會比較疑惑 singletonFactory.getObject() 調用的是哪里?

 

三級緩存獲取對象

 

 

所以這一塊調用的是 getEarlyBeanReference，開始遍歷執(zhí)行 BeanPostProcessor。

getEarlyBeanReference

 

 

getEarlyBeanReference

 

 

看到 wrapIfNecessary 就明白了吧!這塊會獲取一個代理對象。

也就是說此時返回，并放到二級緩存的是一個 A 的代理對象。

這樣 B 就創(chuàng)建完畢了!

到 A 開始初始化并執(zhí)行后置處理器了!因為 A 也有代理，所以 A 也會執(zhí)行到 postProcessAfterInitialization 這一部分!

 

判斷二級緩存

 

 

但是在執(zhí)行 wrapIfNecessary 之前，會先判斷二級緩存是否有 A 了。

this.earlyProxyReferences.remove(cacheKey) != bean 

但是這塊獲取到的是 A 的代理對象。肯定是 false 。所以不會再生成一次 A 的代理對象。

代理 - 循環(huán)依賴

 

總結

可以看到，循環(huán)依賴下，有沒有代理情況下的區(qū)別就在：

singletonObject = singletonFactory.getObject(); 

在循環(huán)依賴發(fā)生的情況下 B 中的 A 賦值時：

1. 無代理：getObject 直接返回原來的 Bean
2. 有代理：getObject 返回的是代理對象

然后都放到二級緩存。

為什么要三級緩存?

假設去掉三級緩存

去掉三級緩存之后，Bean 直接創(chuàng)建 earlySingletonObjects， 看著好像也可以。

如果有代理的時候，在 earlySingletonObjects 直接放代理對象就行了。

但是會導致一個問題：在實例化階段就得執(zhí)行后置處理器，判斷有 AnnotationAwareAspectJAutoProxyCreator 并創(chuàng)建代理對象。

這么一想，是不是會對 Bean 的生命周期有影響。

同樣，先創(chuàng)建 singletonFactory 的好處就是：在真正需要實例化的時候，再使用 singletonFactory.getObject() 獲取 Bean 或者 Bean 的代理。相當于是延遲實例化。

假設去掉二級緩存

如果去掉了二級緩存，則需要直接在 singletonFactory.getObject() 階段初始化完畢，并放到一級緩存中。

 

B 和 C 都依賴 A

 

 

那有這么一種場景，B 和 C 都依賴了 A。

要知道在有代理的情況下 singletonFactory.getObject() 獲取的是代理對象。

 

 

多次獲取代理對象不同

 

 

而多次調用 singletonFactory.getObject() 返回的代理對象是不同的，就會導致 B 和 C 依賴了不同的 A。

那如果獲取 B 到之后直接放到一級緩存，然后 C 再獲取呢?

…

 

一級緩存放的是已經初始化完畢的 Bean，要知道 A 依賴了 B 和 C ，A 這時候還沒有初始化完畢。

小結

循環(huán)依賴的場景有很多，本文只是通過 Debug ，來了解到循環(huán)依賴和 AOP 之間的關系，以及了解到為什么要用三級緩存。

當然，Spring 設計之初是什么樣子的?如何一步一步發(fā)展成現在這種的?

肯定是不能慢慢去研究了，所以只能以現在的版本，去揣測作者的意圖。

不足之處，多多指正。

本文轉載自微信公眾號「程序員小航」，可以通過以下二維碼關注。轉載本文請聯系程序員小航公眾號。