Java作为一门面向对象的语言，写程序的过程就是创建各种对象的过程。创建bean的方式多种多样，比如通常我们使用new创建一个“新”的对象，当整个对象没有任何引用的时候就会被jvm回收。而Spring的核心之一就是创建和管理这些对象（bean），Spring使用IoC容器托管对象，所以既然创建和管理对象都是容器来完成的，那么容器控制着bean的生命周期。

正因为Spring控制着对象的整个创建到销毁的流程，那么我们就能通过Spring提供的接口在bean声明周期的某一时刻做一些我们想要做的事情。

我们通常使用ApplicationContext作为Spring容器。这里，我们讲的也是 ApplicationContext中Bean的生命周期。而实际上BeanFactory也是差不多的，只不过处理器需要手动注册。

ApplicationContext的声明周期流程图

ApplicationContext中Bean的生命周期

Spring 只帮我们管理单例模式 Bean 的完整生命周期，对于 prototype 的 bean ，Spring 在创建好交给使用者之后则不会再管理后续的生命周期。

Bean生命周期相关接口

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：
1、Bean自身的方法：这个包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法
2、Bean级生命周期接口方法：这个包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法
3、容器级生命周期接口方法：这个包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。
4、工厂后处理器接口方法：这个包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法。工厂后处理器也是容器级的。在应用上下文装配配置文件之后立即调用。

示例代码

package com.lvxiao.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * @author lvxiao
 * @version V1.0
 * @date 2019-08-19 23:48
 */
public class LifeCycleBean implements BeanFactoryAware, BeanNameAware,
        InitializingBean, DisposableBean, ApplicationContextAware {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public LifeCycleBean() {
        System.out.println("3.执行实例化方法");
    }

    public void init() {
        System.out.println("12.执行init");
    }
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("8.调用setBeanFactory()");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("7.调用setBeanName()");

    }
    public void myDestroy() {
        System.out.println("15.myDestroy()");
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("14.调用destroy()");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("11.执行afterPropertiesSet()");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("9.调用setApplicationContext()");
    }
}

package com.lvxiao.spring.bean;

import com.lvxiao.spring.bean.LifeCycleBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author lvxiao
 * @version V1.0
 * @date 2019-08-20 00:29
 */
@ComponentScan(basePackages = "com.lvxiao.spring.bean")
@Configuration
public class LifeCycleBeanConfig {
    @Bean(initMethod = "init", destroyMethod = "myDestroy")
    public LifeCycleBean lifeCycleBean() {
        LifeCycleBean lifeCycleBean = new LifeCycleBean();
        lifeCycleBean.setName("set方法设置了一个名字");
        return lifeCycleBean;
    }
}

package com.lvxiao.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

/**
 * @author lvxiao
 * @version V1.0
 * @date 2019-08-20 00:03
 */
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

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

package com.lvxiao.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @author lvxiao
 * @version V1.0
 * @date 2019-08-20 00:25
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof LifeCycleBean) {
            System.out.println("10.执行postProcessBeforeInitialization()");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof LifeCycleBean) {
            System.out.println("13.执行postProcessAfterInitialization()");
        }
        return bean;
    }
}

package com.lvxiao.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;
import org.springframework.stereotype.Component;

import java.beans.PropertyDescriptor;

/**
 * @author lvxiao
 * @version V1.0
 * @date 2019-08-20 00:05
 */
@Component
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (beanName.equals("lifeCycleBean")) {
            System.out.println("2.执行postProcessBeforeInstantiation()");
        }
        return null;
    }
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (bean instanceof LifeCycleBean) {
            System.out.println("4.执行postProcessAfterInstantiation()");
        }
        return true;
    }


    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        if (bean instanceof LifeCycleBean) {
            System.out.println("5.执行postProcessPropertyValues()");
        }
        return null;
    }
}

测试

package com.lvxiao.spring.bean;

import com.lvxiao.spring.bean.LifeCycleBean;
import com.lvxiao.spring.bean.LifeCycleBeanConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author lvxiao
 * @version V1.0
 * @date 2019-08-20 00:32
 */
public class LifeCycleTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(LifeCycleBeanConfig.class);
        LifeCycleBean bean = (LifeCycleBean) context.getBean("lifeCycleBean");
        System.out.println(bean.getName());
        context.close();
    }
}

运行的结果如下：

1.执行postProcessBeanFactory()方法
2.执行postProcessBeforeInstantiation()
3.执行实例化方法
4.执行postProcessAfterInstantiation()
5.执行postProcessPropertyValues()
7.调用setBeanName()
8.调用setBeanFactory()
9.调用setApplicationContext()
10.执行postProcessBeforeInitialization()
11.执行afterPropertiesSet()
12.执行init
13.执行postProcessAfterInitialization()
set方法设置了一个名字
14.调用destroy()
15.myDestroy()

参考文章：
http://www.cnblogs.com/zrtqsk/
https://www.zhihu.com/question/38597960