亚洲成Av人片在线观看不卡|中文字幕在线精品无码一区|国产精品福利午夜h视频|手机看片AV永久免费,91天堂在线视频,最新2021年偷拍精品视频,国产成人一区二区在线视频

您當前的位置 ：寧夏資訊網 > 資訊 >  內容正文
投稿

Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析!

寧夏資訊網 2020-11-20 04:36:16 來源： 閱讀：-

優(yōu)質文章，及時送達

Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析

編輯 | Java之間（gengecn）

來源 | tech.souyunku.com/?p=13107

在網上已經有跟多Bean的生命周期的博客，但是很多都是基于比較老的版本了，最近吧整個流程化成了一個流程圖。待會兒使用流程圖，說明以及代碼的形式來說明整個聲明周期的流程。注意因為代碼比較多，這里的流程圖只畫出了大概的流程，具體的可以深入代碼

一、獲取Bea

Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析

第一階段獲取Bean

這里的流程圖的入口在 AbstractBeanFactory類的doGetBean方法，這里可以配合前面的 getBean方法分析文章進行閱讀。主要流程就是

1、先處理Bean 的名稱，因為如果以“&”開頭的Bean名稱表示獲取的是對應的FactoryBean對象；

2、從緩存中獲取單例Bean，有則進一步判斷這個Bean是不是在創(chuàng)建中，如果是的就等待創(chuàng)建完畢，否則直接返回這個Bean對象

3、如果不存在單例Bean緩存，則先進行循環(huán)依賴的解析

4、解析完畢之后先獲取父類BeanFactory，獲取到了則調用父類的getBean方法，不存在則先合并然后創(chuàng)建Bean

二、創(chuàng)建Bean

2.1 創(chuàng)建Bean之前

Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析

在真正創(chuàng)建Bean之前邏輯

這個流程圖對應的代碼在 AbstractAutowireCapableBeanFactory類的createBean方法中。

1、這里會先獲取RootBeanDefinition對象中的Class對象并確保已經關聯(lián)了要創(chuàng)建的Bean的Class 。整編：微信公眾號，搜云庫技術團隊，ID：souyunku

2、這里會檢查3個條件

（1）Bean的屬性中的 beforeInstantiationResolved字段是否為true，默認是false。

（2）Bean是原生的Bean

（3）Bean的 hasInstantiationAwareBeanPostProcessors屬性為true，這個屬性在Spring準備刷新容器錢轉杯BeanPostProcessors的時候會設置，如果當前Bean實現(xiàn)了InstantiationAwareBeanPostProcessor則這個就會是true。

當三個條件都存在的時候，就會調用實現(xiàn)的 InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法，然后獲取返回的Bean，如果返回的Bean不是還會調用實現(xiàn)的BeanPostProcessor接口的postProcessAfterInitialization方法，這里用代碼說明

  1. protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
  2. Object bean = ;
  3. //條件1
  4. if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
  5. //條件2跟條件3
  6. if (!mbd.isSynthetic && hasInstantiationAwareBeanPostProcessors) {
  7. Class targetType = determineTargetType(beanName, mbd);
  8. if (targetType != ) {
  9. //調用實現(xiàn)的postProcessBeforeInstantiation方法
  10. bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
  11. if (bean != ) {
  12. //調用實現(xiàn)的postProcessAfterInitialization方法
  13. bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
  14. }
  15. }
  16. }
  17. //不滿足2或者3的時候就會設置為false
  18. mbd.beforeInstantiationResolved = (bean != );
  19. }
  20. return bean;
  21. }

1、如果上面3個條件其中一個不滿足就不會調用實現(xiàn)的方法。默認這里都不會調用的這些BeanPostProcessors的實現(xiàn)方法。然后繼續(xù)執(zhí)行后面的doCreateBean方法。

2.1 真正的創(chuàng)建Bean，doCreateBean

Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析

doCreateBean方法邏輯

這個代碼的實現(xiàn)還是在 AbstractAutowireCapableBeanFactory方法中。流程是

1、先檢查instanceWrapper變量是不是，這里一般是，除非當前正在創(chuàng)建的Bean在factoryBeanInstanceCache中存在這個是保存還沒創(chuàng)建完成的FactoryBean的集合。

2、調用createBeanInstance方法實例化Bean，這個方法在后面會講解

3、如果當前RootBeanDefinition對象還沒有調用過實現(xiàn)了的MergedBeanDefinitionPostProcessor接口的方法，則會進行調用 。整編：微信公眾號，搜云庫技術團隊，ID：souyunku

4、 當滿足以下三點

（1）是單例Bean

（2）嘗試解析bean之間的循環(huán)引用

（3）bean目前正在創(chuàng)建中

則會進一步檢查是否實現(xiàn)了 SmartInstantiationAwareBeanPostProcessor接口如果實現(xiàn)了則調用是實現(xiàn)的getEarlyBeanReference方法 5、 調用populateBean方法進行屬性填充，這里后面會講解 6、 調用initializeBean方法對Bean進行初始化，這里后面會講解

2.1.1 實例化Bean，createBeanInstance

Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析

實例化Bean

這里的邏輯稍微有一點復雜，這個流程圖已經是簡化過后的了。簡要根據(jù)代碼說明一下流程

  1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @ableObject[] args) {
  2. //步驟1
  3. Class beanClass = resolveBeanClass(mbd, beanName);

  4. if (beanClass !=  && !Modifier.isPublic(beanClass.getModifiers) && !mbd.isNonPublicAccessAllowed) {
  5. throw new BeanCreationException(mbd.getResourceDescription, beanName,
  6. "Bean class isn't public, and non-public access not allowed: "+ beanClass.getName);
  7. }
  8. //步驟2
  9. Supplier instanceSupplier = mbd.getInstanceSupplier;
  10. if (instanceSupplier != ) {
  11. return obtainFromSupplier(instanceSupplier, beanName);
  12. }
  13. //步驟3
  14. if (mbd.getFactoryMethodName != ) {
  15. return instantiateUsingFactoryMethod(beanName, mbd, args);
  16. }


  17. boolean resolved = false;
  18. boolean autowireNecessary = false;
  19. if (args == ) {
  20. synchronized (mbd.constructorArgumentLock) {
  21. if (mbd.resolvedConstructorOrFactoryMethod != ) {
  22. resolved = true;
  23. autowireNecessary = mbd.constructorArgumentsResolved;
  24. }
  25. }
  26. }
  27. //步驟4.1
  28. if (resolved) {

  29. if (autowireNecessary) {
  30. return autowireConstructor(beanName, mbd, , );
  31. }
  32. else {

  33. return instantiateBean(beanName, mbd);
  34. }
  35. }

  36. //步驟4.2
  37. Constructor ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  38. if (ctors !=  || mbd.getResolvedAutowireMode == AUTOWIRE_CONSTRUCTOR ||
  39. mbd.hasConstructorArgumentValues || !ObjectUtils.isEmpty(args)) {
  40. return autowireConstructor(beanName, mbd, ctors, args);
  41. }

  42. //步驟5
  43. ctors = mbd.getPreferredConstructors;
  44. if (ctors != ) {
  45. return autowireConstructor(beanName, mbd, ctors, );
  46. }


  47. return instantiateBean(beanName, mbd);
  48. }

1、先檢查Class是否已經關聯(lián)了，并且對應的修飾符是否是public的

2、如果用戶定義了Bean實例化的函數(shù)，則調用并返回

3、如果當前Bean實現(xiàn)了FactoryBean接口則調用對應的FactoryBean接口的getObject方法

4、根據(jù)getBean時候是否傳入構造參數(shù)進行處理

4.1如果沒有傳入構造參數(shù)，則檢查是否存在已經緩存的無參構造器，有則使用構造器直接創(chuàng)建，沒有就會調用instantiateBean方法先獲取實例化的策略默認是CglibSubclassingInstantiationStrategy，然后實例化Bean。最后返回

4.2如果傳入了構造參數(shù)，則會先檢查是否實現(xiàn)了SmartInstantiationAwareBeanPostProcessor接口，如果實現(xiàn)了會調用determineCandidateConstructors獲取返回的候選構造器。整編：微信公眾號，搜云庫技術團隊，ID：souyunku

4.3檢查4個條件是否滿足一個

（1）構造器不為，

（2）從RootBeanDefinition中獲取到的關聯(lián)的注入方式是構造器注入（沒有構造參數(shù)就是setter注入，有則是構造器注入）

（3）含有構造參數(shù)

（4）getBean方法傳入構造參數(shù)不是空

滿足其中一個則會調用返回的候選構造器實例化Bean并返回，如果都不滿足，則會根據(jù)構造參數(shù)選則合適的有參構造器然后實例化Bean并返回

5、如果上面都沒有合適的構造器，則直接使用無參構造器創(chuàng)建并返回Bean。

2.1.2 填充Bean，populateBean

Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析

填充Bean

這里還是根據(jù)代碼來說一下流程

  1. protected void populateBean(String beanName, RootBeanDefinition mbd, @ableBeanWrapper bw) {
  2. if (bw == ) {
  3. if (mbd.hasPropertyValues) {
  4. throw new BeanCreationException(
  5. mbd.getResourceDescription, beanName, "Cannot apply property values to instance");
  6. }
  7. else {
  8. // Skip property population phase for instance.
  9. return;
  10. }
  11. }


  12. boolean continueWithPropertyPopulation = true;
  13. //步驟1
  14. if (!mbd.isSynthetic && hasInstantiationAwareBeanPostProcessors) {
  15. for (BeanPostProcessor bp : getBeanPostProcessors) {
  16. if (bp instanceof InstantiationAwareBeanPostProcessor) {
  17. InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  18. if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance, beanName)) {
  19. continueWithPropertyPopulation = false;
  20. break;
  21. }
  22. }
  23. }
  24. }

  25. if (!continueWithPropertyPopulation) {
  26. return;
  27. }
  28. //步驟2--------------------
  29. PropertyValues pvs = (mbd.hasPropertyValues ? mbd.getPropertyValues : );

  30. int resolvedAutowireMode = mbd.getResolvedAutowireMode;
  31. if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  32. MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  33. // Add property values based on autowire by name if applicable.
  34. if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
  35. autowireByName(beanName, mbd, bw, newPvs);
  36. }
  37. // Add property values based on autowire by type if applicable.
  38. if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  39. autowireByType(beanName, mbd, bw, newPvs);
  40. }
  41. pvs = newPvs;
  42. }

  43. boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors;
  44. boolean needsDepCheck = (mbd.getDependencyCheck != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

  45. PropertyDescriptor filteredPds = ;
  46. //步驟3
  47. if (hasInstAwareBpps) {
  48. if (pvs == ) {
  49. pvs = mbd.getPropertyValues;
  50. }
  51. for (BeanPostProcessor bp : getBeanPostProcessors) {
  52. if (bp instanceof InstantiationAwareBeanPostProcessor) {
  53. InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  54. PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance, beanName);
  55. if (pvsToUse == ) {
  56. if (filteredPds == ) {
  57. filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  58. }
  59. pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance, beanName);
  60. if (pvsToUse == ) {
  61. return;
  62. }
  63. }
  64. pvs = pvsToUse;
  65. }
  66. }
  67. }
  68. if (needsDepCheck) {
  69. if (filteredPds == ) {
  70. filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  71. }
  72. checkDependencies(beanName, mbd, filteredPds, pvs);
  73. }
  74. //步驟4
  75. if (pvs != ) {
  76. applyPropertyValues(beanName, mbd, bw, pvs);
  77. }
  78. }

1、檢查當前Bean是否實現(xiàn)了InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法則調用，并結束Bean的填充。

2、將按照類型跟按照名稱注入的Bean分開，如果注入的Bean還沒有實例化的這里會實例化，然后放到PropertyValues對象中。

3、如果實現(xiàn)了InstantiationAwareBeanPostProcessor類的postProcessProperties則調用這個方法并獲取返回值，如果返回值是，則有可能是實現(xiàn)了過期的postProcessPropertyValues方法，這里需要進一步調用postProcessPropertyValues方法

4、進行參數(shù)填充

2.1.3 初始化Bean，initializeBean

Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析

初始化Bean

同時這里根據(jù)代碼跟流程圖來說明

1、如果Bean實現(xiàn)了BeanNameAware,BeanClassLoaderAware,BeanFactoryAware則調用對應實現(xiàn)的方法 。整編：微信公眾號，搜云庫技術團隊，ID：souyunku

2、Bean不為并且bean不是合成的，如果實現(xiàn)了BeanPostProcessor的postProcessBeforeInitialization則會調用實現(xiàn)的postProcessBeforeInitialization方法。在ApplicationContextAwareProcessor類中實現(xiàn)了postProcessBeforeInitialization方法。而這個類會在Spring刷新容器準備beanFactory的時候會加進去，這里就會被調用，而調用里面會檢查Bean是不是EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,ApplicationEventPublisherAware,MessageSourceAware,ApplicationContextAware的實現(xiàn)類。這里就會調用對應的實現(xiàn)方法。代碼如下

  1. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  2. .......
  3. beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  4. .......
  1. public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  2. if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
  3. bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
  4. bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
  5. return bean;
  6. }

  7. AccessControlContext acc = ;

  8. if (System.getSecurityManager != ) {
  9. acc = this.applicationContext.getBeanFactory.getAccessControlContext;
  10. }

  11. if (acc != ) {
  12. AccessController.doPrivileged((PrivilegedAction)  -> {
  13. invokeAwareInterfaces(bean);
  14. return ;
  15. }, acc);
  16. }
  17. else {
  18. invokeAwareInterfaces(bean);
  19. }

  20. return bean;
  21. }
    22. 1、實例化Bean然后，檢查是否實現(xiàn)了InitializingBean的afterPropertiesSet方法，如果實現(xiàn)了就會調用
    2、Bean不為并且bean不是合成的，如果實現(xiàn)了BeanPostProcessor的postProcessBeforeInitialization則會調用實現(xiàn)的postProcessAfterInitialization方法。
    到此創(chuàng)建Bean 的流程就沒了，剩下的就是容器銷毀的時候的了
    三、destory方法跟銷毀Bean
    歡迎關注公眾號：Java后端
    Bean在創(chuàng)建完畢之后會檢查用戶是否指定了 destroyMethodName以及是否實現(xiàn)了DestructionAwareBeanPostProcessor接口的requiresDestruction方法，如果指定了會記錄下來保存在DisposableBeanAdapter對象中并保存在bean的disposableBeans屬性中。代碼在AbstractBeanFactory的registerDisposableBeanIfNecessary中
    1. protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
    2. ......
    3. registerDisposableBean(beanName,
    4. new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors, acc));
    5. ......
    6. }
    1. public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
    2. List postProcessors, @ableAccessControlContext acc) {
    3. .......
    4. String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
    5. if (destroyMethodName !=  && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
    6. !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
    7. ......
    8. this.destroyMethod = destroyMethod;
    9. }
    10. this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
    11. }
    在銷毀Bean的時候最后都會調用 AbstractAutowireCapableBeanFactory的destroyBean方法。
    1. public void destroyBean(Object existingBean) {
    2. new DisposableBeanAdapter(existingBean, getBeanPostProcessors, getAccessControlContext).destroy;
    3. }
    這里是創(chuàng)建一個 DisposableBeanAdapter對象，這個對象實現(xiàn)了Runnable接口，在實現(xiàn)的run方法中會調用實現(xiàn)的DisposableBean接口的destroy方法。并且在創(chuàng)建DisposableBeanAdapter對象的時候會根據(jù)傳入的bean是否實現(xiàn)了DisposableBean接口來設置invokeDisposableBean變量，這個變量表實有沒有實現(xiàn)DisposableBean接口
    1. public DisposableBeanAdapter(Object bean, List postProcessors, AccessControlContext acc) {
    2. Assert.not(bean, "Disposable bean must not be ");
    3. this.bean = bean;
    4. this.beanName = bean.getClass.getName;
    5. //根據(jù)傳入的bean是否實現(xiàn)了`DisposableBean`接口來設置`invokeDisposableBean`變量
    6. this.invokeDisposableBean = (this.bean instanceof DisposableBean);
    7. this.nonPublicAccessAllowed = true;
    8. this.acc = acc;
    9. this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
    10. }

    11. public void destroy {
    12. ......
    13. //根據(jù)invokeDisposableBean決定是否調用destroy方法
    14. if (this.invokeDisposableBean) {
    15. if (logger.isTraceEnabled) {
    16. logger.trace("Invoking destroy on bean with name '"+ this.beanName +"'");
    17. }
    18. try {
    19. if (System.getSecurityManager != ) {
    20. AccessController.doPrivileged((PrivilegedExceptionAction)  -> {
    21. ((DisposableBean) this.bean).destroy;
    22. return ;
    23. }, this.acc);
    24. }
    25. else {
    26. ((DisposableBean) this.bean).destroy;
    27. }
    28. }
    29. catch (Throwable ex) {
    30. String msg = "Invocation of destroy method failed on bean with name '"+ this.beanName +"'";
    31. if (logger.isDebugEnabled) {
    32. logger.warn(msg, ex);
    33. }
    34. else {
    35. logger.warn(msg + ": "+ ex);
    36. }
    37. }
    38. }
    39. ......
    40. }
      41. 四、總結。
      最后來一個大的流程
      Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析
      實例化前的準備階段
      Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析
      實例化前
      Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析
      實例化后
      Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析
      初始化前
      Spring 的 Bean 生命周期，11 張高清流程圖及代碼，深度解析
      -END-
      
        
      （正文已結束）
      
        
      
		
      推薦閱讀：天津紅橋網
      
		
      

      免責聲明及提醒：此文內容為本網所轉載企業(yè)宣傳資訊，該相關信息僅為宣傳及傳遞更多信息之目的，不代表本網站觀點，文章真實性請瀏覽者慎重核實！任何投資加盟均有風險，提醒廣大民眾投資需謹慎！
      

    
     
    
    
  
  
 

 
      
    
      Copyright.2002-2019 寧夏資訊網 版權所有 本網拒絕一切非法行為 歡迎監(jiān)督舉報 如有錯誤信息 歡迎糾正 
      
    

      

      







潍坊市|
长沙市|
合川市|
交城县|
青阳县|
信丰县|
商城县|
寻乌县|
广饶县|
子长县|
东乌珠穆沁旗|
炎陵县|
临沧市|
宁化县|
岑溪市|
金阳县|
苗栗县|
繁峙县|
峨山|
仁化县|
平昌县|
金华市|
定远县|
永年县|
丰城市|
双江|
东城区|
沈丘县|
兴海县|
浦东新区|
炉霍县|
斗六市|
当雄县|
浦北县|
永泰县|
龙胜|
习水县|
鄂托克旗|
曲阜市|
渑池县|
闸北区|