當前位置: 泰州之窗首頁 > 汽車 > 正文

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

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

優質文章,及時送達編輯 | Java之間(gengecn)來源 | tech.souyunku.com/?p=13107在網上已經有跟多Bean的生命周期的博客,但是很多都是基于比較老的版本了,最近吧整個流程化成了一個流程圖。

優質文章,及時送達

編輯 | Java之間(gengecn)

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

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

一、獲取Bea

第一階段獲取Bean

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

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

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

3、如果不存在單例Bean緩存,則先進行循環依賴的解析

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

二、創建Bean

2.1 創建Bean之前

在真正創建Bean之前邏輯

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

1、這里會先獲取RootBeanDefinition對象中的Class對象并確保已經關聯了要創建的Bean的Class 。整編:微信公眾號,搜云庫技術團隊,ID:souyunku

2、這里會檢查3個條件

(1)Bean的屬性中的 beforeInstantiationResolved字段是否為true,默認是false。

(2)Bean是原生的Bean

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

當三個條件都存在的時候,就會調用實現的 InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法,然后獲取返回的Bean,如果返回的Bean不是還會調用實現的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. //調用實現的postProcessBeforeInstantiation方法

  10. bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);

  11. if (bean != ) {

  12. //調用實現的postProcessAfterInitialization方法

  13. bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);

  14. }

  15. }

  16. }

  17. //不滿足2或者3的時候就會設置為false

  18. mbd.beforeInstantiationResolved = (bean != );

  19. }

  20. return bean;

  21. }

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

2.1 真正的創建Bean,doCreateBean

doCreateBean方法邏輯

這個代碼的實現還是在 AbstractAutowireCapableBeanFactory方法中。流程是

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

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

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

4、 當滿足以下三點

(1)是單例Bean

(2)嘗試解析bean之間的循環引用

(3)bean目前正在創建中

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

2.1.1 實例化Bean,createBeanInstance

實例化Bean

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

  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是否已經關聯了,并且對應的修飾符是否是public的

2、如果用戶定義了Bean實例化的函數,則調用并返回

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

4、根據getBean時候是否傳入構造參數進行處理

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

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

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

(1)構造器不為,

(2)從RootBeanDefinition中獲取到的關聯的注入方式是構造器注入(沒有構造參數就是setter注入,有則是構造器注入)

(3)含有構造參數

(4)getBean方法傳入構造參數不是空

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

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

2.1.2 填充Bean,populateBean

填充Bean

這里還是根據代碼來說一下流程

  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是否實現了InstantiationAwareBeanPostProcessorpostProcessAfterInstantiation方法則調用,并結束Bean的填充。

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

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

4、進行參數填充

2.1.3 初始化Bean,initializeBean

初始化Bean

同時這里根據代碼跟流程圖來說明

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

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

  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<Object>) -> {

  13. invokeAwareInterfaces(bean);

  14. return ;

  15. }, acc);

  16. }

  17. else {

  18. invokeAwareInterfaces(bean);

  19. }


  20. return bean;

  21. }

1、實例化Bean然后,檢查是否實現了InitializingBeanafterPropertiesSet方法,如果實現了就會調用

2、Bean不為并且bean不是合成的,如果實現了BeanPostProcessorpostProcessBeforeInitialization則會調用實現的postProcessAfterInitialization方法。

到此創建Bean 的流程就沒了,剩下的就是容器銷毀的時候的了

三、destory方法跟銷毀Bean

歡迎關注公眾號:Java后端

Bean在創建完畢之后會檢查用戶是否指定了 destroyMethodName以及是否實現了DestructionAwareBeanPostProcessor接口的requiresDestruction方法,如果指定了會記錄下來保存在DisposableBeanAdapter對象中并保存在bean的disposableBeans屬性中。代碼在AbstractBeanFactoryregisterDisposableBeanIfNecessary

  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<BeanPostProcessor> 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的時候最后都會調用 AbstractAutowireCapableBeanFactorydestroyBean方法。

  1. public void destroyBean(Object existingBean) {

  2. new DisposableBeanAdapter(existingBean, getBeanPostProcessors, getAccessControlContext).destroy;

  3. }

這里是創建一個 DisposableBeanAdapter對象,這個對象實現了Runnable接口,在實現的run方法中會調用實現的DisposableBean接口的destroy方法。并且在創建DisposableBeanAdapter對象的時候會根據傳入的bean是否實現了DisposableBean接口來設置invokeDisposableBean變量,這個變量表實有沒有實現DisposableBean接口

  1. public DisposableBeanAdapter(Object bean, List<BeanPostProcessor> postProcessors, AccessControlContext acc) {

  2. Assert.not(bean, "Disposable bean must not be ");

  3. this.bean = bean;

  4. this.beanName = bean.getClass.getName;

  5. //根據傳入的bean是否實現了`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. //根據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<Object>) -> {

  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. }

四、總結。

最后來一個大的流程

實例化前的準備階段

實例化前

實例化后

初始化前

-END-

推薦閱讀:小米新款電動車

[責任編輯:無]
正规男模特赚钱吗 燕赵排列七开奖结果 沪市股票代码 辉煌棋牌只输不赢 吉林11选5遗漏数据 35选7是什么彩票 东方6 1五加一多少钱 刮刮乐可看透的技巧 安徽安庆闲来麻将 街机1000千炮捕鱼 欢乐斗棋牌斗牛咋没