Spring Bean的生命周期指的是Bean从创建到初始化再到销毁的过程，这个过程由IOC容器管理。一个完整的Bean生命周期可以参考Spring Bean生命周期。这里我们主要记录一些和Bean生命周期相关的细节。
Bean的初始化和销毁 在整个生命周期过程中，我们可以自定义Bean的初始化和销毁钩子函数，当Bean的生命周期到达相应的阶段的时候，Spring会调用我们自定义的Bean的初始化和销毁方法。自定义Bean初始化和销毁方法有多种方式，下面逐一介绍。
374544735d0dd4104601ef98749c7f89.png
但是当我第一次看到该图时，就产生了很多困扰，“Aware，BeanPostProcessor…这些都是什么啊？而且这么多步骤，太多了，该怎么记啊？”。
其实要记忆该过程，还是需要我们先去理解，本文将从以下两方面去帮助理解 Bean 的生命周期：
生命周期的概要流程：对 Bean 的生命周期进行概括，并且结合代码来理解；
扩展点的作用：详细介绍 Bean 生命周期中所涉及到的扩展点的作用。
2. 生命周期的概要流程
Bean 的生命周期概括起来就是 4 个阶段：
实例化（Instantiation）
属性赋值（Populate）
初始化（Initialization）
销毁（Destruction）
e8a473640bcd06e544c86fa729133ac3.png
实例化：第 1 步，实例化一个 bean 对象；
属性赋值：第 2 步，为 bean 设置相关属性和依赖；
初始化：第 3~7 步，步骤较多，其中第 5、6 步为初始化操作，第 3、4 步为在初始化前执行，第 7 步在初始化后执行，该阶段结束，才能被用户使用；
销毁：第 8~10步，第8步不是真正意义上的销毁（还没使用呢），而是先在使用前注册了销毁的相关调用接口，为了后面第9、10步真正销毁 bean 时再执行相应的方法。
下面我们结合代码来直观的看下，在 doCreateBean() 方法中能看到依次执行了这 4 个阶段：
// AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 1. 实例化
BeanWrapper instanceWrapper = null;
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
Object exposedObject = bean;
try {
// 2. 属性赋值
populateBean(beanName, mbd, instanceWrapper);
// 3. 初始化
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
// 4. 销毁-注册回调接口
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
return exposedObject;
}
由于初始化包含了第 3~7 步， 较复杂， 所以我们进到 initializeBean() 方法里具体看下其过程（ 注释的序号对应图中序号）：
// AbstractAutowireCapableBeanFactory.java protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { //
- 检查 Aware 相关接口并设置相关依赖
if(System.getSecurityManager() != null)
{
AccessController.doPrivileged((PrivilegedAction < Object > )() - >
{
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else
{
invokeAwareMethods(beanName, bean);
} //
4. BeanPostProcessor 前置处理 Object wrappedBean = bean;
if(mbd == null || !mbd.isSynthetic())
{
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
} //
5. 若实现 InitializingBean 接口， 调用 afterPropertiesSet() 方法 //
6. 若配置自定义的 init - method方法， 则执行
try
{
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch(Throwable ex)
{
throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null), beanName, “Invocation of init method failed”, ex);
} //
7. BeanPostProceesor 后置处理
if(mbd == null || !mbd.isSynthetic())
{
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
在 invokInitMethods() 方法中会检查 InitializingBean 接口和 init-method 方法，销毁的过程也与其类似：
// DisposableBeanAdapter.java public void destroy() { //
9. 若实现 DisposableBean 接口， 则执行 destory() 方法
if(this.invokeDisposableBean)
{
try
{
if(System.getSecurityManager() != null)
{
AccessController.doPrivileged((PrivilegedExceptionAction < Object > )() - >
{
((DisposableBean) this.bean).destroy();
return null;
}, this.acc);
}
else
{
((DisposableBean) this.bean).destroy();
}
}
} //
10. 若配置自定义的 detory - method 方法， 则执行
if(this.destroyMethod != null)
{
invokeCustomDestroyMethod(this.destroyMethod);
}
else if(this.destroyMethodName != null)
{
Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
if(methodToInvoke != null)
{
invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
}
}
}
从 Spring 的源码我们可以直观的看到其执行过程，而我们记忆其过程便可以从这 4 个阶段出发，实例化、属性赋值、初始化、销毁。其中细节较多的便是初始化，涉及了 Aware、BeanPostProcessor、InitializingBean、init-method 的概念。这些都是 Spring 提供的扩展点，其具体作用将在下一节讲述。
3. 扩展点的作用
3.1 Aware 接口
若 Spring 检测到 bean 实现了 Aware 接口，则会为其注入相应的依赖。所以通过让bean 实现 Aware 接口，则能在 bean 中获得相应的 Spring 容器资源。
Spring 中提供的 Aware 接口有：
BeanNameAware：注入当前 bean 对应 beanName；
BeanClassLoaderAware：注入加载当前 bean 的 ClassLoader；
BeanFactoryAware：注入 当前BeanFactory容器 的引用。
其代码实现如下：
// AbstractAutowireCapableBeanFactory.java private void invokeAwareMethods(final String beanName, final Object bean)
{
if(bean instanceof Aware)
{
if(bean instanceof BeanNameAware)
{
((BeanNameAware) bean).setBeanName(beanName);
}
if(bean instanceof BeanClassLoaderAware)
{
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
if(bean instanceof BeanFactoryAware)
{
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
以上是针对 BeanFactory 类型的容器，而对于 ApplicationContext 类型的容器，也提供了 Aware 接口，只不过这些 Aware 接口的注入实现，是通过 BeanPostProcessor 的方式注入的，但其作用仍是注入依赖。