在網上已經有跟多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 。
2、這裡會檢查3個條件
(1)Bean的屬性中的 beforeInstantiationResolved欄位是否為true,默認是false。
(2)Bean是原生的Bean
(3)Bean的 hasInstantiationAwareBeanPostProcessors屬性為true,這個屬性在Spring準備刷新容器錢轉杯BeanPostProcessors的時候會設置,如果當前Bean實現了InstantiationAwareBeanPostProcessor則這個就會是true。
當三個條件都存在的時候,就會調用實現的 InstantiationAwareBeanPostProcessor接口的 postProcessBeforeInstantiation方法,然後獲取返回的Bean,如果返回的Bean不是null還會調用實現的 BeanPostProcessor接口的 postProcessAfterInitialization方法,這裡用代碼說明
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) { Object bean = null; //條件1 if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) { //條件2跟條件3 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { Class<?> targetType = determineTargetType(beanName, mbd); if (targetType != null) { //調用實現的postProcessBeforeInstantiation方法 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) {//調用實現的postProcessAfterInitialization方法 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); } } } //不滿足2或者3的時候就會設置為false mbd.beforeInstantiationResolved = (bean != null); } return bean; }
1、如果上面3個條件其中一個不滿足就不會調用實現的方法。默認這裡都不會調用的這些 BeanPostProcessors的實現方法。然後繼續執行後面的 doCreateBean方法。
2.1 真正的創建Bean,doCreateBean
doCreateBean方法邏輯
這個代碼的實現還是在 AbstractAutowireCapableBeanFactory方法中。流程是
1、先檢查 instanceWrapper變量是不是null,這裡一般是null,除非當前正在創建的Bean在 factoryBeanInstanceCache中存在這個是保存還沒創建完成的FactoryBean的集合。
3、如果當前 RootBeanDefinition對象還沒有調用過實現了的 MergedBeanDefinitionPostProcessor接口的方法,則會進行調用 。
4、 當滿足以下三點
(1)是單例Bean
(2)嘗試解析bean之間的循環引用
(3)bean目前正在創建中
則會進一步檢查是否實現了 SmartInstantiationAwareBeanPostProcessor接口如果實現了則調用是實現的 getEarlyBeanReference方法 5、 調用 populateBean方法進行屬性填充,這裡後面會講解 6、 調用 initializeBean方法對Bean進行初始化,這裡後面會講解
2.1.1 實例化Bean,createBeanInstance
實例化Bean
這裡的邏輯稍微有一點複雜,這個流程圖已經是簡化過後的了。簡要根據代碼說明一下流程
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { //步驟1 Class<?> beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); } //步驟2 Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName); } //步驟3 if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args); }
boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } //步驟4.1 if (resolved) {
if (autowireNecessary) { return autowireConstructor(beanName, mbd, null, null); } else {
return instantiateBean(beanName, mbd); } }
//步驟4.2 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); }
//步驟5 ctors = mbd.getPreferredConstructors(); if (ctors != null) { return autowireConstructor(beanName, mbd, ctors, null); }
return instantiateBean(beanName, mbd); }
1、先檢查Class是否已經關聯了,並且對應的修飾符是否是public的
2、如果用戶定義了Bean實例化的函數,則調用並返回
3、如果當前Bean實現了 FactoryBean接口則調用對應的 FactoryBean接口的 getObject方法
4、根據getBean時候是否傳入構造參數進行處理
4.1 如果沒有傳入構造參數,則檢查是否存在已經緩存的無參構造器,有則使用構造器直接創建,沒有就會調用 instantiateBean方法先獲取實例化的策略默認是 CglibSubclassingInstantiationStrategy,然後實例化Bean。最後返回
4.2 如果傳入了構造參數,則會先檢查是否實現了 SmartInstantiationAwareBeanPostProcessor接口,如果實現了會調用 determineCandidateConstructors獲取返回的候選構造器。
4.3 檢查4個條件是否滿足一個
(1)構造器不為null,
(2)從RootBeanDefinition中獲取到的關聯的注入方式是構造器注入(沒有構造參數就是setter注入,有則是構造器注入)
(3)含有構造參數
(4)getBean方法傳入構造參數不是空
滿足其中一個則會調用返回的候選構造器實例化Bean並返回,如果都不滿足,則會根據構造參數選則合適的有參構造器然後實例化Bean並返回
5、如果上面都沒有合適的構造器,則直接使用無參構造器創建並返回Bean。
2.1.2 填充Bean,populateBean
填充Bean
這裡還是根據代碼來說一下流程
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { if (mbd.hasPropertyValues()) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance"); } else { // Skip property population phase for null instance. return; } }
boolean continueWithPropertyPopulation = true; //步驟1 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false; break; } } } }
if (!continueWithPropertyPopulation) { return; }//步驟2-------------------- PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode(); if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) { MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // Add property values based on autowire by name if applicable. if (resolvedAutowireMode == AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // Add property values based on autowire by type if applicable. if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; }
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;//步驟3 if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); } for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } } if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } checkDependencies(beanName, mbd, filteredPds, pvs); }//步驟4 if (pvs != null) { applyPropertyValues(beanName, mbd, bw, pvs); } }
1、檢查當前Bean是否實現了 InstantiationAwareBeanPostProcessor的 postProcessAfterInstantiation方法則調用,並結束Bean的填充。
2、將按照類型跟按照名稱注入的Bean分開,如果注入的Bean還沒有實例化的這裡會實例化,然後放到 PropertyValues對象中。
3、如果實現了 InstantiationAwareBeanPostProcessor類的 postProcessProperties則調用這個方法並獲取返回值,如果返回值是null,則有可能是實現了過期的 postProcessPropertyValues方法,這裡需要進一步調用 postProcessPropertyValues方法
4、進行參數填充
2.1.3 初始化Bean,initializeBean
初始化Bean
同時這裡根據代碼跟流程圖來說明
1、如果Bean實現了 BeanNameAware, BeanClassLoaderAware, BeanFactoryAware則調用對應實現的方法 。
2、Bean不為null並且bean不是合成的,如果實現了 BeanPostProcessor的 postProcessBeforeInitialization則會調用實現的 postProcessBeforeInitialization方法。在 ApplicationContextAwareProcessor類中實現了
postProcessBeforeInitialization方法。而這個類會在Spring刷新容器準備 beanFactory的時候會加進去,這裡就會被調用,而調用裡面會檢查Bean是不是 EnvironmentAware, EmbeddedValueResolverAware, ResourceLoaderAware, ApplicationEventPublisherAware,
MessageSourceAware, ApplicationContextAware的實現類。這裡就會調用對應的實現方法。代碼如下
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { ....... beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); .......
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware || bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware || bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){ return bean; }
AccessControlContext acc = null;
if (System.getSecurityManager() != null) { acc = this.applicationContext.getBeanFactory().getAccessControlContext(); }
if (acc != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareInterfaces(bean); return null; }, acc); } else { invokeAwareInterfaces(bean); }
return bean; }
1、實例化Bean然後,檢查是否實現了 InitializingBean的 afterPropertiesSet方法,如果實現了就會調用
2、Bean不為null並且bean不是合成的,如果實現了 BeanPostProcessor的 postProcessBeforeInitialization則會調用實現的 postProcessAfterInitialization方法。
到此創建Bean 的流程就沒了,剩下的就是容器銷毀的時候的了
三、destory方法跟銷毀Bean
Bean在創建完畢之後會檢查用戶是否指定了 destroyMethodName以及是否實現了 DestructionAwareBeanPostProcessor接口的 requiresDestruction方法,如果指定了會記錄下來保存在 DisposableBeanAdapter對象中並保存在bean的 disposableBeans屬性中。代碼在 AbstractBeanFactory的 registerDisposableBeanIfNecessary中
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) { ...... registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc)); ...... }
public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition, List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) { ....... String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition); if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) && !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) { ...... this.destroyMethod = destroyMethod; } this.beanPostProcessors = filterPostProcessors(postProcessors, bean); }
在銷毀Bean的時候最後都會調用 AbstractAutowireCapableBeanFactory的 destroyBean方法。
public void destroyBean(Object existingBean) { new DisposableBeanAdapter(existingBean, getBeanPostProcessors(), getAccessControlContext()).destroy(); }
這裡是創建一個 DisposableBeanAdapter對象,這個對象實現了Runnable接口,在實現的 run方法中會調用實現的 DisposableBean接口的 destroy方法。並且在創建 DisposableBeanAdapter對象的時候會根據傳入的bean是否實現了 DisposableBean接口來設置 invokeDisposableBean變量,這個變量表實有沒有實現 DisposableBean接口
public DisposableBeanAdapter(Object bean, List<BeanPostProcessor> postProcessors, AccessControlContext acc) { Assert.notNull(bean, "Disposable bean must not be null"); this.bean = bean; this.beanName = bean.getClass().getName(); //根據傳入的bean是否實現了`DisposableBean`接口來設置`invokeDisposableBean`變量 this.invokeDisposableBean = (this.bean instanceof DisposableBean); this.nonPublicAccessAllowed = true; this.acc = acc; this.beanPostProcessors = filterPostProcessors(postProcessors, bean); }
public void destroy() { ...... //根據invokeDisposableBean決定是否調用destroy方法 if (this.invokeDisposableBean) { if (logger.isTraceEnabled()) { logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'"); } try { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> { ((DisposableBean) this.bean).destroy(); return null; }, this.acc); } else { ((DisposableBean) this.bean).destroy(); } } catch (Throwable ex) { String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'"; if (logger.isDebugEnabled()) { logger.warn(msg, ex); } else { logger.warn(msg + ": " + ex); } } }...... }