1.概述
之前我们在总结Spring扩展点：后置处理器时谈到了Spring Bean的生命周期和其对Spring框架原理理解的重要性，所以接下来我们就来分析一下Bean生命周期的整体流程。首先Bean就是一些Java对象，只不过这些Bean不是我们主动new出来的，而是交个Spring IOC容器创建并管理的，因此Bean的生命周期受Spring IOC容器控制，Bean生命周期大致分为以下几个阶段：
- Bean的实例化(Instantiation) ：Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射进行实例化
- Bean的属性赋值(Populate) ：Bean实例化之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充，Bean的属性赋值就是指 Spring 容器根据BeanDefinition中属性配置的属性值注入到 Bean 对象中的过程。
- Bean的初始化(Initialization) ：对Bean实例的属性进行填充完之后还需要执行一些Aware接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段，并且Spring高频面试题Bean的循环引用问题也是在这个阶段体现的；
- Bean的使用阶段：经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池singletonObjects中去了，即完成了Spring Bean的整个生命周期，接下来Bean就可以被随心所欲地使用了。
- Bean的销毁(Destruction) ：Bean 的销毁是指 Spring 容器在关闭时，执行一些清理操作的过程。在 Spring 容器中， Bean 的销毁方式有两种：销毁方法destroy-method和 DisposableBean 接口。
项目推荐：基于SpringBoot2.x、SpringCloud和SpringCloudAlibaba企业级系统架构底层框架封装，解决业务开发时常见的非功能性需求，防止重复造轮子，方便业务快速开发和企业技术栈框架统一管理。引入组件化的思想实现高内聚低耦合并且高度可配置化，做到可插拔。严格控制包依赖和统一版本管理，做到最少化依赖。注重代码规范和注释，非常适合个人学习和企业使用
Github地址：github.com/plasticene/…
Gitee地址：gitee.com/plasticene3…
微信公众号：Shepherd进阶笔记
2.Bean生命周期详解和使用案例
这里我先纠正一下在Spring扩展点后置处理器总结的描述：之前说BeanDefinitionRegistryPostProcessor,BeanFactoryPostProcessor,BeanPostProcessor这三个后置处理器的调用时机都在Spring Bean生命周期中是不严谨的，按照上面我们对Bean生命周期的阶段划分，只有BeanPostProcessor作用于Bean的生命周期中，而BeanDefinitionRegistryPostProcessor,BeanFactoryPostProcessor是针对BeanDefinition的，所以不属于Bean的生命周期中。
BeanPostProcessor在Bean生命周期的体现如下图所示：
Bean的生命周期和人的一生一样都会经历从出生到死亡，中间是一个漫长且复杂的过程，接下来我们就来整体分析一下Bean生命周期的核心流程和相关接口回调方法的调用时机，同时这里想强调一下Bean的生命周期也是面试的高频考点，对核心流程务必要掌握清楚，这里用一张流程图进行详述展示，是重点、重点、重点。
根据上面的Bean生命周期核心流程做如下代码演示示例：
Bean定义：
@Data
@AllArgsConstructor
public class Boo implements InitializingBean, DisposableBean, BeanNameAware {
private Long id;
private String name;
public Boo() {
System.out.println("boo实例化构造方法执行了...");
}
@PostConstruct
public void postConstruct() {
System.out.println("boo执行初始化@postConstruct注解标注的方法了...");
}
@PreDestroy
public void preDestroy() {
System.out.println("boo执行初始化@preDestroy注解标注的方法了...");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("boo执行InitializingBean的afterPropertiesSet()方法了...");
}
@Override
public void destroy() throws Exception {
System.out.println("boo执行DisposableBean的destroy()方法了...");
}
@Override
public void setBeanName(String name) {
System.out.println("boo执行BeanNameAware的setBeanName()方法了...");
}
private void initMethod() {
System.out.println("boo执行init-method()方法了...");
}
public void destroyMethod() {
System.out.println("boo执行destroy-method()方法了...");
}
}
实现InstantiationAwareBeanPostProcessor:
@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInstantiation(Class<?> BeanClass, String BeanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor的before()执行了...." + BeanName);
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object Bean, String BeanName) throws BeansException {
System.out.println("InstantiationAwareBeanPostProcessor的after()执行了...." + BeanName);
return false;
}
}
实现BeanPostProcessor：
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object Bean, String BeanName) throws BeansException {
System.out.println("BeanPostProcessor的before()执行了...." + BeanName);
return Bean;
}
@Override
public Object postProcessAfterInitialization(Object Bean, String BeanName) throws BeansException {
System.out.println("BeanPostProcessor的after()执行了...."+ BeanName);
return Bean;
}
}
执行下面的配置类测试方法：
@ComponentScan(basePackages = {"com.shepherd.common.config"})
@Configuration
public class MyConfig {
@Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
public Boo boo() {
return new Boo();
}
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
Boo boo = applicationContext.getBean(Boo.class);
System.out.println("拿到boo对象了：" + boo);
applicationContext.close();
}
}
名为boo的Bean相关运行结果如下：
beanPostProcessor的before()执行了....myConfig
beanPostProcessor的after()执行了....myConfig
InstantiationAwareBeanPostProcessor的before()执行了....boo
boo实例化构造方法执行了...
InstantiationAwareBeanPostProcessor的after()执行了....boo
boo执行BeanNameAware的setBeanName()方法了...
beanPostProcessor的before()执行了....boo
boo执行初始化@postConstruct注解标注的方法了...
boo执行InitializingBean的afterPropertiesSet()方法了...
boo执行init-method()方法了...
beanPostProcessor的after()执行了....boo
拿到boo对象了：Boo(id=null, name=null)
boo执行初始化@preDestroy标注的方法了...
boo执行DisposableBean的destroy()方法了...
boo执行destroy-method()方法了...
根据控制台打印结果可以boo的相关方法执行顺序严格遵从上面流程图，同时当我们执行容器applicationContext的关闭方法close()会触发调用bean的销毁回调方法。
3.浅析Bean生命周期源码实现
DefaultListableBeanFactory是Spring IOC的Bean工厂的一个默认实现，IOC大部分核心逻辑实现都在这里，可关注。Bean生命周期就是创建Bean的过程，这里我们就不在拐弯抹角兜圈子，直接来到DefaultListableBeanFactory继承的AbstractAutowireCapableBeanFactory的#doCreateBean()方法，之前说过在Spring框架中以do开头的方法都是核心逻辑实现所在
protected Object doCreateBean(String BeanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the Bean.
// BeanWrapper 是对 Bean 的包装，其接口中所定义的功能很简单包括设置获取被包装的对象，获取被包装 Bean 的属性描述器
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// <1> 单例模型，则从未完成的 FactoryBean 缓存中删除
instanceWrapper = this.factoryBeanInstanceCache.remove(BeanName);
}
if (instanceWrapper == null) {
// <2> 使用合适的实例化策略来创建新的实例：工厂方法、构造函数自动注入、简单初始化
instanceWrapper = createBeanInstance(BeanName, mbd, args);
}
// 包装的实例对象
Object Bean = instanceWrapper.getWrappedInstance();
// 包装的实例class类型
Class<?> BeanType = instanceWrapper.getWrappedClass();
if (BeanType != NullBean.class) {
mbd.resolvedTargetType = BeanType;
}
// Allow post-processors to modify the merged Bean definition.
// <3> 判断是否有后置处理
// 如果有后置处理，则允许后置处理修改 BeanDefinition
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.
// <4> 解决单例模式的循环依赖
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");
}
// 提前将创建的 Bean 实例加入到 singletonFactories 中
// 这里是为了后期避免循环依赖
addSingletonFactory(BeanName, () -> getEarlyBeanReference(BeanName, mbd, Bean));
}
// Initialize the Bean instance.
// 开始初始化 Bean 实例对象
Object exposedObject = Bean;
try {
// <5> 对 Bean 进行填充，将各个属性值注入，其中，可能存在依赖于其他 Bean 的属性
// 则会递归初始依赖 Bean
populateBean(BeanName, mbd, instanceWrapper);
// <6> 调用初始化方法
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);
}
}
// <7> 循环依赖处理
if (earlySingletonExposure) {
// 获取 earlySingletonReference
Object earlySingletonReference = getSingleton(BeanName, false);
// 只有在存在循环依赖的情况下，earlySingletonReference 才不会为空
if (earlySingletonReference != null) {
// 如果 exposedObject 没有在初始化方法中被改变，也就是没有被增强
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 {
// <8> 注册 Bean的销毁逻辑
registerDisposableBeanIfNecessary(BeanName, Bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), BeanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
由上面代码可知，Bean的创建过程核心步骤如下：
- createBeanInstance(BeanName, mbd, args) 进行Bean的实例化
- populateBean(BeanName, mbd, instanceWrapper)进行Bean的属性填充赋值
- initializeBean(BeanName, exposedObject, mbd)处理Bean初始化之后的各种回调事件
- registerDisposableBeanIfNecessary(BeanName, Bean, mbd)注册Bean的销毁接口
- 解决创建Bean过程中的循环依赖，Spring使用三级缓存解决循环依赖，这也是一个重要的知识点，这里不详细阐述，后面会安排
接下来我们就来看看和Bean初始化阶段相关各种回调事件执行方法#initializeBean()，分析一下上面流程图的执行顺序是怎么实现的。
protected Object initializeBean(final String BeanName, final Object Bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(BeanName, Bean);
return null;
}
}, getAccessControlContext());
}
else {
// 涉及到的回调接口点进去一目了然，代码都是自解释的
// BeanNameAware、BeanClassLoaderAware或BeanFactoryAware
invokeAwareMethods(BeanName, Bean);
}
Object wrappedBean = Bean;
if (mbd == null || !mbd.isSynthetic()) {
// BeanPostProcessor 的 postProcessBeforeInitialization 回调,这里会执行@PostConstruct标注的方法
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, BeanName);
}
try {
// init-methods
// 或者是实现了InitializingBean接口，会调用afterPropertiesSet() 方法
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 的 postProcessAfterInitialization 回调
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, BeanName);
}
return wrappedBean;
}
至于Bean的销毁流程与Bean初始化类似，从上面的使用示例中看可以得出当容器关闭时，才会对Bean销毁方法进行调用。销毁过程是这样的。顺着close()-> doClose() -> destroyBeans() -> destroySingletons() -> destroySingleton() -> destroyBean() -> Bean.destroy()，会看到最终调用Bean的销毁方法。这里就不在展示源码细节啦，有兴趣的话自行去调试查看了解
4.总结
以上全部就是对Spring Bean生命周期的全面总结， Spring 的 Bean 容器机制是非常强大的，它可以帮助我们轻松地管理 Bean 对象，并且提供了丰富的生命周期回调方法，允许我们在 Bean 的生命周期中执行自己的特定操作，这对于我们平时工作使用中进行增强扩展至关重要，因此掌握Bean的生命周期是必须的。
