1.什么是循環依賴？
當多個Bean相互依賴時則構成了循環依賴，例如A，B兩個Bean。其中A中存在屬性B，B中存在屬性A，當Spring在實例化A時發現A中存在屬性B，就去實例化B，實例化B時又發現存在屬性A，一直在循環注入依賴，導致循環依賴問題出現。
2.Spring是怎么解決循環依賴的？
Spring中會通過各種Bean中間狀態來達到Bean還未實例化完成時提前將Bean提前注入到依賴Bean的屬性中，假設說Bean有三種狀態分別是青年態(一級緩存)、胚胎態(二級緩存)、小蝌蚪態(三級緩存)其中青年態代表Bean已經實例化完成，可以直接使用了，胚胎態代表Bean已經存在了但是還在創建中，還未創建完畢，小蝌蚪態代表還未開始創建，但是隨時可以進行創建，三個狀態就類似于三個等級，可以逐步提升從小蝌蚪狀態提升到胚胎狀態然后再提升到青年態，然后Spring開始創建Bena時會提前將Bean存放到小蝌蚪態的緩存集合中，當發現存在循環依賴時會使用存在于小蝌蚪狀態緩存集合中的Bean，提前
3.循環依賴的案例
假設例子中存在BeanA、BeanB、BeanC、BeanD四個Bean，其中
- BeanA依賴著BeanB,C
- BeanB依賴著BeanC
- BeanC依賴著BeanA
- BeanD依賴著BeanA,B,C
BeanA beanA = beanFactory.getBean("beanA",BeanA.class); BeanB beanB = beanFactory.getBean("beanB",BeanB.class); BeanC beanC = beanFactory.getBean("beanC",BeanC.class); BeanD beanD = beanFactory.getBean("beanD",BeanD.class);
那么他們的實例化流程是什么樣的呢？
發現了吧，Spring解決循環依賴的法寶就是緩存。
3.代碼解析（只保留相關代碼）
1.檢查緩存中是否已經存在實例化完畢的Bean
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//首先檢查一級緩存中是否存在
Object singletonObject = this.singletonObjects.get(beanName);
/**
* 如果一級緩存中不存在代表當前 Bean 還未被創建或者正在創建中
* 檢查當前 Bean 是否正處于正在創建的狀態中(當Bean創建時會將Bean名稱存放到 singletonsCurrentlyInCreation 集合中)
*/
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//檢查二級緩存中是否存在
singletonObject = this.earlySingletonObjects.get(beanName);
/**
* @@如果二級緩存中不存在 并且 允許使用早期依賴
* allowEarlyReference ： 它的含義是是否允許早期依賴
* @@那么什么是早期依賴？
* 就是當Bean還未成為成熟的Bean時就提前使用它，在實例化流程圖中我們看到在添加緩存前剛剛實例化Bean但是還未依賴注入時的狀態
*/
if (singletonObject == null && allowEarlyReference) {
//獲取三級緩存中的 Bean ObjectFactory
ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
//如果 Bean 對應的 ObjectFactory 存在
if (singletonFactory != null) {
//使用 getObject 方法獲取到 Bean 的實例
singletonObject = singletonFactory.getObject();
//將 bean 從三級緩存提升至二級緩存
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
2.創建Bean
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
/**
* 我們一開始通過 getSingleton() 方法中獲取三級緩存中存放的Bean，這里就是向三級緩存中添加 bean 的地方
* 流程:
* 1.檢查當前 bean 是否為單例模式，并且是否允許循環引用[講解1],并且當前是否正在創建中(在getSingleton方法中添加的)
* 2.如果允許提前曝光[講解2]，addSingletonFactory() 方法向緩存中添加當前 bean 的 ObjectFactory
*
* [講解1]：當前 Bean 如果不允許循環引用(循環依賴也就是被依賴)，則這里就不會提前曝光，對應的 ObjectFactory
* 則當發生循環依賴時會拋出 BeanCreationException 異常
*
* [講解2]：提前曝光的含義就是說當 bean 還未創建完畢時就先將創建中狀態的bean放到指定緩存中，為循環依賴提供支持
*/
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
//需要提前曝光
if (earlySingletonExposure) {
/**
* 向緩存(三級緩存)中添加當前 bean 的 ObjectFactory
*/
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
/**
* Initialize the bean instance.
* 初始化 Bean 實例階段
*/
Object exposedObject = bean;
try {
/**
* 依賴注入這時會遞歸調用getBean
*/
populateBean(beanName, mbd, instanceWrApper);
//調用初始化方法，如：init-method
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
/**
* 當允許提前曝光時進入判斷
* @這里做了什么？
* 1.檢查當前bean是否經歷了一場循環依賴
* - 通過 getSingleton(beanName,false) 獲取緩存中的 bean，傳入 false 代表不獲取三級緩存中的bean
* - 為什么說 檢查當前bean是否經歷了一場循環依賴呢？ 因為上述說了傳入 false 代表不獲取三級緩存的
* - 那么什么情況下才會存在與一級緩存和二級緩存呢？答案就是循環依賴后 [解釋1] 和bean實例化完成后
* - 所以如果 getSingleton 返回的 bean 不為空，則這個bean就是剛剛經歷了循環依賴
*
* 2.檢查提前曝光的bean和當前的Bean是否一致
* - 下面有個判斷 if (exposedObject == bean) ，這個判斷從緩存中獲取的bean 和 經歷過初始化后的 bean
* - 是否一致，可能我們有點暈，這里解釋一下，緩存從的bean是什么時候存進去的？是在 addSingletonFactory 方法(649行)
* - 然后這里存進去的 bean 只是提前曝光的 bean，還沒有依賴注入和初始化，但是在依賴注入和初始化時都是可能直接改變
* - 當前 bean 的實例的，這意味著什么？意味著經歷了依賴注入和初始化的bean很可能和緩存中的bean就已經完全不是一個 bean了
* 下面講解當一致或不一致時的邏輯：
* 2.1 一致：
* 不是很理解，直接賦值，可是經歷了各種 BeanPostProsser 或者依賴注入和初始化后不是就不一樣了嗎
* 2.2 不一致:
* 看下方對于 else if 代碼塊的解釋
*
* @[解釋1]
* 當循環依賴時，A依賴著B，B依賴著A，實例化A首先將A放到三級緩存中然后發現依賴著B，然后去實例化B，發現依賴著A
* 發現A在三級緩存，然后獲取三級緩存中的bean并且將A從三級緩存中提升到二級緩存中，實例化B完成，接著實例化A也完成。
*
* @通俗講解
* 假設我們業務上對某種數據加了緩存，假設 i 在緩存中存的值為1，當我在數據庫中把 i 的值改成 2 時，緩存中的 i 還沒有被改變還是 1
* 這時的數據已經和我們的真實數據偏離了，不一致了，這時有兩種解決方式：1.服務器檢查到數據不一致拋出異常。(也就是進入else if 代碼塊)
* 2.直接使用原始值也就是1(也就是將 allowRawInjectionDespiteWrapping 改成 true),當然這兩種方式明顯不是我們正常數據庫的操作，只是
* 為了說明當前的這個例子而已。
*
*/
if (earlySingletonExposure) {
//獲取緩存中(除三級緩存) beanName 對應的 bean
Object earlySingletonReference = getSingleton(beanName, false);
//當經歷了一場循環依賴后 earlySingletonReference 就不會為空
if (earlySingletonReference != null) {
//如果 exposedObject 沒有在初始化方法中被改變，也就是沒有被增強
if (exposedObject == bean) {
//直接賦值? 可是經歷了各種 BeanPostProsser 或者依賴注入和初始化后不是就不一樣了嗎
exposedObject = earlySingletonReference;
}
/**
*
* 走到 else if 時說明 當前 Bean 被 BeanPostProessor 增強了
* 判斷的條件為：
* 1.如果允許使用被增強的
* 2.檢查是否存在依賴當前bean的bean
*
* 如果存在依賴的bean已經被實例化完成的，如果存在則拋出異常
* 為什么拋出異常呢？
* 因為依賴當前bean 的bean 已經在內部注入了當前bean的舊版本，但是通過初始化方法后這個bean的版本已經變成新的了
* 舊的哪個已經不適用了，所以拋出異常
*
*/
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
try {
/**
* Register bean as disposable.
* 注冊 Bean 的銷毀方法拓展
*/
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
