Spring bean 生命周期

1. 概述

  一个普通对象的生命周期有：

  Spring对象的周期肯定也会遵守这个过程，但是Spring这个功能强大的轻量级框架提供了很多对外的接口，允许我们程序员对这三个过程（实例化，初始化，销毁）的前后增加一些操作。
  在Spring Bean中，实例化其实是在为bean对象在容器里开辟空间，初始化则是对属性的注入。

2. 具体生命周期

1. 先实例化 BeanFactoryPostProcessor(Bean工厂后处理器)

     Bean创建之前，读取Bean的元属性，并根据自己的需求对元属性进行改变，比如将Bean的scope从singleton改变为prototype。

2. 调用 BeanFactoryPostProcessor 的 postProcessBeanFactory 方法

     此方法只会执行一次,并且携带了每个bean的基本信息。

3. 实例化 BeanPostProcessor（Bean后处理器）

     即调用setter方法。

4. 实例化 InstantiationAwareBeanPostProcessorAdapter（后处理器适配器 ）

5. 调用 InstantiationAwareBeanPostProcessorAdapter 的 postProcessBeforeInitialization 方法
   这个方法能有效地抑制目标bean的默认实例化，返回的是要公开的bean对象而不是目标bean的默认实例，或要处理默认实例化的null。

6. 执行Bean构造器，开始实例化Bean

7. 调用 InstantiationAwareBeanPostProcessorAdapter 的 postProcessAfterInitialization 方法
   这是在给定bean实例上执行字段注入的理想回调，如果应该在bean上设置属性，则为true;如果应该跳过属性填充，则为false。正常的实现应该返回true。返回false还将防止在此bean实例上调用任何后续的InstantiationAwareBeanPostProcessor实例。

8. 调用 InstantiationAwareBeanPostProcessorAdapter 的 postProcessPropertyValues方法

     扫描带有注解的字段和方法，并注入到Bean中。

9. 给已经实例化的bean注入属性值

10. 调用 BeanFactoryAware 的 setBeanName 方法

      让Bean对象获取自己在BeanFactory配置中的name或者id，但是这个时候还不能被getBean

11. 调用 BeanFactoryAware 的 setBeanFactory方法

      可以在该Bean被加载的过程中获取加载该Bean的BeanFactory，同时也可以获取这个BeanFactory中加载的其它Bean

12. 调用 BeanPostProcessor 的 postProcessBeforeInitialization 方法在bean初始化前对bean对象属性，bean对象的name等进行自定义处理。

13. 调用 InitializingBean 的 afterPropertiesSet 方法

      在Bean的属性都设置值后被调用，用于完成初始化工作。

14. 调用的init-method属性指定的初始化方法。

15. 调用 BeanPostProcessor 的 postProcessAfterInitialization方法在bean初始化后对bean对象属性，bean对象的name等进行自定义处理。

16. 正常调用方法

17. 调用 DisposableBean 的 destroy 方法

      用于做一些销毁的收尾工作

18. 调用的 destroy-method 属性指定的销毁方法

3. 大致流程图

4. 代码实现

BeanFactoryPostProcessor

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor() {
        super();
        System.out.println("实例化 BeanFactoryPostProcessor 实现类");
    }

    @Override
    public void postProcessBeanFactory
    (ConfigurableListableBeanFactory configurableListableBeanFactory)
     throws BeansException {
        System.out.println("执行 BeanFactoryPostProcessor 的 postProcessBeanFactory方法");
    }
}

BeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor() {
        super();
        System.out.println("实例化 BeanPostProcessor 实现类");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) 
    throws BeansException {
        System.out.println("执行 BeanPostProcessor 的 postProcessBeforeInitialization 方法");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) 
    throws BeansException {
        System.out.println("执行 BeanPostProcessor 的 postProcessAfterInitialization 方法");
        return null;
    }
}

InstantiationAwareBeanPostProcessorAdapter

public class MyInstantiationAwareBeanPostProcessorAdapter extends
     InstantiationAwareBeanPostProcessorAdapter {

    public MyInstantiationAwareBeanPostProcessorAdapter() {
        super();
        System.out.println("实例化 InstantiationAwareBeanPostProcessorAdapter 实现类");
    }

    @Override
    public Object postProcessBeforeInstantiation
    (Class<?> beanClass, String beanName) 
    throws BeansException {
        System.out.println("执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessBeforeInitialization 方法");
        return super.postProcessBeforeInstantiation(beanClass, beanName);
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) 
    throws BeansException {
        System.out.println("执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessAfterInitialization 方法");
        return super.postProcessAfterInstantiation(bean, beanName);
    }

    @Override
    public PropertyValues postProcessPropertyValues
    (PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) 
    throws BeansException {
        System.out.println("执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessPropertyValues 方法");
        return super.postProcessPropertyValues(pvs, pds, bean, beanName);
    }
}

Person

public class Person implements BeanFactoryAware, BeanNameAware,
        InitializingBean, DisposableBean {

    public Person() {
        System.out.println("执行 Bean 的构造器");
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("为Bean注入属性");
        this.name = name;
    }

    public void user(){
        System.out.println("正常调用");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) 
    throws BeansException {
        System.out.println("调用 BeanFactoryAware 的 setBeanFactory 方法");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("调用 BeanFactoryAware 的 setBeanName 方法");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("调用 DisposableBean 的 destroy 方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("调用 InitializingBean 的 afterPropertiesSet 方法");
    }

    public void myInit(){
        System.out.println("调用<bean>的 init-method 属性指定的初始化方法");
    }

    public void myDestroy(){
        System.out.println("调用<bean>的 destroy-method 属性指定的销毁方法");
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean class="com.MyBeanPostProcessor"></bean>

    <bean class="com.MyInstantiationAwareBeanPostProcessorAdapter"></bean>

    <bean class="com.MyBeanFactoryPostProcessor"></bean>

    <bean class="com.Person" id="person" init-method="myInit" destroy-method="myDestroy">
        <property name="name" value="name"></property>
    </bean>

</beans>

测试

public class Main {
    public static void main(String[] args) {
        ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");

        Person person = application.getBean("person", Person.class);
        person.user();

        System.out.println("开始销毁容器");

        ((ClassPathXmlApplicationContext) application).close();
    }
}

运行结果

实例化 BeanFactoryPostProcessor 实现类
执行 BeanFactoryPostProcessor 的 postProcessBeanFactory方法
实例化 BeanPostProcessor 实现类
实例化 InstantiationAwareBeanPostProcessorAdapter 实现类
执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessBeforeInitialization 方法
执行 Bean 的构造器
执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessAfterInitialization 方法
执行 InstantiationAwareBeanPostProcessorAdapter 的 postProcessPropertyValues 方法
为Bean注入属性
调用 BeanFactoryAware 的 setBeanName 方法
调用 BeanFactoryAware 的 setBeanFactory 方法
执行 BeanPostProcessor 的 postProcessBeforeInitialization 方法
调用 InitializingBean 的 afterPropertiesSet 方法
调用<bean>的 init-method 属性指定的初始化方法
执行 BeanPostProcessor 的 postProcessAfterInitialization 方法
正常调用
开始销毁容器
调用 DisposableBean 的 destroy 方法
调用<bean>的 destroy-method 属性指定的销毁方法

Process finished with exit code 0

5. 依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.1.RELEASE</version>
    </dependency>
</dependencies>

6. 项目结构