Spring Bean 生命周期源码

Spring Bean 生命周期非常重要，今天我们来进入到源码了解一下整个bean的生命周期

先来一张流程图(懒得画了，截图的)

大概了解了bean的生命周期后，我们来看源码，经过上一篇的 ioc 源码文章，我们这直接看重点
1.AbstractAutowireCapableBeanFactory类的doCreateBean方法

	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the 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 {
			//bean属性填充
			populateBean(beanName, mbd, instanceWrapper);
			//调用初始化方法
			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.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

1. 创建实例，调用空构造函数，并未赋值

instanceWrapper = createBeanInstance(beanName, mbd, args);

当此代码执行完控制台便会打印构造函数的输出
2. bean属性填充

populateBean(beanName, mbd, instanceWrapper);

此代码执行完便会打印setName方法的输出
3. 接下进入这行代码看初始化方法

exposedObject = initializeBean(beanName, exposedObject, mbd);

initializeBean方法代码

	protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				//检查是否实现了相关aware接口并调用
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			//调用bean前置处理器
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			//检查是否实现InitializingBean接口和initMethod方法
			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的after方法
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}

接下来看invokeAwareMethods方法

	private void invokeAwareMethods(String beanName, Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);
			}
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
				}
			}
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
			}
		}
	}

这里依次判断是否实现了BeanNameAware接口，是的话调用setBeanName方法

if (bean instanceof BeanNameAware) {
	((BeanNameAware) bean).setBeanName(beanName);
}

是否实现了BeanClassLoaderAware接口，是的话调用setBeanClassLoader方法

if (bean instanceof BeanClassLoaderAware) {
	ClassLoader bcl = getBeanClassLoader();
	if (bcl != null) {
		((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
	}
}

最后检查是否实现了BeanFactoryAware接口，是的话调用setBeanFactory方法

if (bean instanceof BeanFactoryAware) {
	((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}

4. 调用beanPostProcess的before方法
   接下来回到initializeBean方法，调用这行代码

wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);

5. 检查是否实现InitializingBean接口和initMethod方法
   接下来是这一行代码

invokeInitMethods(beanName, wrappedBean, mbd);

这个方法会判断是否实现了InitializingBean接口，如果实现则调用
afterpropertiesSet方法和调用自定义的初始化方法

6. 调用BeanPostProcessor的after方法

接下来调用这行代码

wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

7. 最后回到doCreateBean方法
   看这一行

try {
	registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}

此行代码会注册相关回调方法等待销毁的时候调用
比如是否实现了DisposableBean接口，如果实现了销毁时调用
destory方法、是否实现了自定义的destoryMethod方法实现了则调用
到此Spring Bean的生命周期就算结束了