Spring Bean的生命周期
一、引言
要想理解Spring框架，那么Spring Bean的生命周期就是必须要了解的一环，关于Spring Bean的生命周期，就是一个Bean在IOC容器中从创建到销毁的过程，下面就开始梳理一下一个Bean的创建过程。
二、生命周期概要流程
简单的来说，一个Bean的生命周期分为四个阶段：
1、实例化（Instantiation）
2、属性设置（populate）
3、初始化（Initialization）
4、销毁（Destruction）
如下图：
具体逻辑位于AbstractAutowireCapableBeanFactory类doCreateBean方法中，代码较多，只放出了重要的部分，如下：
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { BeanWrapper instanceWrapper = null; if (instanceWrapper == null) { //实例化 instanceWrapper = this.createBeanInstance(beanName, mbd, args); } try { //属性赋值 this.populateBean(beanName, mbd, instanceWrapper); //初始化 exposedObject = this.initializeBean(beanName, exposedObject, mbd); } catch (Throwable var18) { //... } try { //注册销毁回调接口 this.registerDisposableBeanIfNecessary(beanName, bean, mbd); return exposedObject; } catch (BeanDefinitionValidationException var16) { //... } }
上面是的步实例化、属性赋值、初始化都是Spring容器启动时的步骤，销毁是在容器关闭时的操作，容器销毁时会调用容器的close()方法去销毁容器。
三、对生命周期的扩展
Spring在创建Bean的时候不仅仅只创建了一个我们设置的Bean，还可以在创建Bean的时候对它进行很多的扩展，总的来说有以下几类：
1、BeanPostProcessor接口
2、InstantiationAwareBeanPostProcessor接口
3、Aware类型的接口
4、生命周期类型接口
其中1和2是作用于所有Bean的接口，3和4是作用于单个Bean的接口。BeanPostProcessor是初始化时的后置处理器，InstantiationAwareBeanPostProcessor是实例化时的后置处理器，Aware类型的接口如BeanNameAware、BeanFactoryAware等需要Bean自己去实现，生命周期类型接口如InitializingBean、DisposableBean。
加上这些扩展，现在上面的图可以变成下面这样了：
接下来看详细的源码，刚刚我们提到的实例化、属性赋值、初始化这三个步骤都在doCreateBean方法中，那么在这个方法之前有什么操作吗：
//createBean方法里面调用了doCreateBean protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { Object beanInstance; try { //这个里面调用了InstantiationAwareBeanPostProcessor的前置方法postProcessBeforeIns beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse); } catch (Throwable var10) { //... } //... try { //这里调用了doCreateBean beanInstance = this.doCreateBean(beanName, mbdToUse, args); return beanInstance; } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) { //... } catch (Throwable var8) { //... } } //resolveBeforeInstantiation方法里面调用了这个方法 protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) { Iterator var3 = this.getBeanPostProcessors().iterator(); while(var3.hasNext()) { BeanPostProcessor bp = (BeanPostProcessor)var3.next(); if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp; //调用了InstantiationAwareBeanPostProcessor的前置方法postProcessBeforeInstantiation Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName); if (result != null) { return result; } } } return null; }
在调用完InstantiationAwareBeanPostProcessor的前置方法之后接下来进入doCreateBean方法，首先会执行createBeanInstance(beanName, mbd, args)进行实例化，然后进入populateBean(beanName, mbd, instanceWrapper)方法进行属性赋值，看一下这一部分代码还有没有别的操作：
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { //... } else { if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) { Iterator var4 = this.getBeanPostProcessors().iterator(); while(var4.hasNext()) { BeanPostProcessor bp = (BeanPostProcessor)var4.next(); if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp; //执行InstantiationAwareBeanPostProcessor的后置方法postProcessAfterInstantiation if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { return; } } } } if (hasInstAwareBpps) { Iterator var9 = this.getBeanPostProcessors().iterator(); while(var9.hasNext()) { BeanPostProcessor bp = (BeanPostProcessor)var9.next(); if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp; //执行执行InstantiationAwareBeanPostProcessor的postProcessProperties PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { ////执行执行InstantiationAwareBeanPostProcessor的postProcessPropertyValues(该方法已废弃，不建议使用) pvsToUse = ibp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName); } } } } } }
通过源码可以看出InstantiationAwareBeanPostProcessor的几个方法分别在实例化的前后完成，然后进行属性赋值，接下来就是实例化initializeBean(beanName, exposedObject, mbd)，我们来看一下：
//该方法位于AbstractAutowireCapableBeanFactory类中，这段代码很简单，不像其他部分还添加了很多其他操作，这块一看就明白了，就不把BeanPostProcessor、InitializingBean等具体的方法列出来了 protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged(() -> { //invokeAwareMethods方法执行实现的Aware接口 this.invokeAwareMethods(beanName, bean); return null; }, this.getAccessControlContext()); } else { //和上面的一样，执行实现的Aware类型的接口 this.invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { //这个方法里面执行了BeanPostProcessor的postProcessBeforeInitialization方法 wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName); } try { //执行了InitializingBean的afterPropertiesSet方法和自定义的init-method方法 this.invokeInitMethods(beanName, wrappedBean, mbd); } catch (Throwable var6) { throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6); } if (mbd == null || !mbd.isSynthetic()) { //这个方法里面执行了BeanPostProcessor的postProcessAfterInitialization方法 wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); } return wrappedBean; }
关于Aware类型的接口这里要说一下，可能你会奇怪按照我上面的那个类去找invokeAwareMethods(beanName, bean)方法会是下面这种情况：
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 = this.getBeanClassLoader(); if (bcl != null) { ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl); } } if (bean instanceof BeanFactoryAware) { ((BeanFactoryAware)bean).setBeanFactory(this); } } }
为什么只有这三个Aware类型的接口，明明还有其他好几种啊，比如EnvironmentAware、EmbeddedValueResolverAware等，这是什么它们的容器不同，AbstractAutowireCapableBeanFactory使用的容器是BeanFactory，其他几种是ApplicationContext 添加的扩展接口，如：
//ApplicationContextAwareProcessor中实现的接口如下 private void invokeAwareInterfaces(Object bean) { if (bean instanceof EnvironmentAware) { ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment()); } if (bean instanceof EmbeddedValueResolverAware) { ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver); } if (bean instanceof ResourceLoaderAware) { ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext); } if (bean instanceof ApplicationEventPublisherAware) { ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext); } if (bean instanceof MessageSourceAware) { ((MessageSourceAware)bean).setMessageSource(this.applicationContext); } if (bean instanceof ApplicationContextAware) { ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext); } }
到这一步初始化也完成了，至于销毁时在容器关闭时执行容器的close方法，close方法中会执行destroy方法销毁所有的Bean：
//销毁Bean的方法 public void destroy() { if (!CollectionUtils.isEmpty(this.beanPostProcessors)) { Iterator var1 = this.beanPostProcessors.iterator(); while(var1.hasNext()) { //其实这里也有个销毁时的处理器，实现了BeanPostProcessor,在执行销毁方法前执行postProcessBeforeDestruction方法 DestructionAwareBeanPostProcessor processor = (DestructionAwareBeanPostProcessor)var1.next(); processor.postProcessBeforeDestruction(this.bean, this.beanName); } } if (this.invokeDisposableBean) { try { if (System.getSecurityManager() != null) { AccessController.doPrivileged(() -> { //执行DisposableBean的destroy方法 ((DisposableBean)this.bean).destroy(); return null; }, this.acc); } else { //同上，执行DisposableBean的destroy方法 ((DisposableBean)this.bean).destroy(); } } catch (Throwable var3) { //... } } if (this.destroyMethod != null) { //如果存在指定的销毁方法就执行，即destroy-method指定的方法 this.invokeCustomDestroyMethod(this.destroyMethod); } else if (this.destroyMethodName != null) { //... } }
到这里我们已经看完了一个Bean从实例化到销毁的所有步骤。
四、总结
总的来说Spring Bean的生命周期就是四大步骤，实例化 -> 属性赋值 ->初始化 ->销毁，其他的操作都是对这四个步骤的扩展。
