Spring源碼解析之Bean的生命周期
前一篇分析了BeanDefinition的封裝過程，最終將beanName與BeanDefinition以一對一映射關系放到beanDefinitionMap容器中，這一篇重點分析如何利用bean的定義信息BeanDefinition實例化bean。
二、流程概覽其實bean的實例化過程比較復雜，中間細節很多，為了抓住重點，先將核心流程梳理出來，主要包含以下幾個流程：
進入AbstractApplicationContext中的fresh()方法，找到finishBeanFactoryInitialization(beanFactory)方法，該類是bean的實例化的入口，具體的實例化由preInstantiateSingletons()方法觸發，見如下代碼：
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解析時，把所有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);//如果不是抽象的，單例的，非懶加載的就實例化if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {//判斷bean是否實現了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 {// 實例化過程getBean(beanName);}}}
上述代碼主要看getBean方法，隨后進入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// 創建bean實例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，如果沒有，則創建bean，最重要的方法就是getSingleton，該方法第二個參數是個函數式接口，進入getSingleton方法，當調用singletonObject = singletonFactory.getObject()時，會觸發函數式接口中的createBean方法，隨后一路進入doCreateBean，這個方法里面完成了所有實例化所需的步驟:
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.// 真正開始創建bean的實例.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.// 有必要時，注冊bean的銷毀try {registerDisposableBeanIfNecessary(beanName, bean, mbd);}catch (BeanDefinitionValidationException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, 'Invalid destruction signature', ex);}return exposedObject;}
從上述源碼中看出bean的實例化主要分為以下三步：
step1:bean的創建； step2:給bean的屬性賦值； step3:bean的初始化；接著得到exposedObject這個已經完全實例化后的bean返回，其中當有必要時，注冊bean的銷毀，后面再詳細看，先抓住主要流程。其中step3也是比較重要的方法，進入該方法:
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;}
從上面源碼可知，梳理出主要的四個步驟：
step1:激活aware接口，完成aware接口的相關操作； step2:初始化前處理的beanPostProcessor； step3:完成init-method方法； step4:初始化后處理的beanPostProcessor;BeanPostProcessor作用是對初始化后的bean進行增強處理，在該階段 BeanPostProcessor 會處理當前容器內所有符合條件的實例化后的 bean 對象。它主要是對 Spring 容器提供的 bean 實例對象進行有效的擴展，允許Spring在初始化 bean 階段對其進行定制化修改，如處理標記接口或者為其提供代理實現。
四、演示定義一個MyBeanPostProcessor實現BeanPostProcessor接口
public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println('post Process Before Initialization 被調用...');return bean; } @Override public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println('post Process after Initialization 被調用...');return bean; }}
定義一個LifeCycleBean類，實現如下接口：
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('構造函數調用...'); } @Override public void setBeanClassLoader(ClassLoader classLoader) {System.out.println('BeanClassLoaderAware 被調用...'); } @Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println('BeanFactoryAware 被調用...'); } @Override public void setBeanName(String name) {System.out.println('BeanNameAware 被調用...'); } @Override public void destroy() throws Exception {System.out.println('DisposableBean destroy 被調用...'); } @Override public void afterPropertiesSet() throws Exception {System.out.println('InitializingBean afterPropertiesSet 被調用...'); } public void initMethod(){System.out.println('init-method 被調用...'); } public void destroyMethod(){System.out.println('destroy-method 被調用...'); } public void display(){System.out.println('方法調用...'); }}
指定配置文件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'); }
執行結果：
構造函數調用...屬性注入....BeanNameAware 被調用...BeanClassLoaderAware 被調用...BeanFactoryAware 被調用...post Process Before Initialization 被調用...InitializingBean afterPropertiesSet 被調用...init-method 被調用...post Process after Initialization 被調用...DisposableBean destroy 被調用...destroy-method 被調用...
五、總結本篇從一個初學者的角度概覽了bean的整個生命周期，并描述了其中的主要流程，閱讀源碼的初始階段，優先抓住主要流程，別陷入細節，并通過跑案例、寫注解、畫流程圖等方式加深理解，后續將繼續分析bean實例化中的核心流程、設計思想等。
到此這篇關于Spring源碼解析之Bean的生命周期的文章就介紹到這了,更多相關Bean的生命周期內容請搜索好吧啦網以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持好吧啦網！
相關文章：
網公網安備