Spring源碼解析之Bean的生命周期
一、Bean的實(shí)例化概述
前一篇分析了BeanDefinition的封裝過程,最終將beanName與BeanDefinition以一對(duì)一映射關(guān)系放到beanDefinitionMap容器中,這一篇重點(diǎn)分析如何利用bean的定義信息BeanDefinition實(shí)例化bean。
二、流程概覽
其實(shí)bean的實(shí)例化過程比較復(fù)雜,中間細(xì)節(jié)很多,為了抓住重點(diǎn),先將核心流程梳理出來,主要包含以下幾個(gè)流程:
step1
: 通過反射創(chuàng)建實(shí)例;step2
:給實(shí)例屬性賦初始值;step3
:如果Bean類實(shí)現(xiàn)BeanNameAware接口,則將通過傳遞Bean的名稱來調(diào)用setBeanName()方法;如果Bean類實(shí)現(xiàn)BeanClassLoaderAware接口,則將通過傳遞加載此Bean的ClassLoader對(duì)象的實(shí)例來調(diào)用setBeanClassLoader()方法;如果Bean類實(shí)現(xiàn)BeanFactoryAware接口,則將通過傳遞BeanFactory對(duì)象的實(shí)例來調(diào)用setBeanFactory()方法;step4
: 如果有類實(shí)現(xiàn)BeanPostProcessors接口,則將在初始化之前調(diào)用postProcessBeforeInitialization()方法;step5
:如果Bean類實(shí)現(xiàn)了InitializingBean接口,將調(diào)用afterPropertiesSet()方法,如果配置文件中的Bean定義包含init-method屬性,則該屬性的值將解析為Bean類中的方法名稱,并將調(diào)用該方法;step6
: 如果有類實(shí)現(xiàn)BeanPostProcessors接口,則將在初始化之后調(diào)用postProcessAfterInitialization()方法;step7
:如果Bean類實(shí)現(xiàn)DisposableBean接口,則當(dāng)Application不再需要Bean引用時(shí),將調(diào)用destroy()方法;如果配置文件中的Bean定義包含destroy-method屬性,那么將調(diào)用Bean類中的相應(yīng)方法定義。
三、源碼分析
進(jìn)入AbstractApplicationContext中的fresh()方法,找到finishBeanFactoryInitialization(beanFactory)方法,該類是bean的實(shí)例化的入口,具體的實(shí)例化由preInstantiateSingletons()方法觸發(fā),見如下代碼:
public void preInstantiateSingletons() throws BeansException if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. //xml解析時(shí),把所有beanName都緩存到beanDefinitionNames了 List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { //把父BeanDefinition里面的屬性拿到子BeanDefinition中 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); //如果不是抽象的,單例的,非懶加載的就實(shí)例化 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //判斷bean是否實(shí)現(xiàn)了FactoryBean接口 if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged( (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { // 實(shí)例化過程 getBean(beanName); } } }
上述代碼主要看getBean
方法,隨后進(jìn)入doGetBean
方法:
protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { String beanName = transformedBeanName(name); Object bean; // 從緩存中獲取bean. Object sharedInstance = getSingleton(beanName); if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { markBeanAsCreated(beanName); } try { RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } registerDependentBean(dep, beanName); try { getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // Create bean instance // 創(chuàng)建bean實(shí)例 if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { 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); } ... }
由上述代碼可知,先從緩存中獲取bean,如果沒有,則創(chuàng)建bean,最重要的方法就是getSingleton,該方法第二個(gè)參數(shù)是個(gè)函數(shù)式接口,進(jìn)入getSingleton方法,當(dāng)調(diào)用singletonObject = singletonFactory.getObject()
時(shí),會(huì)觸發(fā)函數(shù)式接口中的createBean方法,隨后一路進(jìn)入doCreateBean,這個(gè)方法里面完成了所有實(shí)例化所需的步驟:
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. // 真正開始創(chuàng)建bean的實(shí)例. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class<?> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); } addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); } // Initialize the bean instance. Object exposedObject = bean; try { // 屬性賦值 populateBean(beanName, mbd, instanceWrapper); // 初始化bean exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. // 有必要時(shí),注冊bean的銷毀 try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
從上述源碼中看出bean的實(shí)例化主要分為以下三步:
step1
:bean的創(chuàng)建;step2
:給bean的屬性賦值;step3
:bean的初始化;
接著得到exposedObject這個(gè)已經(jīng)完全實(shí)例化后的bean返回,其中當(dāng)有必要時(shí),注冊bean的銷毀,后面再詳細(xì)看,先抓住主要流程。其中step3也是比較重要的方法,進(jìn)入該方法:
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { // 激活aware接口 invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 初始化前處理的beanPostProcessor wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { // 激活 init-method方法 invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { // 初始化后處理的beanPostProcessor wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }
從上面源碼可知,梳理出主要的四個(gè)步驟:
step1
:激活aware接口,完成aware接口的相關(guān)操作;step2
:初始化前處理的beanPostProcessor;step3
:完成init-method方法;step4
:初始化后處理的beanPostProcessor;
BeanPostProcessor作用是對(duì)初始化后的bean進(jìn)行增強(qiáng)處理,在該階段 BeanPostProcessor 會(huì)處理當(dāng)前容器內(nèi)所有符合條件的實(shí)例化后的 bean 對(duì)象。它主要是對(duì) Spring 容器提供的 bean 實(shí)例對(duì)象進(jìn)行有效的擴(kuò)展,允許Spring在初始化 bean 階段對(duì)其進(jìn)行定制化修改,如處理標(biāo)記接口或者為其提供代理實(shí)現(xiàn)。
四、演示
定義一個(gè)MyBeanPostProcessor實(shí)現(xiàn)BeanPostProcessor接口
public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("post Process Before Initialization 被調(diào)用..."); return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { System.out.println("post Process after Initialization 被調(diào)用..."); return bean; } }
定義一個(gè)LifeCycleBean類,實(shí)現(xiàn)如下接口:
public class LifeCycleBean implements BeanNameAware, BeanFactoryAware, BeanClassLoaderAware, InitializingBean, DisposableBean { private String property; public String getProperty() { return property; } public void setProperty(String property) { System.out.println("屬性注入...."); this.property = property; } public LifeCycleBean(){ System.out.println("構(gòu)造函數(shù)調(diào)用..."); } @Override public void setBeanClassLoader(ClassLoader classLoader) { System.out.println("BeanClassLoaderAware 被調(diào)用..."); } @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { System.out.println("BeanFactoryAware 被調(diào)用..."); } @Override public void setBeanName(String name) { System.out.println("BeanNameAware 被調(diào)用..."); } @Override public void destroy() throws Exception { System.out.println("DisposableBean destroy 被調(diào)用..."); } @Override public void afterPropertiesSet() throws Exception { System.out.println("InitializingBean afterPropertiesSet 被調(diào)用..."); } public void initMethod(){ System.out.println("init-method 被調(diào)用..."); } public void destroyMethod(){ System.out.println("destroy-method 被調(diào)用..."); } public void display(){ System.out.println("方法調(diào)用..."); } }
指定配置文件spring.xml,配置init-method
與destroy-method
方法
<bean id="lifeCycle" class="com.wzj.bean.LifeCycleBean" init-method="initMethod" destroy-method="destroyMethod"> <property name="property" value="property"/> </bean> <bean id="myBeanPostProcessor" class="com.wzj.bean.MyBeanPostProcessor" > </bean>
測試類如下:
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = {"classpath:spring.xml"}) public class TestSpring { @Test public void testLifeCycleBean() { ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); }
執(zhí)行結(jié)果:
構(gòu)造函數(shù)調(diào)用...
屬性注入....
BeanNameAware 被調(diào)用...
BeanClassLoaderAware 被調(diào)用...
BeanFactoryAware 被調(diào)用...
post Process Before Initialization 被調(diào)用...
InitializingBean afterPropertiesSet 被調(diào)用...
init-method 被調(diào)用...
post Process after Initialization 被調(diào)用...
DisposableBean destroy 被調(diào)用...
destroy-method 被調(diào)用...
五、總結(jié)
本篇從一個(gè)初學(xué)者的角度概覽了bean的整個(gè)生命周期,并描述了其中的主要流程,閱讀源碼的初始階段,優(yōu)先抓住主要流程,別陷入細(xì)節(jié),并通過跑案例、寫注解、畫流程圖等方式加深理解,后續(xù)將繼續(xù)分析bean實(shí)例化中的核心流程、設(shè)計(jì)思想等。
到此這篇關(guān)于Spring源碼解析之Bean的生命周期的文章就介紹到這了,更多相關(guān)Bean的生命周期內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家!
相關(guān)文章
SpringBoot通知機(jī)制的實(shí)現(xiàn)方式
這篇文章主要介紹了SpringBoot通知機(jī)制的實(shí)現(xiàn)方式,具有很好的參考價(jià)值,希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教2021-07-07Java實(shí)現(xiàn)同步枚舉類數(shù)據(jù)到數(shù)據(jù)庫
這篇文章主要為大家詳細(xì)介紹了Java實(shí)現(xiàn)同步枚舉類數(shù)據(jù)到數(shù)據(jù)庫,文中示例代碼介紹的非常詳細(xì),具有一定的參考價(jià)值,感興趣的小伙伴們可以參考一下2022-08-08Java concurrency之鎖_動(dòng)力節(jié)點(diǎn)Java學(xué)院整理
這篇文章主要為大家詳細(xì)介紹了Java concurrency之鎖的相關(guān)資料,具有一定的參考價(jià)值,感興趣的小伙伴們可以參考一下2017-06-06SpringBoot項(xiàng)目啟動(dòng)時(shí)預(yù)加載操作方法
Spring Boot是一種流行的Java開發(fā)框架,它提供了許多方便的功能來簡化應(yīng)用程序的開發(fā)和部署,這篇文章主要介紹了SpringBoot項(xiàng)目啟動(dòng)時(shí)預(yù)加載,需要的朋友可以參考下2023-09-09Java ExecutorServic線程池異步實(shí)現(xiàn)流程
這篇文章主要介紹了Java ExecutorServic線程池異步實(shí)現(xiàn)流程,文中通過示例代碼介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下2020-12-12SpringBoot集成Jpa對(duì)數(shù)據(jù)進(jìn)行排序、分頁、條件查詢和過濾操作
這篇文章主要介紹了SpringBoot集成Jpa對(duì)數(shù)據(jù)進(jìn)行排序、分頁、條件查詢和過濾操作,主要使用Jpa連接數(shù)據(jù)庫對(duì)數(shù)據(jù)進(jìn)行排序、分頁、條件查詢和過濾操作,需要的朋友可以參考下2023-05-05Java 數(shù)組獲取最大和最小值的實(shí)例實(shí)現(xiàn)
這篇文章主要介紹了Java 數(shù)組獲取最大和最小值的實(shí)例實(shí)現(xiàn),文中通過示例代碼介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2019-09-09