簡單瞭解Spring迴圈依賴解決過程
這篇文章主要介紹了簡單瞭解Spring迴圈依賴解決過程,文中通過示例程式碼介紹的非常詳細,對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
前言
說起Spring中迴圈依賴的解決辦法,相信很多園友們都或多或少的知道一些,但當真的要詳細說明的時候,可能又沒法一下將它講清楚。本文就試著儘自己所能,對此做出一個較詳細的解讀。另,需注意一點,下文中會出現類的例項化跟類的初始化兩個短語,為怕園友迷惑,事先宣告一下,本文的例項化是指剛執行完構造器將一個物件new出來,但還未填充屬性值的狀態,而初始化是指完成了屬性的依賴注入。
一、先說說Spring解決的迴圈依賴是什麼
Java中的迴圈依賴分兩種,一種是構造器的迴圈依賴,另一種是屬性的迴圈依賴。
構造器的迴圈依賴就是在構造器中有屬性迴圈依賴,如下所示的兩個類就屬於構造器迴圈依賴:
@Service public class Student { @Autowired private Teacher teacher; public Student (Teacher teacher) { System.out.println("Student init1:" + teacher); } public void learn () { System.out.println("Student learn"); } }
@Service public class Teacher { @Autowired private Student student; public Teacher (Student student) { System.out.println("Teacher init1:" + student); } public void teach () { System.out.println("teach:"); student.learn(); } }
這種迴圈依賴沒有什麼解決辦法,因為JVM虛擬機器在對類進行例項化的時候,需先例項化構造器的引數,而由於迴圈引用這個引數無法提前例項化,故只能丟擲錯誤。
Spring解決的迴圈依賴就是指屬性的迴圈依賴,如下所示:
@Service public class Teacher { @Autowired private Student student; public Teacher () { System.out.println("Teacher init1:" + student); } public void teach () { System.out.println("teach:"); student.learn(); } }
@Service public class Student { @Autowired private Teacher teacher; public Student () { System.out.println("Student init:" + teacher); } public void learn () { System.out.println("Student learn"); } }
測試掃描類:
@ComponentScan(value = "myPackage") public class ScanConfig { }
測試啟動類:
public class SpringTest { public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ScanConfig.class); applicationContext.getBean(Teacher.class).teach(); } }
測試類執行結果:
Student init:null Teacher init:null teach: Student learn
可以看到,在構造器執行的時候未完成屬性的注入,而在呼叫方法的時候已經完成了注入。下面就一起看看Spring內部是在何時完成的屬性注入,又是如何解決的迴圈依賴。
二、迴圈依賴與屬性注入
1、對於非懶載入的類,是在refresh方法中的 finishBeanFactoryInitialization(beanFactory) 方法完成的包掃描以及bean的初始化,下面就一起追蹤下去。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // 其他程式碼 // Instantiate all remaining (non-lazy-init) singletons. beanFactory.preInstantiateSingletons(); }
可以看到呼叫了beanFactory的一個方法,此處的beanFactory就是指我們最常見的那個DefaultListableBeanFactory,下面看它裡面的這個方法。
2、DefaultListableBeanFactory的preInstantiateSingletons方法
public void preInstantiateSingletons() throws BeansException { List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { // 判斷為非抽象類、是單例、非懶載入 才給初始化 if (isFactoryBean(beanName)) { // 無關程式碼(針對FactoryBean的處理) } else { // 重要!!!普通bean就是在這裡初始化的 getBean(beanName); } } } // 其他無關程式碼 }
可以看到,就是在此方法中迴圈Spring容器中所有的bean,依次對其進行初始化,初始化的入口就是getBean方法
3、AbstractBeanFactory的getBean跟doGetBean方法
追蹤getBean方法:
public Object getBean(String name) throws BeansException { return doGetBean(name,null,false); }
可見引用了過載的doGetBean方法,繼續追蹤之:
protected <T> T doGetBean(final String name,@Nullable final Class<T> requiredType,@Nullable final Object[] args,boolean typeCheckOnly) throws BeansException { final String beanName = transformedBeanName(name); Object bean; // 方法1)從三個map中獲取單例類 Object sharedInstance = getSingleton(beanName); // 省略無關程式碼 } else { // 如果是多例的迴圈引用,則直接報錯 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // 省略若干無關程式碼 try { // Create bean instance. if (mbd.isSingleton()) { // 方法2) 獲取單例物件 sharedInstance = getSingleton(beanName,() -> { try { //方法3) 建立ObjectFactory中getObject方法的返回值 return createBean(beanName,mbd,args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process,to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance,name,beanName,mbd); } } // 省略若干無關程式碼 return (T) bean; }
該方法比較長,對於解決迴圈引用來說,上面標出來的3個方法起到了至關重要的作用,下面我們挨個攻克。
3.1) getSingleton(beanName)方法: 注意該方法跟方法2)是過載方法,名字一樣內部邏輯卻大相徑庭。
protected Object getSingleton(String beanName,boolean allowEarlyReference) { Object singletonObject = this.singletonObjects.get(beanName);// 步驟A if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { synchronized (this.singletonObjects) { singletonObject = this.earlySingletonObjects.get(beanName);// 步驟B if (singletonObject == null && allowEarlyReference) { ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);// 步驟C if (singletonFactory != null) { singletonObject = singletonFactory.getObject(); this.earlySingletonObjects.put(beanName,singletonObject); this.singletonFactories.remove(beanName); } } } } return singletonObject; }
通過上面的步驟可以看出這三個map的優先順序。其中singletonObjects裡面存放的是初始化之後的單例物件;earlySingletonObjects中存放的是一個已完成例項化未完成初始化的早期單例物件;而singletonFactories中存放的是ObjectFactory物件,此物件的getObject方法返回值即剛完成例項化還未開始初始化的單例物件。所以先後順序是,單例物件先存在於singletonFactories中,後存在於earlySingletonObjects中,最後初始化完成後放入singletonObjects中。
當debug到此處時,以上述Teacher和Student兩個迴圈引用的類為例,如果第一個走到這一步的是Teacher,則從此處這三個map中get到的值都是空,因為還未新增進去。這個方法主要是給迴圈依賴中後來過來的物件用。
3.2)getSingleton(String beanName,ObjectFactory<?> singletonFactory)方法:
public Object getSingleton(String beanName,ObjectFactory<?> singletonFactory) { Assert.notNull(beanName,"Bean name must not be null"); synchronized (this.singletonObjects) { Object singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { // 省略無關程式碼 beforeSingletonCreation(beanName); // 步驟A boolean newSingleton = false; // 省略無關程式碼 try { singletonObject = singletonFactory.getObject();// 步驟B newSingleton = true; } // 省略無關程式碼 finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } afterSingletonCreation(beanName);// 步驟C } if (newSingleton) { addSingleton(beanName,singletonObject);// 步驟D } } return singletonObject; } }
獲取單例物件的主要邏輯就是此方法實現的,主要分為上面四個步驟,繼續挨個看:
步驟A:
protected void beforeSingletonCreation(String beanName) { // 判斷,並首次將beanName即teacher放入singletonsCurrentlyInCreation中 if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } }
步驟C:
protected void afterSingletonCreation(String beanName) { // 得到單例物件後,再講beanName從singletonsCurrentlyInCreation中移除 if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) { throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation"); } }
步驟D:
protected void addSingleton(String beanName,Object singletonObject) { synchronized (this.singletonObjects) { this.singletonObjects.put(beanName,singletonObject);//新增單例物件到map中 this.singletonFactories.remove(beanName);//從早期暴露的工廠中移除,此map在解決迴圈依賴中發揮了關鍵的作用 this.earlySingletonObjects.remove(beanName);//從早期暴露的物件map中移除 this.registeredSingletons.add(beanName);//新增到已註冊的單例名字集合中 } }
步驟B:
此處呼叫了ObjectFactory的getObject方法,此方法是在哪裡實現的呢?返回的又是什麼?且往回翻,找到3中的方法3,對java8函數語言程式設計有過了解的園友應該能看出來,方法3 【createBean(beanName,args)】的返回值就是getObject方法的返回值,即方法3返回的就是我們需要的單例物件,下面且追蹤方法3而去。
3.3)AbstractAutowireCapableBeanFactory#createBean(java.lang.String,org.springframework.beans.factory.support.RootBeanDefinition,java.lang.Object[]) 方法
protected Object createBean(String beanName,RootBeanDefinition mbd,@Nullable Object[] args) throws BeanCreationException { // 省略無關程式碼 try { Object beanInstance = doCreateBean(beanName,mbdToUse,args); return beanInstance; } // 省略無關程式碼 }
去掉無關程式碼之後,關鍵方法只有doCreateBean方法,追蹤之:
protected Object doCreateBean(final String beanName,final RootBeanDefinition mbd,final @Nullable Object[] args) throws BeanCreationException { BeanWrapper instanceWrapper = null; // 省略程式碼 if (instanceWrapper == null) { // 例項化bean instanceWrapper = createBeanInstance(beanName,args); } boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { // 重點!!!將例項化的物件新增到singletonFactories中 addSingletonFactory(beanName,() -> getEarlyBeanReference(beanName,bean)); } // 初始化bean Object exposedObject = bean; try { populateBean(beanName,instanceWrapper);//也很重要 exposedObject = initializeBean(beanName,exposedObject,mbd); } // 省略無關程式碼 return exposedObject; }
上面註釋中標出的重點是此方法的關鍵。在addSingletonFactory方法中,將第二個引數ObjectFactory存入了singletonFactories供其他物件依賴時呼叫。然後下面的populateBean方法對剛例項化的bean進行屬性注入(該方法關聯較多,本文暫時不展開追蹤了,有興趣的園友自行檢視即可),如果遇到Spring中的物件屬性,則再通過getBean方法獲取該物件。至此,迴圈依賴在Spring中的處理過程已經追溯完畢,下面我們總結一下。
小結
屬性注入主要是在populateBean方法中進行的。對於迴圈依賴,以我們上文中的Teacher中注入了Student、Student中注入了Teacher為例來說明,假定Spring的載入順序為先載入Teacher,再載入Student。
getBean方法觸發Teacher的初始化後:
a. 首先走到3中的方法1),此時map中都為空,獲取不到例項;
b. 然後走到方法2)中,步驟A、步驟C、步驟D為控制map中資料的方法,實現簡單,可暫不關注。其中步驟B的getObject方法觸發對方法3)的呼叫;
c. 在方法3)中,先通過createBeanInstance例項化Teacher物件,又將該例項化的物件通過addSingletonFactory方法放入singletonFactories中,完成Teacher物件早期的暴露;
d. 然後在方法3)中通過populateBean方法對Teacher物件進行屬性的注入,發現它有一個Student屬性,則觸發getBean方法對Student進行初始化
e. 重複a、b、c步驟,只是此時要初始化的是Student物件
f. 走到d的時候,呼叫populateBean對Student物件進行屬性注入,發現它有一個Teacher屬性,則觸發getBean方法對Teacher進行初始化;
g. 對Teacher進行初始化,又來到a,但此時map已經不為空了,因為之前在c步驟中已經將Teacher例項放入了singletonFactories中,a中得到Teacher例項後返回;
h.完成f中對Student的初始化,繼而依次往上回溯完成Teacher的初始化;
完成Teacher的初始化後,Student的初始化就簡單了,因為map中已經存了這個單例。
至此,Spring迴圈依賴的總結分析結束,一句話來概括一下:Spring通過將例項化後的物件提前暴露給Spring容器中的singletonFactories,解決了迴圈依賴的問題。
以上就是本文的全部內容,希望對大家的學習有所幫助,也希望大家多多支援我們。