Spring Bean的生命周期

说明: 本文基于Spring-Framework 5.1.x版本讲解

概述

说起生命周期, 很多开源框架、中间件的组件都有这个词，其实就是指组件从创建到销毁的过程。 那这里讲Spring Bean的生命周期,并不是讲Bean是如何创建的, 而是想讲下Bean从实例化到销毁，Spring框架在Bean的各个阶段给我们提供了哪些拓展点。 Bean本身有三个大的阶段： 实例化、初始化、销毁。

Spring的强大就是提供了非常多的拓展点, 我们可以基于这些拓展点实现不同的需求。 回到主题，Spring容器围绕着生命周期的各个阶段提供了不同功能的拓展点如下图：

从上图可以看到，整个生命周期涉及到的接口(当然这不是所有接口,只是日常中可以用到的，还有一部分是Spring内部的接口)分成了4个阶段：

1. 实例化阶段： 主要是以不同方式实例化Bean

2. 属性注入阶段：IOC的过程

3. 初始化阶段：初始化Bean的内部组件、生成代理对象等都在这里

4. 销毁阶段： 释放资源

下面我们对这些核心的接口进行简单的介绍

 

接口介绍

InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation

@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
	return null;
}

返回值Object: 返回null值则执行Spring提供给我们的Bean实例化、属性注入、初始化阶段,  这是对于大多数Bean的选择； 返回非null值则跳过Bean实例化、属性注入、初始化阶段，因为Spring会认为IOC等阶段由使用者管理，所以在这种情况下后续会直接调用BeanPostProcessor#postProcessAfterInitialization接口, 进而有可能提前结束标准IOC流程， 为什么说有可能呢？ 因为还需取决于BeanPostProcessor#postProcessAfterInitialization的返回值。

使用场景： 使用频率比较低，实际没有用到过。不过在Spring-Framework的AOP源码中有用到,见AbstractAutoProxyCreator

 

InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation

default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
	return true;
}

返回值boolean: true则执行Spring的属性注入功能 ， 大多数情况返回true即可，除非你有定制化的需求；返回false跳过Spring属性注入功能，意味着@Resource、@Autowired等注解失效,也意味着xml文件中<property>标签失效。

使用场景： 比较少, Spring-Framework源码中也没有用到

 

InstantiationAwareBeanPostProcessor#postProcessProperties

@Nullable
default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
	return null;
}

返回值PropertyValues: 一般返回入参pvs即可， Spring后续会使用返回值进行属性注入。 尤其对于SpringBoot这种纯JavaConfig配置的方式, 参数pvs一般为Empty(注意与null区分)

使用场景：标注@Resource、@Autowired等注解的属性都在这个方法实现注入，比较核心, 详见: CommonAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor 

 

如果postProcessProperties方法返回null，Spring也会调用postProcessPropertyValues方法实现同样的效果，不过这个方法是老版本中的，已经弃用掉的，不推荐使用. 

@Deprecated
@Nullable
default PropertyValues postProcessPropertyValues(
		PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
	return pvs;
}

 

BeanName、BeanFactory、BeanClassLoaderAware

public interface BeanNameAware extends Aware {
	void setBeanName(String name);
}
public interface BeanClassLoaderAware extends Aware {
	void setBeanClassLoader(ClassLoader classLoader);
}
public interface BeanFactoryAware extends Aware {
	void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}

这三个接口就比较简单了，就是给我们的Bean注入BeanName、ClassLoader、BeanFactory属性， 他的调用时机在实例化、属性注入之后，是初始化阶段的第一步

 

BeanPostProcessor#postProcessBeforeInitialization

/**
 * Apply this BeanPostProcessor to the given new bean instance <i>before</i> any bean
 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
 * or a custom init-method). The bean will already be populated with property values.
 * The returned bean instance may be a wrapper around the original.
 * <p>The default implementation returns the given {@code bean} as-is.
 * @param bean the new bean instance
 * @param beanName the name of the bean
 * @return the bean instance to use, either the original or a wrapped one;
 * if {@code null}, no subsequent BeanPostProcessors will be invoked
 * @throws org.springframework.beans.BeansException in case of errors
 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
 */
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
	return bean;
}

返回值Object: 一般情况返回入参的bean即可。

需要注意几点：

1. 如果返回null，则后续所有实现该接口的Processor都不会执行，且返回上个Processor的返回值；

2. 上个Processor的返回值会作为下个Processor的入参。

3. 最后一个Processor的返回值会代替原来的Bean(返回入参Bean的情况可以忽略这一条)进行后续处理(包含Bean初始化、以及最终暴露到Spring容器中)

这里比较难理解，贴下源码

/**
  * 执行Bean的初始化步骤
  */
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
   
    // 此处省略不关键的部分代码
    
	Object wrappedBean = bean;
    // 调用所有实现BeanPostProcessor#postProcessBeforeInitialization接口的方法
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    // 使用postProcessBeforeInitialization方法的返回值当做入参进行Bean初始化
	invokeInitMethods(beanName, wrappedBean, mbd);
    // 使用postProcessBeforeInitialization方法的返回值当做入参进行Bean初始化的后置处理
	wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	return wrappedBean;
}
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException {
	Object result = existingBean;
    // getBeanPostProcessors() 返回的Processors是有有优先级顺序的
	for (BeanPostProcessor processor : getBeanPostProcessors()) { 
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result; // 如果为null , 这里直接退出该方法并返回上次Processor返回的结果
		}
		result = current; // 上个Processor执行的结果作为下个Processor处理的入参
	}
	return result;
}

使用场景：1. 标注@PostConstruct注解的方法都在该接口实现调用, 详见InitDestroyAnnotationBeanPostProcessor 2. 各种Aware接口的调用入口，详见ApplicationContextAwareProcessor

 

InitializingBean#afterPropertiesSet

public interface InitializingBean {
 
	/**
	 * Invoked by the containing {@code BeanFactory} after it has set all bean properties
	 * and satisfied {@link BeanFactoryAware}, {@code ApplicationContextAware} etc.
	 * <p>This method allows the bean instance to perform validation of its overall
	 * configuration and final initialization when all bean properties have been set.
	 * @throws Exception in the event of misconfiguration (such as failure to set an
	 * essential property) or if initialization fails for any other reason
	 */
	void afterPropertiesSet() throws Exception;
 
}

Bean初始化资源的回调接口 ， 与@PostConstruct一样的作用 ，但要注意的是几个初始化方法调用的顺序：1.@PostConstruct2. afterPropertiesSet 3. init-method

使用场景： 资源初始化、可以使用回调的特性实现策略模式等，实际工作中用的较多

 

init-method

XML配置文件中init-method属性或者@Bean注解initMethod属性指定的方法 ， 比较简单不多说了

 

BeanPostProcessor#postProcessAfterInitialization

/**
 * Apply this BeanPostProcessor to the given new bean instance <i>after</i> any bean
 * initialization callbacks (like InitializingBean's {@code afterPropertiesSet}
 * or a custom init-method). The bean will already be populated with property values.
 * The returned bean instance may be a wrapper around the original.
 * <p>In case of a FactoryBean, this callback will be invoked for both the FactoryBean
 * instance and the objects created by the FactoryBean (as of Spring 2.0). The
 * post-processor can decide whether to apply to either the FactoryBean or created
 * objects or both through corresponding {@code bean instanceof FactoryBean} checks.
 * <p>This callback will also be invoked after a short-circuiting triggered by a
 * {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation} method,
 * in contrast to all other BeanPostProcessor callbacks.
 * <p>The default implementation returns the given {@code bean} as-is.
 * @param bean the new bean instance
 * @param beanName the name of the bean
 * @return the bean instance to use, either the original or a wrapped one;
 * if {@code null}, no subsequent BeanPostProcessors will be invoked
 * @throws org.springframework.beans.BeansException in case of errors
 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet
 * @see org.springframework.beans.factory.FactoryBean
 */
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
	return bean;
}

返回值Object: 一般情况返回入参的bean即可。

与postProcessBeforeInitialization方法的调用逻辑一样，需要注意几点：

1. 如果返回null，则后续所有实现该接口的Processor都不会执行，且返回上个Processor的返回值；

2. 上个Processor的返回值会作为下个Processor的入参。

3. 最后一个Processor的返回值会代替原来的Bean(返回入参Bean的情况可以忽略这一条)进行后续处理(包含Bean初始化、以及最终暴露到Spring容器中)

使用场景：AOP生成代理的入口,详见AbstractAutoProxyCreator

 

DestructionAwareBeanPostProcessor#postProcessBeforeDestruction

/**
 * Apply this BeanPostProcessor to the given bean instance before its
 * destruction, e.g. invoking custom destruction callbacks.
 * <p>Like DisposableBean's {@code destroy} and a custom destroy method, this
 * callback will only apply to beans which the container fully manages the
 * lifecycle for. This is usually the case for singletons and scoped beans.
 * @param bean the bean instance to be destroyed
 * @param beanName the name of the bean
 * @throws org.springframework.beans.BeansException in case of errors
 * @see org.springframework.beans.factory.DisposableBean#destroy()
 * @see org.springframework.beans.factory.support.AbstractBeanDefinition#setDestroyMethodName(String)
 */
void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;

用于处理Bean销毁前的一些前置工作，可实现批量处理。

使用场景：标注@PreDestroy注解的方法都在该接口实现调用, 详见InitDestroyAnnotationBeanPostProcessor

 

DisposableBean#destroy

/**
 * Invoked by the containing {@code BeanFactory} on destruction of a bean.
 * @throws Exception in case of shutdown errors. Exceptions will get logged
 * but not rethrown to allow other beans to release their resources as well.
 */
void destroy() throws Exception;

Bean直接实现该接口即可，同时也注意这几个销毁方法的调用顺序： 1.@PreDestroy2. destroy 3. destroy-method

使用场景：释放Bean本身持有的资源，如连接池Bean资源等 ，单个处理。

 

destroy-method

XML配置文件中destroy-method属性或者@Bean注解destroyMethod属性指定的方法 ， 比较简单不多说了

 

小结

围绕生命周期Spring容器给我们提供的接口就简单介绍到这，实际上除了上面列举的接口之外，还有一些不常用的接口我没有列举出来，如：SmartInstantiationAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor等。对于以上接口，个人理解没有必要像八股文一样死记硬背每个接口的作用，甚至尝试记住接口的名称，关键在于设计的思想，开头也说过，其他框架的组件也有生命周期的实现，Spring与这些框架实现上有什么不同，这才是应该了解的；当然完全不了解其接口的作用也是不行的，这里强调的是不用刻意去死记硬背接口的含义， 在工作中多看看别人、别的框架的使用方式更有利于加深理解。