一、Bean的實(shí)例化概述

前一篇分析了BeanDefinition的封裝過程，最終將beanName與BeanDefinition以一對一映射關(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對象的實(shí)例來調(diào)用setBeanClassLoader()方法；如果Bean類實(shí)現(xiàn)BeanFactoryAware接口，則將通過傳遞BeanFactory對象的實(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);// 初始化beanexposedObject = 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()) {// 初始化前處理的beanPostProcessorwrappedBean = 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()) {// 初始化后處理的beanPostProcessorwrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean;}

從上面源碼可知，梳理出主要的四個(gè)步驟：

step1:激活aware接口，完成aware接口的相關(guān)操作； step2:初始化前處理的beanPostProcessor； step3:完成init-method方法； step4:初始化后處理的beanPostProcessor;

BeanPostProcessor作用是對初始化后的bean進(jìn)行增強(qiáng)處理，在該階段 BeanPostProcessor 會(huì)處理當(dāng)前容器內(nèi)所有符合條件的實(shí)例化后的 bean 對象。它主要是對 Spring 容器提供的 bean 實(shí)例對象進(jìn)行有效的擴(kuò)展，允許Spring在初始化 bean 階段對其進(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 init-method='initMethod' destroy-method='destroyMethod'><property name='property' value='property'/></bean><bean ></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)容請搜索好吧啦網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持好吧啦網(wǎng)！