在網上已經有跟多Bean的生命周期的博客，但是很多都是基于比較老的版本了，最近吧整個流程化成了一個流程圖，待會兒使用流程圖，說明以及代碼的形式來說明整個宣告周期的流程，注意因為代碼比較多，這里的流程圖只畫出了大概的流程，具體的可以深入代碼Java面試寶典完整版PDF
1.獲取Bean
?
第一階段獲取Bean
?這里的流程圖的入口在AbstractBeanFactory類的doGetBean方法，主要流程就是
- 先處理Bean 的名稱，因為如果以“&”開頭的Bean名稱表示獲取的是對應的FactoryBean物件；
- 從快取中獲取單例Bean，有則進一步判斷這個Bean是不是在創建中，如果是的就等待創建完畢，否則直接回傳這個Bean物件
- 如果不存在單例Bean快取，則先進行回圈依賴的決議
- 決議完畢之后先獲取父類BeanFactory，獲取到了則呼叫父類的getBean方法，不存在則先合并然后創建Bean
2.創建Bean
2.1 創建Bean之前
?
在真正創建Bean之前邏輯
?這個流程圖對應的代碼在AbstractAutowireCapableBeanFactory類的createBean方法中，
-
這里會先獲取
RootBeanDefinition物件中的Class物件并確保已經關聯了要創建的Bean的Class， -
這里會檢查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; }
-
如果上面3個條件其中一個不滿足就不會呼叫實作的方法，默認這里都不會呼叫的這些
BeanPostProcessors的實作方法，然后繼續執行后面的doCreateBean方法，
2.1 真正的創建Bean，doCreateBean
?
doCreateBean方法邏輯
這個代碼的實作還是在AbstractAutowireCapableBeanFactory方法中，流程是
- 先檢查
instanceWrapper變數是不是null，這里一般是null，除非當前正在創建的Bean在factoryBeanInstanceCache中存在這個是保存還沒創建完成的FactoryBean的集合， - 呼叫createBeanInstance方法實體化Bean，這個方法在后面會講解
- 如果當前
RootBeanDefinition物件還沒有呼叫過實作了的MergedBeanDefinitionPostProcessor介面的方法，則會進行呼叫 - 當滿足以下三點
（1）是單例Bean
（2）嘗試決議bean之間的回圈參考
（3）bean目前正在創建中
則會進一步檢查是否實作了SmartInstantiationAwareBeanPostProcessor介面如果實作了則呼叫是實作的getEarlyBeanReference方法 - 呼叫
populateBean方法進行屬性填充，這里后面會講解 - 呼叫
initializeBean方法對Bean進行初始化，這里后面會講解
2.1.1 實體化Bean，createBeanInstance
?
實體化Bean
?這里的邏輯稍微有一點復雜，這個流程圖已經是簡化過后的了，簡要根據代碼說明一下流程
beanClass = resolveBeanClass(mbd, beanName);\n\n if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {\n throw new BeanCreationException(mbd.getResourceDescription(), beanName,\n \"Bean class isn't public, and non-public access not allowed: \" + beanClass.getName());\n }\n //步驟2\n Supplier<?> instanceSupplier = mbd.getInstanceSupplier();\n if (instanceSupplier != null) {\n return obtainFromSupplier(instanceSupplier, beanName);\n }\n //步驟3\n if (mbd.getFactoryMethodName() != null) {\n return instantiateUsingFactoryMethod(beanName, mbd, args);\n }\n\n\n boolean resolved = false;\n boolean autowireNecessary = false;\n if (args == null) {\n synchronized (mbd.constructorArgumentLock) {\n if (mbd.resolvedConstructorOrFactoryMethod != null) {\n resolved = true;\n autowireNecessary = mbd.constructorArgumentsResolved;\n }\n }\n }\n //步驟4.1\n if (resolved) {\n \n if (autowireNecessary) {\n return autowireConstructor(beanName, mbd, null, null);\n }\n else {\n \n return instantiateBean(beanName, mbd);\n }\n }\n\n //步驟4.2\n Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);\n if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||\n mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {\n return autowireConstructor(beanName, mbd, ctors, args);\n }\n\n //步驟5\n ctors = mbd.getPreferredConstructors();\n if (ctors != null) {\n return autowireConstructor(beanName, mbd, ctors, null);\n }\n\n \n return instantiateBean(beanName, mbd);\n }\n","classes":[],"lang":""}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet"> 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);
}
- 先檢查Class是否已經關聯了，并且對應的修飾符是否是public的
- 如果用戶定義了Bean實體化的函式，則呼叫并回傳
- 如果當前Bean實作了
FactoryBean介面則呼叫對應的FactoryBean介面的getObject方法 - 根據getBean時候是否傳入構造引數進行處理
4.1 如果沒有傳入構造引數，則檢查是否存在已經快取的無參構造器，有則使用構造器直接創建，沒有就會呼叫instantiateBean方法先獲取實體化的策略默認是CglibSubclassingInstantiationStrategy，然后實體化Bean，最后回傳
4.2 如果傳入了構造引數，則會先檢查是否實作了SmartInstantiationAwareBeanPostProcessor介面，如果實作了會呼叫determineCandidateConstructors獲取回傳的候選構造器，
4.3 檢查4個條件是否滿足一個
（1）構造器不為null，
（2）從RootBeanDefinition中獲取到的關聯的注入方式是構造器注入（沒有構造引數就是setter注入，有則是構造器注入）
（3）含有構造引數
（4）getBean方法傳入構造引數不是空
滿足其中一個則會呼叫回傳的候選構造器實體化Bean并回傳，如果都不滿足，則會根據構造引數選則合適的有參構造器然后實體化Bean并回傳 - 如果上面都沒有合適的構造器，則直接使用無參構造器創建并回傳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);
}
}
- 檢查當前Bean是否實作了
InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法則呼叫，并結束Bean的填充， - 將按照型別跟按照名稱注入的Bean分開，如果注入的Bean還沒有實體化的這里會實體化，然后放到
PropertyValues物件中， - 如果實作了
InstantiationAwareBeanPostProcessor類的postProcessProperties則呼叫這個方法并獲取回傳值，如果回傳值是null，則有可能是實作了過期的postProcessPropertyValues方法，這里需要進一步呼叫postProcessPropertyValues方法 - 進行引數填充
2.1.3 初始化Bean，initializeBean
?
初始化Bean
同時這里根據代碼跟流程圖來說明
-
如果Bean實作了
BeanNameAware,BeanClassLoaderAware,BeanFactoryAware則呼叫對應實作的方法 -
Bean不為null并且bean不是合成的，如果實作了
BeanPostProcessor的postProcessBeforeInitialization則會呼叫實作的postProcessBeforeInitialization方法，在ApplicationContextAwareProcessor類中實作了postProcessBeforeInitialization方法，而這個類會在Spring重繪容器準備beanFactory的時候會加進去，這里就會被呼叫，而呼叫里面會檢查Bean是不是EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware,ApplicationEventPublisherAware,MessageSourceAware,ApplicationContextAware的實作類，這里就會呼叫對應的實作方法，代碼如下) () -> {/n invokeAwareInterfaces(bean);/n return null;/n }, acc);/n }/n else {/n invokeAwareInterfaces(bean);/n }/n/n return bean;/n}/n","classes":[],"lang":""}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet">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; }
-
實體化Bean然后，檢查是否實作了
InitializingBean的afterPropertiesSet方法，如果實作了就會呼叫 -
Bean不為null并且bean不是合成的，如果實作了
BeanPostProcessor的postProcessBeforeInitialization則會呼叫實作的postProcessAfterInitialization方法，
到此創建Bean 的流程就沒了，剩下的就是容器銷毀的時候的了
3.destory方法跟銷毀Bean
?Bean在創建完畢之后會檢查用戶是否指定了destroyMethodName以及是否實作了DestructionAwareBeanPostProcessor介面的requiresDestruction方法，如果指定了會記錄下來保存在DisposableBeanAdapter物件中并保存在bean的disposableBeans屬性中，代碼在AbstractBeanFactory的registerDisposableBeanIfNecessary中
postProcessors, @Nullable AccessControlContext acc) {/n ......./n String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);/n if (destroyMethodName != null && !(this.invokeDisposableBean && /"destroy/".equals(destroyMethodName)) &&/n !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {/n ....../n this.destroyMethod = destroyMethod;/n }/n this.beanPostProcessors = filterPostProcessors(postProcessors, bean);/n }/n","classes":[],"lang":""}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet"> 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介面
postProcessors, AccessControlContext acc) {/n Assert.notNull(bean, /"Disposable bean must not be null/");/n this.bean = bean;/n this.beanName = bean.getClass().getName();/n //根據傳入的bean是否實作了`DisposableBean`介面來設定`invokeDisposableBean`變數/n this.invokeDisposableBean = (this.bean instanceof DisposableBean);/n this.nonPublicAccessAllowed = true;/n this.acc = acc;/n this.beanPostProcessors = filterPostProcessors(postProcessors, bean);/n }/n/n public void destroy() {/n ....../n //根據invokeDisposableBean決定是否呼叫destroy方法/n if (this.invokeDisposableBean) {/n if (logger.isTraceEnabled()) {/n logger.trace(/"Invoking destroy() on bean with name'\" + this.beanName + \"'\");\n }\n try {\n if (System.getSecurityManager() != null) {\n AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {\n ((DisposableBean) this.bean).destroy();\n return null;\n }, this.acc);\n }\n else {\n ((DisposableBean) this.bean).destroy();\n }\n }\n catch (Throwable ex) {\n String msg = \"Invocation of destroy method failed on bean with name '\" + this.beanName + \"'\";\n if (logger.isDebugEnabled()) {\n logger.warn(msg, ex);\n }\n else {\n logger.warn(msg + \": \" + ex);\n }\n }\n }\n......\n }\n","classes":[],"lang":""}" data-cke-widget-upcasted="1" data-cke-widget-keep-attr="0" data-widget="codeSnippet"> 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);
}
}
}
......
}
4.總結，
最后來一個大的流程
?
實體化前的準備階段
?
實體化前
?
實體化后
?
初始化前Java面試寶典完整版PDF
?
初始化之后+銷毀
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/252448.html
標籤：Java
下一篇：ArrayList詳解