1、Spring Bean 生命周期整体流程

Spring Bean 的生命周期，概括起来主要有四个阶段：

  1. 实例化（Instantiation）：基于BeanDefinition实例化一个 Bean ，此时 Bean 里的属性字段为 null 尚未赋值；
  2. 属性赋值（Populate）：为 Bean 里的属性字段赋值，包括解析@Autowired等注入的属性字段；
  3. 初始化（Initialization）：将属性赋值后的 Bean 注册到 Spring 容器中，这里 Spring 提供了很多拓展接口，支持用户自定义 Bean 的初始化过程中做哪些操作，具体接口在第3小节介绍；
  4. 销毁（Destruction）：销毁 Bean ，通常在 Spring 应用结束时调用。

Bean的生命周期 - 图1

2、面试说辞

Bean的生命周期 - 图2

Bean 生命周期的整个执行过程描述如下：

  1. Spring 启动，查找并加载需要被 Spring 管理的 Bean，对 Bean 进行实例化。
  2. 对 Bean 进行属性注入。
  3. 如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。
  4. 如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用。
  5. 如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用。
  6. 如果 Bean 实现了 BeanPostProcessor 接口，则 Spring 调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作。
  7. 如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法。
  8. 如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法。
  9. 如果 Bean 实现了 BeanPostProcessor 接口，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()，此处非常重要，Spring 的 AOP 就是利用它实现的。
  10. 此时，Bean 已经可以被应用系统使用了。
  11. 如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法销毁 Bean。
  12. 如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁。

3、常用接口方法说明

对于上面的接口和方法，可以分为以下三大类：

  • Bean自身的方法：比如构造函数、getter/setter 以及 Bean 中自定义的初始化方法（init-method）和销毁方法（destory-method）等；
  • Bean直接实现的接口的方法：比如BeanNameAware、BeanFactoryAware、InitializingBean、DisposableBean等方法，这些方法只对当前 Bean 生效；
  • 容器级生命周期的方法：这些接口的实现类是独立于 Bean 的，并且会注册到 Spring 容器中，在 Spring 容器创建任何 Bean 的时候，这些接口对应的方法都会发生作用。比如InstantiationAwareBeanPostProcessor、BeanPostProcessor接口里的方法。

    Bean自身的方法和Bean直接实现的接口的方法都只对当前Bean起作用，但是容器级生命周期方法是对所有的bean都起作用的。

3.1 Bean自身的方法

Bean 的构造方法和 getter/setter 方法就不在介绍了，主要介绍一下通过@Bean(initMethod="initMethod", destroyMethod="destroyMethod")注解实现的初始化和销毁方法。

3.1.1 @Bean(initMethod=”initMethod”, destroyMethod=”destroyMethod”)

Spring 支持用户在 Bean 中自定义 Bean 的初始化和销毁时做的动作，即用户在 Bean 类中声明 public 的初始化和销毁方法，在公共的 BeanConfig 里通过@Bean注解创建这个 Bean 时，在@Bean注解里通过initMethod和destroyMethod参数将 Bean 类中自定义的初始化方法名和销毁方法名传入。

需要注意的是：

  • @Bean注解里initMethod参数指定的初始化 Bean 的方法，是在InitializingBean接口的afterPropertiesSet()方法执行之后再执行的；
  • @Bean注解里destroyMethod参数指定的销毁 Bean 的方法，是在DisposableBean接口的destroy()方法执行之后再实行的。

@Bean(initMethod="initMethod", destroyMethod="destroyMethod")的Demo如下：

  1. @Configuration
  2. @ComponentScans(value= {@ComponentScan("com.jerry.springbootstudy.lifecycle")})
  3. public class LifeCycleConfig {
  5.     @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
  6.     public User user()
  7.     {
  8.         return new User();
  9.     }
  10. }
  12. @Component
  13. public class User implements {
  15.     public void initMethod() {
  16.         System.out.println("调用自定义的init方法初始化方法");
  17.     }
  19.     public void destroyMethod() {
  20.         System.out.println("调用自定义的destroy方法销毁对象");
  21.     }
  22. }

3.2 Bean直接实现的接口的方法

这三个接口在平时开发中基本都没用过。

3.2.1 BeanNameAware接口

BeanNameAware接口是个函数式接口，只有一个方法void setBeanName(String s)，通过该接口可以获取 Bean 的 name，demo 如下：

  1. @Service
  2. public class BizService implements BeanNameAware {
  3.     private String beanName;
  5.     @Override
  6.     public void setBeanName(String s) {
  7.         this.beanName = s;
  8.     }
  10.     public String getBeanName() {
  11.         return beanName;
  12.     }
  13. }

BizService 实例可以通过调用getBeanName()方法获取当前 BizService 实例（Bean）的 beanName。

3.2.2 BeanFactoryAware接口

BeanFactoryAware接口也是一个函数式接口，只有一个方法void setBeanFactory(BeanFactory beanFactory) throws BeansException，通过该接口可以获取当前 Bean 对应的 beanFactory 的引用，demo 如下：

  1. @Service
  2. public class BizService implements BeanFactoryAware {
  3.     private BeanFactory factory;
  5.     @Override
  6.     public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
  7.         this.factory = beanFactory;
  8.     }
  10.     public BeanFactory getFactory() {
  11.         return factory;
  12.     }
  13. }

BizService 实例可以通过调用getFactory()方法获取当前 BizService 实例（Bean）对应的 beanFactory 的引用。

这里简要介绍一下 Spring 的 BeanFactory ：Spring 提供了两种类型的IOC容器：BeanFactory 接口和 ApplicationContext 接口，二者的关系是 BeanFactory 接口是 ApplicationContext 接口的父父接口；
二者的区别在于：

  • BeanFactory 是基础类型的Ioc容器，默认采取延迟初始化（懒加载）策略，所谓懒加载是指在容器初始化时并没有初始化容器中的bean，只有当程序需要访问其中一个被容器管理的对象时才会对bean进行初始化及其注入操作；
  • ApplicationContext 在 BeanFactory 基础上构建，除了拥有 BeanFactory 的所有特性，它还支持事件发布、国际化信息的支持等。另外，ApplicationContext 管理的对象会在容器初始化的时候将其全部初始化。

    3.2.3 ApplicationContextAware接口

    ApplicationContextAware接口也是一个函数式接口，只有一个方法：void setApplicationContext(ApplicationContext applicationContext)throws BeansException，通过该接口可以获取 Spring 的上下文ApplicationContext 实例。Demo 如下： ```java

public class ApplicationContextUtil implements ApplicationContextAware{

  1. private static ApplicationContext applicationContext;
  3. /**
  4.  * 实现ApplicationContextAware接口的回调方法，设置上下文环境
  5.  *
  6.  * @param applicationContext spring上下文对象
  7.  * @throws BeansException 抛出spring异常
  8.  */
  9. @Override
  10. public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  11.     ApplicationContextUtil.applicationContext = applicationContext;
  12. }
  14. /**
  15.  * @return ApplicationContext
  16.  */
  17. public static ApplicationContext getApplicationContext() {
  18.     return applicationContext;
  19. }
  21. /**
  22.  * 获取对象
  23.  *
  24.  * @param name spring配置文件中配置的bean名或注解的名称
  25.  * @return 一个以所给名字注册的bean的实例
  26.  * @throws BeansException 抛出spring异常
  27.  */
  28. @SuppressWarnings("unchecked")
  29. public static <T> T getBean(String name) throws BeansException {
  30.     return (T) applicationContext.getBean(name);
  31. }
  33. /**
  34.  * 获取类型为requiredType的对象
  35.  *
  36.  * @param clazz 需要获取的bean的类型
  37.  * @return 该类型的一个在ioc容器中的bean
  38.  * @throws BeansException 抛出spring异常
  39.  */
  40. public static <T> T getBean(Class<T> clazz) throws BeansException {
  41.     return applicationContext.getBean(clazz);
  42. }
  44. /**
  45.  * 如果ioc容器中包含一个与所给名称匹配的bean定义，则返回true否则返回false
  46.  *
  47.  * @param name ioc容器中注册的bean名称
  48.  * @return 存在返回true否则返回false
  49.  */
  50. public static boolean containsBean(String name) {
  51.     return applicationContext.containsBean(name);
  52. }

}

  1. 获取到了 Spring 的上下文，意味着你可以通过实现类的实例获取 Spring 中的所有 Bean，或者判断当前上下文中是否含有指定名称的 Bean，但貌似实际项目中也没用到过。
  2. <a name="z8YGz"></a>
  3. ### 3.2.4 InitializingBean接口
  4. `InitializingBean`接口也是一个函数式接口，只有一个方法：`void afterPropertiesSet() throws Exception`，通过该接口可以自定义 Bean 初始化时执行的操作。使用场景比如某功能需要在 Spring 启动（对应的就是你这个服务启动）的时候就执行，而不是通过自动注入 Bean 然后调用 Bean 的方法去触发，这个时候就可以将执行操作写在`afterPropertiesSet`方法里，IOC容器选择 ApplicationContext ，在 Spring 容器初始化的时候就初始化 Bean ，进而调用`afterPropertiesSet`方法里要执行的操作。<br />`InitializingBean`接口的简单demo如下：
  5. ```java
  6. @Service
  7. public class TestInitializingBean implements InitializingBean{
  9.     private Logger logger = LoggerFactory.getLogger(TestInitializingBean.class);
  10.     @Override
  11.     public void afterPropertiesSet() throws Exception {
  12.         logger.info("开始工作......");
  14.         logger.info("结束工作......");
  15.     }
  16. }

这里说一下3.1.1中@Bean(initMethod="initMethod", destroyMethod="destroyMethod")中指定的初始化方法和InitializingBean接口的afterPropertiesSet方法的异同点：

  • 相同点：功能都是 Bean 初始化时指定要执行的操作；
  • 不同点：
    • @Bean注解中的init-method参数是通过反射执行的，而afterPropertiesSet是直接执行的，因此afterPropertiesSet的效率要高一些；
    • 执行顺序上**afterPropertiesSet**先执行，**@Bean**注解中的**init-method**后执行。

      3.2.5 DisposableBean接口

      DisposableBean接口也是一个函数式接口，只有一个方法void destroy()，在容器销毁的时候调用，且DisposableBean接口定义的destroy方法先执行，@Bean(initMethod="initMethod", destroyMethod="destroyMethod")中指定的销毁方法后执行。

3.3 容器级生命周期方法

3.3.1 BeanPostProcessor接口

该接口也叫后置处理器，作用是在 Bean 对象在实例化和依赖注入完毕后，在显示调用初始化方法（InitializingBean接口的afterPropertiesSet方法或自定义的init方法）的前后添加我们自己的逻辑。接口中有两个方法，如下：

  1. public interface BeanPostProcessor {
  2.     //实例化、依赖注入完毕，在调用显式的初始化之前完成一些定制的初始化任务。
  3.     Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
  4.     //实例化、依赖注入、初始化完毕时执行定制的任务。
  5.     Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
  6. }

postProcessBeforeInitialization在InitializingBean接口的afterPropertiesSet方法或自定义的init-method方法执行前调用，postProcessAfterInitialization在InitializingBean接口的afterPropertiesSet方法或自定义的init-method方法执行后调用。

3.3.2 InstantiationAwareBeanPostProcessor接口

InstantiationAwareBeanPostProcessor接口是BeanPostProcessor的子接口，该接口跟 Bean 的实例化过程有关，接口中有3个方法（不包含父接口BeanPostProcessor里的2个方法），如下：

  1. package org.springframework.beans.factory.config;
  2. public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
  4.     Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
  6.     boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
  8.     PropertyValues postProcessPropertyValues(
  9.             PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException;
  10. }
postProcessBeforeInstantiation 该方法在目标对象实例化之前调用，该方法的返回值类型是Object。由于这个时候目标对象还未实例化，所以这个返回值可以用来代替原本该生成的目标对象的实例(比如代理对象)。如果该方法返回为null，后续的方法都正常执行，如果该方法返回实例对象，则后续方法都不执行，直接执行BeanPostProcessor接口的postProcessAfterInitialization方法。
postProcessAfterInstantiation 在目标对象实例化之后调用，这个时候对象已经被实例化，但是该实例的属性还未被设置，都是 null。该方法的返回值是决定要不要调用postProcessPropertyValues方法的其中一个因素（因为还有一个因素是mbd.getDependencyCheck()），如果该方法返回 false，并且不需要 check，那么postProcessPropertyValues就会被忽略不执行；如果返回 true，postProcessProperties方法就会被执行。
postProcessProperties 如果postProcessAfterInstantiation方法返回 false，该方法可能不会被调用。此时属性值还未被设置，但是可以通过postProcessProperties方法修改原本应该设置进去的属性值。

注意区分两个单词：

单词 含义 对应接口
Instantiation 表示实例化，对象还未生成 InstantiationAwareBeanPostProcessor接口
Initialization 表示初始化，对象已经生成 BeanPostProcessor接口

3.3.3 BeanFactoryPostProcessor接口

BeanFactoryPostProcessor接口也是一个函数式接口，只有一个方法postProcessBeanFactory，如下：

  1. public interface BeanFactoryPostProcessor {
  2.     void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
  3. }

实现该接口，可以对beanDifinition进行修改。也就是说，Spring 允许BeanFactoryPostProcessor在容器实例化任何 Bean 之前读取配置元数据（beanDifinition），并可以根据需要进行修改，例如可以把 Bean 的 scope 从 singleton 改为 prototype，也可以把 property 的值给修改掉。可以同时配置多个BeanFactoryPostProcessor，并通过设置 order 属性来控制各个BeanFactoryPostProcessor的执行次序。注意：**BeanFactoryPostProcessor**的**postProcessBeanFactory**方法的执行顺序在**InstantiationAwareBeanPostProcessor**接口的**postProcessBeforeInstantiation**方法执行之前。

4、Spring生命周期Demo

根据第一节介绍的 Spring 生命周期详细的过程，设计 Demo 验证整个流程。
User：

  1. @Component
  2. public class User implements InitializingBean, BeanNameAware, DisposableBean {
  4.     @Value("001")
  5.     private String id;
  7.     @Value("Jerry")
  8.     private String name;
  10.     public User() {
  11.         System.out.println("3、调用构造函数");
  12.     }
  14.     public void initMethod() {
  15.         System.out.println("9、调用自定义的init方法初始化方法");
  16.     }
  18.     public void destroyMethod() {
  19.         System.out.println("12、调用自定义的destroy方法销毁对象");
  20.     }
  22.     public String getId() {
  23.         return id;
  24.     }
  26.     public void setId(String id) {
  27.         this.id = id;
  28.         System.out.println("5、属性注入(id)");
  29.     }
  31.     public String getName() {
  32.         return name;
  33.     }
  35.     public void setName(String name) {
  36.         this.name = name;
  37.         System.out.println("5、属性注入(name)");
  38.     }
  40.     @Override
  41.     public void afterPropertiesSet() throws Exception {
  42.         System.out.println("8、调用InitializingBean实例的afterPropertiesSet");
  43.     }
  45.     @Override
  46.     public void setBeanName(String name) {
  47.         System.out.println("6、调用BeanNameAware接口的setBeanName方法");
  48.     }
  50.     @Override
  51.     public void destroy() throws Exception {
  52.         System.out.println("11、调用DisposableBean接口的destroy方法");
  53.     }
  54. }

User类中主要定义了 Bean 自身的方法和 Bean 实现的接口。

MyBeanFactoryPostProcessor：

  1. public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  2.     @Override
  3.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  4.         System.out.println("1、调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法，beanFactory: " + beanFactory);
  5.     }
  6. }

MyBeanPostProcessor：

  1. public class MyBeanPostProcessor implements BeanPostProcessor {
  2.     @Override
  3.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  4.         System.out.println("7、调用BeanPostProcessor接口的postProcessBeforeInitialization方法, bean:" + beanName);
  5.         return bean;
  6.     }
  8.     @Override
  9.     public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  10.         User user = (User) bean;
  12.         System.out.println("10、调用BeanPostProcessor接口的postProcessAfterInitialization方法, user id is: " + user.getId() + ", user name is: " + user.getName());
  13.         return bean;
  14.     }
  15. }

MyInstantiationAwareBeanPostProcessor：

  1. public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
  2.     @Override
  3.     public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
  4.         System.out.println("2、调用InstantiationAwareBeanPostProcessor接口的postProcessBeforeInstantiation方法");
  5.         return null;
  6.     }
  8.     @Override
  9.     public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
  10.         System.out.println("4、调用InstantiationAwareBeanPostProcessor接口的postProcessAfterInstantiation方法");
  11.         return true;
  12.     }
  14.     @Override
  15.     public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
  16.         System.out.println("5、调用InstantiationAwareBeanPostProcessor接口的postProcessProperties方法");
  17.         return pvs;
  18.     }
  19. }

MyBeanFactoryPostProcessor、MyBeanPostProcessor和MyInstantiationAwareBeanPostProcessor是 Spring 容器级方法对应的接口的实现类。

LifeCycleConfig：

  1. @Configuration
  2. @ComponentScans(value= {@ComponentScan("com.jerry.springbootstudy.lifecycle")})
  3. public class LifeCycleConfig {
  5.     @Bean(initMethod = "initMethod", destroyMethod = "destroyMethod")
  6.     public User user()
  7.     {
  8.         return new User();
  9.     }
  11.     @Bean
  12.     public MyBeanPostProcessor myBeanPostProcessor() {
  13.         return new MyBeanPostProcessor();
  14.     }
  16.     @Bean
  17.     public MyBeanFactoryPostProcessor myBeanFactoryPostProcessor() {
  18.         return new MyBeanFactoryPostProcessor();
  19.     }
  21.     @Bean
  22.     public MyInstantiationAwareBeanPostProcessor myInstantiationAwareBeanPostProcessor() {
  23.         return new MyInstantiationAwareBeanPostProcessor();
  24.     }
  25. }

配置类，网上很多例子都是基于 Spring xml 配置文件的，但是现在开发项目中应该基本没有再用xml配置文件的了，都是用的 Config 类导入，这里 LifeCycleConfig 相当于一个主配置类（BeanConfig）。

LifeCycleConfigTest：

  1. public class LifeCycleConfigTest {
  2.     public static void main(String[] args) {
  3.         // 基于配置类创建容器
  4.         AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(LifeCycleConfig.class);
  6.         // 从容器中获取bean
  7.         Object user = ctx.getBean("user");
  9.         // 销毁容器
  10.         ctx.close();
  11.     }
  12. }

注意这里要写成 main 函数启动的方式，而不是之前那种 Spirng 程序的启动方式，测试代码中通过AnnotationConfigApplicationContext生成 Spring 基于注解的上下文，再从上下文中获取 Bean，完成 user Bean 的初始化，并通过打印消息的方式代表对应的初始化方法已经执行了。为了打印结果对齐，没有采用log打印日志，而是通过System.out.println的方式将日志打印到控制台，启动 Spring 应用后，控制台的打印结果如下：
image.png

参考文档

  1. 书籍参考
  2. Spring 通过三级缓存解决循环依赖原理分析
  3. Spring Bean 的生命周期
  4. SpringBoot 生命周期