Bean 的生命周期

—— BeanFactory 中 Bean 的生命周期

1 生命周期图解

BeanFactory 中 Bean 的生命周期.png

在图中带“★”的步骤是由 InstantiationAwareBeanPostProcessor 和 BeanPostProcess 这两个接口实现的，一般称它们的实现为“后处理器”。实现类以容器附加装置的形式注册到 Spring 容器中，并通过接口反射为 Spring 容器扫描识别。这些后处理器的影响是全局性的，即当 Spring 容器创建任何 Bean 的时候，这些后处理器都会发生作用！

2 Bean 生命周期实例

2.1 实现各种生命周期控制访问的 Car

package org.sysu.SpringTest;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

public class Car implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean{
    private String brand;
    private String color;
    private int maxSpeed;

    private BeanFactory beanFactory;
    private String beanName;

    public Car() {
        System.out.println("2、调用 Car()，实例化");
    }

    public String getColor() {
        return this.color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getMaxSpeed() {
        return this.maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }

    public void setBrand(String brand) {
        System.out.println("5、调用 setBrand()");
        this.brand = brand;
    }

    public void introduce() {
        System.out.println("brand: " + color + "; color: " + color + " maxSpeed: " + maxSpeed);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("7、实现 BeanFactoryAware.setBeanFactory() 接口方法，将 BeanFactory 容器实例设置到 Bean 中");
        this.beanFactory = beanFactory;
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("6、实现 BeanNameAware.setBeanName() 接口方法，将配置文件中该 Bean 对应的名称设置到 Bean 中");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("12、实现 DisposableBean.destroy() 接口方法");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("9、实现 InitializingBean.afterPropertiesSet() 接口方法");
    }

    public void myInit() {
        System.out.println("10、通过 init-method 属性配置的初始化方法");
        this.maxSpeed = 240;
    }

    public void myDestroy() {
        System.out.println("13、通过 destroy-method 属性配置的销毁方法");
    }
}

2.2 InstantiationAwareBeanPostProcessor 实现类

package org.sysu.SpringTest;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

import java.beans.PropertyDescriptor;

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {

        if ("car".equals(beanName)) {
            System.out.println("1、调用 InstantiationAwareBeanPostProcessorAdapter.postProcessBeforeInitialization() 方法");
        }
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if ("car".equals(beanName)) {
            System.out.println("3、调用 InstantiationAwareBeanPostProcessorAdapter.postProcessAfterInitialization() 方法");
        }
        return true;
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        if ("car".equals(beanName)) {
            System.out.println("4、调用 InstantiationAwareBeanPostProcessorAdapter.postProcessPropertyValues() 方法");
        }
        return pvs;
    }
}

2.3 BeanPostProcessor 实现类

package org.sysu.SpringTest;

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

public class MyBeanPostProcessor implements BeanPostProcessor {

    /**
     * @param o 当前正在处理 Bean
     * @param s 当前 Bean 的配置名
     * @return java.lang.Object
     */
    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        if (s.equals("car")) {
            Car car = (Car)o;
            if (car.getColor() == null) {
                System.out.println("8、调用 BeanPostProcessor.postProcessBeforeInitialization()，color为空，设置为黑");
                car.setColor("黑色");
            }

        }
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        if (s.equals("car")) {
            Car car = (Car)o;
            if (car.getMaxSpeed() >= 200) {
                System.out.println("11、调用 BeanPostProcessor.postProcessAfterInitialization()，若速度大于200，则调整为200");
                car.setMaxSpeed(200);
            }
        }
        return o;
    }
}

2.4 配置 Car： Beans.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" xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="car" class="org.sysu.SpringTest.Car"
          init-method="myInit"
          destroy-method="myDestroy"
          p:brand="AE86"
          p:maxSpeed="250" />
</beans>

2.5 容器装载配置文件，注册后处理器

package org.sysu.SpringTest;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;

public class BeanLifeCycle {
    public static void LifeCycleInBeanFactory() {
        // 装载配置文件并启动容器
        ClassPathResource res = new ClassPathResource("org/sysu/SpringTest/Beans.xml");

        BeanFactory bf = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory)bf);
        reader.loadBeanDefinitions(res);

        // 向容器中注册 MyBeanPostProcessor 后处理器
        ((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyBeanPostProcessor());

        // 向容器中注册 MyInstantiationAwareBeanPostProcessor 后处理器
        ((ConfigurableBeanFactory)bf).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());

        // 第一次从容器中获取 Car，将触发容器实例化该 Bean，这将引发 Bean 生命周期方法的调用
        Car car1 = (Car)bf.getBean("car");
        car1.introduce();
        car1.setColor("红色");

        // 第二次从容器中获取 Car，直接从缓存池中获取
        Car car2 = (Car)bf.getBean("car");

        // 查看 car1 和 car2 是否指向同一引用
        System.out.println("car1 == car2: " + (car1 == car2));

        // 关闭容器
        ((DefaultListableBeanFactory)bf).destroySingletons();

    }

    public static void main(String args[]) {
        LifeCycleInBeanFactory();
    }
}

注意在向容器中注册后处理器时，我们对 BeanFactory 类型的 bf 变量进行了强制类型转换，因为用于注册后处理器的 addBeanPostProcessor() 方法是在 ConfigurableBeanFactory 接口中定义的。
如果有多个后处理器，这可以按照相似的方式调用 addBeanPostProcessor() 方法进行注册。后处理器的实际调用顺序与注册顺序无关，在具有多个后处理器的情况下，必须通过实现 org.springframework.core.Ordered接口来确定调用顺序。详见文章《Spring点滴五：Spring中的后置处理器BeanPostProcessor讲解》

2.6 运行结果

BeanFactory 运行结果.png

2.7 将 Bean 的作用范围定义为 prototype

    <bean id="car" class="org.sysu.SpringTest.Car"
          init-method="myInit"
          destroy-method="myDestroy"
          scope="prototype"
          p:brand="AE86"
          p:maxSpeed="250" />

运行结果

BeanFactory prototype.png

由此可知，[singleton] 会将实例化 Car 放入缓存池中，然后再将这个 Bean 引用返回给调用者。当再次从容器获取 car Bean，Bean 将从容器缓存池中直接取出，不会引发生命周期相关方法的执行。
[prototype] 会将准备就绪的 Bean 交给调用者，则第二次 getBean() 时，生命周期方法会再次被调用，因为 prototype 范围的 Bean 每次都返回新的实例。

3 深入剖析

如果用户希望将业务完全 POJO 化，则可以只实现自己的业务接口，不需要和某个特定框架的接口关联（解耦）。可以通过 <bean> 的 init-method 和 destroy-method 属性配置方式为 Bean 指定初始化和销毁方法。而不是通过实现 InitializingBean 和 DisposableBean 接口方式，尽管二者效果完全相同。
一般情况下，用户不需要关心 BeanFactoryAware 和 BeanNameAware 接口。前者让 Bean 感知容器（BeanFactory 实例），而后者让 Bean 获得配置文件对应的配置名称。如果 Bean 希望获取容器中的其他 Bean，则可以通过属性注入的方式引用这些 Bean；如果 Bean 希望在运行期获知配置文件中的 Bean 名称，则可以简单地将名称作为属性注入。
因此，除非编写一个基于 Spring 之上的扩展插件或子项目之类的东西，否则不需要理会以上 4 个 Bean生命周期的接口类。