Spring Bean 的生命周期

1、实例化类
2、设置属性
3、如果实现了 BeanNameAware 接口，则调用其 setBeanName() 方法
4、如果实现了 BeanFactoryAware 接口，则调用其 setBeanFactory() 方法
5、如果实现了 ApplicationContextAware 接口，则调用其 setApplicationContext() 方法
6、如果实在或存在 BeanPostProcessor 接口的实现类，则调用这个实现类的 postProcessBeforeInitialization() 方法
7、如果实现了 InitializingBean 接口，调用其 afterPropertiesSet() 方法
8、如果配置了 initMethod，则调用配置的对应方法
9、如果实在或存在 BeanPostProcessor 接口的实现类，则调用这个实现类的 postProcessAfterInitialization() 方法
=====到此处后，就可以正常使用 Bean =====
10、如果实现了 DisposableBean 接口，则调用其 destroy() 方法
11、如果配置了 destroyMethod，则调用配置的对应方法

上面的很难记住，我们可以把它再分为几个阶段来理解：

一、实例化相关           实例化--->设置属性值

二、声明                     声明Bean名称--->声明BeanFactory--->声明ApplicationContext  

三、初始化                  InitializingBean 的初始化方法 ---> 配置文件中声明的初始化方法（这两个方法会被 BeanPostProcessor 中的方法环绕）

四、 结束                    DisposableBean 的结束方法---> 配置文件中定义的结束方法

下面写一段代码来验证一下：

// 自定义的 Bean
public class TestBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware,
    InitializingBean, DisposableBean{

    private String name;

    public TestBean() {
        System.out.println("执行无参构造器");
    }

    public TestBean(String name) {
        System.out.println("执行有参构造器");
        this.name = name;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("执行 InitializingBean 接口的 afterPropertiesSet 方法进行初始化");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("执行 DisposableBean 接口的 destroy 方法");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("执行 BeanNameAware 接口的 setBeanName 方法，用来声明 Bean 名称");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("执行 BeanFactoryAware 接口的 setBeanFactory 方法，用来声明其所在的 BeanFactory");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("执行 ApplicationContextAware 接口的 setApplicationContext 方法，用来声明其所在的 ApplicationContext");
    }

    public void myinit() {
        System.out.println("执行自己在配置文件中定义的初始化方法");
    }

    public void mydestroy() {
        System.out.println("执行自己在配置文件中定义的结束方法");
    }
}

// BeanPostProcessor
public class MyBeanPostProcessor implements BeanPostProcessor {

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

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

// 配置类
@Configuration
public class BeanConfig {
    @Bean(initMethod = "myinit", destroyMethod = "mydestroy")
    public TestBean testBean1() {
        return new TestBean("hello");
    }

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
            BeanConfig.class);
        context.registerShutdownHook();
    }
}

执行结果如下：

执行有参构造器
执行 BeanNameAware 接口的 setBeanName 方法，用来声明 Bean 名称
执行 BeanFactoryAware 接口的 setBeanFactory 方法，用来声明其所在的 BeanFactory
执行 ApplicationContextAware 接口的 setApplicationContext 方法，用来声明其所在的 ApplicationContext
postProcessBeforeInitialization : testBean1
执行 InitializingBean 接口的 afterPropertiesSet 方法进行初始化
执行自己在配置文件中定义的初始化方法
postProcessAfterInitialization : testBean1
执行 DisposableBean 接口的 destroy 方法
执行自己在配置文件中定义的结束方法