Spring框架（六）——bean的生命周期

遇到面试官问bean生命周期，让我回答bean生命周期中调用的接口和方法，给我整蒙了

没办法，老老实实学习和记录一下。

对于普通的java对象，通过new方法创建的对象，当没有引用时被垃圾回收机制回收。
而SpringBean对象，Spring会扫描指定包下面的Java类，然后将其变成beanDefinition对象，然后Spring会根据beanDefinition来创建bean，它们的生命周期完全由容器控制。

一、生命周期流程

实例化 -> 属性赋值 -> 初始化 -> 销毁

1. 调用 Bean 构造方法或工厂方法实例化 Bean
2. 利用依赖注入完成 Bean 中所有属性值的配置注入
3. 如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值
4. 如果 Bean 实现了 BeanFactoryAware 接口，则 Spring 调用 setBeanFactory() 方法传入当前工厂实例的引用
5. 如果 Bean 实现了 ApplicationContextAware 接口，则 Spring 调用 setApplicationContext() 方法传入当前 ApplicationContext 实例的引用
6. 如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的预初始化方法 postProcessBeforeInitialzation() 对 Bean 进行加工操作，此处非常重要，Spring 的 AOP 就是利用它实现的
7. 如果 Bean 实现了 InitializingBean 接口，则 Spring 将调用 afterPropertiesSet() 方法
8. 如果在配置文件中通过 init-method 属性指定了初始化方法，则调用该初始化方法
9. 如果 BeanPostProcessor 和 Bean 关联，则 Spring 将调用该接口的初始化方法 postProcessAfterInitialization()。此时，Bean 已经可以被应用系统使用了
10. 如果在<bean> 中指定了该 Bean 的作用范围为 scope=“singleton”，则将该 Bean 放入 Spring IoC 的缓存池中，将触发 Spring 对该 Bean 的生命周期管理；如果在 中指定了该 Bean 的作用范围为 scope=“prototype”，则将该 Bean 交给调用者，调用者管理该 Bean 的生命周期，Spring 不再管理该 Bean
11. 如果 Bean 实现了 DisposableBean 接口，则 Spring 会调用 destory() 方法将 Spring 中的 Bean 销毁；如果在配置文件中通过 destory-method 属性指定了 Bean 的销毁方法，则 Spring 将调用该方法对 Bean 进行销毁

二、接口方法分类

类型	描述
Bean自身的方法	包括了Bean本身调用的方法和通过配置文件中的init-method和destroy-method指定的方法
Bean级生命周期接口方法	包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean这些接口的方法
容器级生命周期接口方法	包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 这两个接口实现的方法，一般称它们的实现类为“后处理器”。
工厂后处理器接口方法	括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工厂后处理器接口的方法

三、演示

1. 调用Bean自身的方法和Bean级生命周期接口方法

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

    private String name;//名称

    private BeanFactory beanFactory;
    private String beanName;
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("传入当前工厂实例");
        this.beanFactory = beanFactory;
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("传入当前 Bean 的 id 值："+s);
        this.beanName =s;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("实现Bean级生命周期接口接口的destroy()");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("实现Bean级生命周期接口的afterPropertiesSet()");
    }



    public String getName() {
        return name;
    }

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

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

}

2.实现BeanPostProcessor接口

public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("预初始化方法对"+bean+"进行加工");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("后初始化方法对"+bean+"进行加工");
        return bean;
    }
}

3. 实现InstantiationAwareBeanPostProcessor接口

InstantiationAwareBeanPostProcessor本质上是BeanPostProcessor的子接口

public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    public MyInstantiationAwareBeanPostProcessor(){
        System.out.println("这是InstantiationAwareBeanPostProcessorAdapter实现类构造器");
    }

    //实例化Bean之前调用
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("实例化前调用InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization（）");
        return bean;
    }

    //实例化Bean之后调用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)  throws BeansException {
        System.out.println("实例化后调用InstantiationAwareBeanPostProcessor.postProcessAfterInitialization（）");
        return bean;
    }

    //设置某个属性时调用
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        System.out.println("设置"+pvs.toString()+"属性时调用InstantiationAwareBeanPostProcessor的postProcessProperties（）");
        return pvs;
    }
}

4.工厂后处理器接口

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    public MyBeanFactoryPostProcessor(){
        System.out.println("实例化MyBeanFactoryPostProcessor构造器");
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("调用BeanFactoryPostProcessor.postProcessBeanFactory（）");
        BeanDefinition bd = configurableListableBeanFactory.getBeanDefinition("userBean");
        System.out.println("实例化Bean:"+bd.toString());
        bd.getPropertyValues().addPropertyValue("name", "测试后工厂方法");
        System.out.println("注入属性:"+bd.getPropertyValues().getPropertyValues());
    }
}

5. 配置文件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

    <bean id="beanPostProcessor" class="com.tung.MyBeanPostProcessor">
    </bean>

    <bean id="instantiationAwareBeanPostProcessor" class="com.tung.MyInstantiationAwareBeanPostProcessor">
    </bean>

    <bean id="beanFactoryPostProcessor" class="com.tung.MyBeanFactoryPostProcessor">
    </bean>

    <bean id="userBean" class="com.tung.UserBean" init-method="myInit"
          destroy-method="myDestory" scope="singleton" p:name="张三"/>

</beans>

6.测试

public class BeanLifeCycle {
    public static void main(String[] argss){
        System.out.println("初始化容器");
        ApplicationContext factory = new ClassPathXmlApplicationContext("/beans.xml");
        System.out.println("容器初始化成功");
        UserBean userBean = factory.getBean("userBean",UserBean.class);
        System.out.println(userBean);
        System.out.println("开始关闭容器");
        ((ClassPathXmlApplicationContext)factory).registerShutdownHook();
    }
}

结果