此文主要讲了Spring中，Bean的生命周期，初始化动作，销毁动作是如何执行。

以及关系生命周期各个接口的作用和自定义实现， 自定义生命周期中执行逻辑的一些使用方式。

比如BeanPostProcessor InitializingBean DisposabbleBean 接口的使用 @postConstruct @PreDestroy 标签的使用 以及对应法法的执行顺序。

对Spring IOC不了解的，可以参考之前两篇文章：
Spring_IOC_01——概念讲解
Spring_IOC_02——原理解析

Spring Bean的生命周期

先通过一个流程图，对Spring Bean 的生命周期有一个整体的了解。

Bean生命周期图解

概述

一个对象的生命周期有：创建（初始化-实例化），使用 和 销毁。Spring中的Bean也遵循这一原则，但是Spring提供了一些对外接口，允许开发者在这三个过程中做一些额外的操作。

注意 实例化 和 初始化 的区别：
在Spring中，实例化，是为Bean对象开辟内存空间（可以理解为构造方法的调用），初始化，则是对属性的初始化，也可以理解为对属性的注入（构造函数也有属性初始化语句，但不属于这部分）
属性的注入，是通过setter方法/参数 注入。不管是通过注解还是XML配置。

相关接口，方法说明

1） Bean自身的方法：init-method / destory-method ， 通过在配置文件bean定义的相应属性中，指定相应的执行方法。

2）Bean级别生命周期接口：BeanNameAware，BeanFactoryAware，IntializaingBean，DiposableBean 这些接口的方法。每个Bean都可以选择实现，可以选择各自的自定义操作。

3）容器级生命周期接口方法：BeanPostProcessor 和 InstantiationAwareBeanPostProcessor（继承自BeanPostProcessor） 这两个的接口的实现。我们一般称之为后置处理器，这个在第二篇文章有讲到。这些接口的实现注册到bean的配置文件中，是每个Bean实例化或者初始化时候都会调用。

4）工厂后处理器接口方法：这些方法也是容器级别的。但是它们是在上下文装置配置文件之后调用。例如：BeanFactoryPostProcessor，CustomAutowireConfigure等。

Bean 具体生命更周期

初始化过程

1） BeanFactoryPostProcessor.postProcessBeanFactory
工厂后处理器（这名字其实只是一个翻译，意义有时候并不一定正确），这个方法其实和Bean的生命周期没多少关系，是 Spring IoC 容器（ApplicationContext）初始化的一部分，详细可以参考 IoC 容器初始化的内容。

具体是每一次刷新时（初始化）调用，它是对 BeanDefinition 进行后处理（BeanDefinition可以参考：SpringIoC容器结构），作用是可以修改配置文件的各个 bean 的配置。
实现：写一个类实现 BeanFactoryPostProcessor 接口，重写该方法，并在Spring配置文件中配置这个类的bean。

2）InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
所有bean对象实例化之前执行，具体就是：执行每个bean类的构造函数之前。
实现：写一个类实现 InstantiationAwareBeanPostProcessor 接口，重写该方法，该方法返回一个Object，但实际上返回一个null即可。在Spring配置文件中配置一个该类的bean。

3）调用Bean的构造函数，实例化bean

4）InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
bean类调用构造函数实例化之后，初始化之前，调用。
实现同第二步，重写该方法。注意：这个返回值是boolean，默认为false。要改为true，否则无法注入属性

5）InstantiationAwareBeanPostProcessor.postProcessPropertyValue
属性注入之前调用该方法。
实现同第二步，注意返回类型是PropertyValues，默认返回null，这里需要改为返回第一个参数propertyValues。

6）BeanNameAware.setBeanName
属性注入后调用，该方法作用是让bean的类知道自己所在的Bean的name或者id属性
实现：bean类实现BeanNameAware接口，重写该方法。

7）BeanFactoryAware.setBeanFactory
setBeanName之后调用，该方法作用是让bean类知道自己所在的BeanFactory的属性（传入bean所在BeanFactory类型参数）
实现：bean类实现BeanFactoryAware接口，重写该方法。

8）BeanPostProcessor.postProcessBeforeInitialization
BeanPostProcessor作用是对bean实例化，初始化做些预处理操作。（具体看上一篇文章 讲 BeanPostProcessor）
实现：写一个类，实现BeanPostProcessor，重写该方法，注意返回类型为Object，默认返回的是null，但需要返回参数中的bean。然后在Spring配置文件中加入这个bean

9）bean里面 @PostConstruct 注解标注的方法

10）InitializingBean.afterPropertiesSet
在Bean加载完成后，执行方法。
实现：bean类实现 InitializingBean 接口。重写该方法，执行初始化工作。但这种方法和Spring耦合，并不推荐（这一点和DisposableBean一样）

11）XML文件中 bean配置的 init-method
xml文件中，bean标签的 init-method属性，可以指定方法。

12）BeanPostProcessor.postProcessAfterInitialization
在bean初始化之后，执行的方法。
实现方式和第8步一样。

销毁过程

1）bean里面 @PreDestory 注解标注的方法

2）DisposableBean.destory
bean销毁前执行的方法。（并不推荐）
实现：bean类实现 DisposableBean 接口，重写该方法即可。

3）XML文件中 bean配置的destory-method
xml文件中，bean标签的 destory-method属性。可以指定方法。

明确一下执行顺序

在配置了BeanProcessor，InstantiationAwareBeanPostProcessor ，实现了InitalizingBean，Bean配置了Init-method，destory-method
代码中指定了 @PostConstruct，@PreDestroy 这些方法后。
Bean初始化时和销毁时，具体执行顺序是什么呢？

代码如下：

//自定义Bean，实现InitializingBean 接口
public class BeanLifeCycleDemo implements InitializingBean {
    public BeanLifeCycleDemo() {
        System.out.println("> Constructor");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("> InitializingBean.afterPropertiesSet");
    }

    public void initMethod(){
        System.out.println("> init-method");
    }
    public void destoryMethod(){
        System.out.println("> destory-method");
    }


    @PostConstruct
    public void postConstructMethod(){
        System.out.println("> postConstruct");
    }
    @PreDestroy
    public void preDestoryMethod(){
        System.out.println("> preDestory");
    }
}

//自定义BeanPostProcessor
public class CustomBeanPostProcessor implements BeanPostProcessor {

    @Nullable
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("> CustomBeanPostProcessor.postProcessBeforeInitialization");
        return bean;
    }

    @Nullable
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("> CustomBeanPostProcessor.postProcessAfterInitialization");
        return bean;
    }
}

//自定义 InstantiationAwareBeanPostProcessor 
public class CustomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Nullable
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("> InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation");
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("> InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation");
        return true;
    }

    @Nullable
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        System.out.println("> InstantiationAwareBeanPostProcessor.postProcessPropertyValues");
        return pvs;
    }
}

//配置如下：

<bean id="beanLifeCycleDemo" class="com.antony.BeanLifeCycleDemo" init-method="initMethod" destroy-method="destoryMethod"></bean>
<bean id="customBeanPostProcessor" class="com.antony.CustomBeanPostProcessor"></bean>
<bean id="customInstantiationAwareBeanPostProcessor" class="com.antony.CustomInstantiationAwareBeanPostProcessor"></bean>

Bean初始化时，方法执行结果如下：

> InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
> Constructor
> InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
> InstantiationAwareBeanPostProcessor.postProcessPropertyValues
> CustomBeanPostProcessor.postProcessBeforeInitialization
> postConstruct (@PostConstruct注解的方法)
> InitializingBean.afterPropertiesSet
> init-method
> CustomBeanPostProcessor.postProcessAfterInitialization

在Bean销毁时，方法的执行顺序为：

> preDestory (@PreDestory注解的方法)
> DisposableBean.destory
> destory-method

（如果有什么错误或者建议，欢迎留言指出）
（本文内容是对各个知识点的转载整理，用于个人技术沉淀，以及大家学习交流用）

参考资料：

SpringBean生命周期详解
spring InitializingBean init-method postConstruct 执行顺序
BeanPostProcessor与InitializingBean接口的关系和应用
InitializingBean与DisposableBean总结

问题：Spring 在什么时候 执行配置的 destory方法？（什么时候决定Bean被销毁）