说说 Spring Bean 的生命周期

2018-04-26 本文已影响97人 deniro

在 Spring 中，我们可以从两个层面定义 Bean 的生命周期：

Bean 的作用范围。
实例化 Bean 时所经历的一系列阶段。

1 BeanFactory 中 Bean 的生命周期

1.1 生命周期过程

BeanFactory 中 Bean 的生命周期

过程如下：

当调用者通过 getBean(beanName) 向容器请求某一个 Bean 时，如果容器注册了 org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口，则在实例化 Bean 之前，将调用接口的 postProcessBeforeInstantiation() 方法；
根据配置情况调用 Bean 构造函数或工厂方法实例化 Bean；
如果容器注册了 InstantiationAwareBeanPostProcessor 接口，那么在实例化 Bean 之后，会调用该接口的 postProcessAfterInstantiation() 方法，对已经实例化的对象进行加工处理；
如果 Bean 配置了属性信息，容器将在这一步着手将配置值设置到 Bean 对应的属性中，不过在设置每个属性之前将先调用 InstantiationAwareBeanPostProcessor 接口的 postProcessPropertyValues() 方法；
调用 Bean 的属性设置方法设置属性值；
如果 Bean 实现了 org.springframework.beans.factory.BeanNameAware 接口，将调用 setBeanName() 接口方法，将配置文件中该 Bean 对应的名称设置到 Bean 中；
如果 Bean 实现了 org.springframework.beans.factory.BeanFactoryAware 接口，则将调用 setBeanFactory() 接口方法，将 BeanFactory 容器实例设置到 Bean 中；
如果 BeanFactory 装配了 org.springframework.beans.factory.config.BeanPostProcessor 后处理器，将调用 BeanPostProcessor 的 Object postProcessBeforeInitialization(Object bean, String beanName) 接口方法对 Bean 进行加工操作。其中入参 bean 是当前正在处理的 Bean ，而 beanName 是当前 Bean 的配置名，返回的对象为加工处理后的 Bean。
如果 Bean 实现了 InitializingBean 的接口，将调用接口的 afterPropertiesSet() 方法；
如果在 <bean> 通过 init-method 属性定义了初始化方法，将执行这个方法；
BeanPostProcessor 后处理器定义了两个方法：其一是 postProcessBeforeInitialization()，它在第 8 步被调用；其二是 Object postProcessAfterInitialization(Object bean, String beanName) 方法，这个方法在此时被调用，可以再次对 Bean 进行加工处理；
如果在 <bean> 中指定 Bean 的作用范围为 scope="prototype"，则将 Bean 返回给调用者，由调用者负责 Bean 后续生命的管理。如果作用范围设置为 scope="singleton" ，则将 Bean 放入到 Spring IoC 容器的缓存池中，并将 Bean 的引用返回给调用者， Spring 继续对这些 Bean 进行后续的生命管理；
对于 scope="singleton" 的 Bean ，当容器关闭时，将触发 Spring 对 Bean 的后续生命周期的管理工作，如果 Bean 实现了 DisposableBean 接口，则将调用接口的 afterPropertiesSet()方法，可以在此编写释放资源、记录日志等操作；
对于 scope="singleton" 的 Bean ，如果通过 <bean> 的 destroy-method 属性指定了 Bean 的销毁方法， Spring 将执行 Bean 的这个方法，完成 Bean 资源的释放等操作。

Bean 的完整生命周期从 Spring 容器着手实例化 Bean 开始，直到最终销毁 Bean ，这当中经过了许多关键点，每个关键点都涉及特定的方法调用，可以将这些方法大致划分为 4 类：

Bean 自身的方法：如调用 Bean 构造函数实例化 Bean、调用 Setter 设置 Bean 的属性值以及通过 <bean> 的 init-method 和 destroy-method 所指定的方法；
Bean 级生命周期接口方法：如 BeanNameAware、BeanFactoryAware、InitializingBean 和 DisposableBean ，这些接口方法由 Bean 类直接实现；
容器级生命周期接口方法：在上图中带 "锚" 的步骤是由InstantiationAwareBeanPostProcessor 和BeanPostProcessor 这两个接口实现的，一般称它们的实现类为 “后处理器”。后处理器接口一般不由 Bean 本身实现，它们独立于 Bean ，实现类以容器附加装置的形式注册到 Spring 容器中并通过接口反射被 Spring 容器识别。当 Spring 容器创建 Bean 时，这些后处理器都会发生作用，所以这些后处理器的影响是全局性的。当然，用户也可以通过合理地编写后处理器，让其仅对感兴趣 Bean 进行加工处理。
工厂后处理接口方法：包括 AspectJWeavingEanbler、CustomAutowireConfigurer、ConfigurationClassPostProcessor 等方法。它们也是容器级的方法，会在应用上下文装配好配置文件后，被立即调用。

Bean 级生命周期接口和容器级生命周期接口是个性和共性辩证统一思想的体现，前者解决了 Bean 个性化处理的问题；而后者解决了容器中某些 Bean 共性化处理的问题。

Spring 容器中可以注册多个后处理器。只要它们同时实现了 org.springframework.core.Ordered 接口，容器将按特定的顺序依次调用这些后处理器。在上图中带 “锚” 的步骤，都可以调用多个后处理器进行一系列的加工处理操作。

InstantiationAwareBeanPostProcessor 是 BeanPostProcessor 接口的子接口，它的适配器类是 InstantiationAwareBeanPostProcessorAdapter ，我们可以方便地扩展这个适配器类来自定义自己感兴趣的方法。

1.2 体验生命周期

我们创建一个类，让它实现所有 Bean 级的生命周期接口，此外，还通过 <bean> 的 init-method 和 destroy-method 属性定义了 Bean 初始化和 Bean 销毁的方法。

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

    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private int age;

    /**
     * 默认构造函数
     */
    public People() {
    }

    /**
     * 带参数的构造函数
     *
     * @param name
     * @param age
     */
    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

  

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("setBeanFactory");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("setBeanName");
    }

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

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

    public void customInit(){
        System.out.println("自定义 customInit");
    }

    public void customDestroy(){
        System.out.println("自定义 customDestroy");
    }
}

XML 配置：

<bean id="people" class="net.deniro.springBoot.spring4.IoC.People"
  init-method="customInit"
  destroy-method="customDestroy"
    />

通过继承 InstantiationAwareBeanPostProcessorAdapter，可以自定义后处理器：

public class CustomInstantiationAwareBeanPostProcessor extends
        InstantiationAwareBeanPostProcessorAdapter {

    public static final String PEOPLE_BEAN = "people";

    /**
     * 在实例化 Bean 之前调用
     *
     * @param beanClass
     * @param beanName
     * @return
     * @throws BeansException
     */
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        if (PEOPLE_BEAN.equals(beanName)) {
            System.out.println("postProcessBeforeInstantiation");
        }
        return null;
    }

    /**
     * 在实例化 Bean 之后调用
     *
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        if (PEOPLE_BEAN.equals(beanName)) {
            System.out.println("postProcessAfterInstantiation");
        }
        return true;
    }

    /**
     * 设置某个属性
     *
     * @param pvs
     * @param pds
     * @param bean
     * @param beanName
     * @return
     * @throws BeansException
     */
    public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        if (PEOPLE_BEAN.equals(beanName)) {
            System.out.println("postProcessPropertyValues");
        }
        return pvs;
    }

}

还可以通过实现 CustomBeanPostProcessor，来自定义后处理器，我们可以针对那些感兴趣的 Bean 进行加工处理：

public class CustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals(PEOPLE_BEAN)) {
            People people = (People) bean;
            if (people.getName() == null) {
                people.setName("deniro");
                System.out.println("postProcessBeforeInitialization："+people);
            }
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (beanName.equals(PEOPLE_BEAN)) {
            People people = (People) bean;
            if (people.getAge() == 0) {
                people.setAge(25);
                System.out.println("postProcessAfterInitialization："+people);
            }
        }
        return bean;
    }
}

测试代码：

/**
 * 加载配置文件并启动
 */
Resource resource = new ClassPathResource("beans2.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(
        factory);
reader.loadBeanDefinitions(resource);

//注册后处理器
factory.addBeanPostProcessor(new CustomBeanPostProcessor());
factory.addBeanPostProcessor(new CustomInstantiationAwareBeanPostProcessor());

//从容器中获取 People，实例化该 Bean，这将引发 Bean 生命周期方法的调用
People people1 = (People) factory.getBean("people");
System.out.println("people1：" + people1);
people1.setName("lily");
System.out.println("new people1：" + people1);

//第二次从缓存池中获取 Bean
People people2 = (People) factory.getBean("people");
System.out.println("people1==people2:" + (people1 == people2));

//关闭容器
factory.destroySingletons();

我们首先装载了配置文件并启动容器。然后向容器中注册了 CustomBeanPostProcessor 处理器。如果有多个后处理器，可按照相似的方式调用 addBeanPostProcessor() 方法进行注册，需要强调的是，后处理器的实际调用顺序和注册顺序是无关的，在具有多个后处理器的情况下，必须通过实现的 org.springframework.core.Ordered 接口以确定调用顺序。

1.3 讨论

可以通过 <bean> 的 init-method 和 destroy-method 属性的配置方式为 Bean 指定初始化和销毁的方法，这样可以实现业务类完全 POJO 化，这些类只实现自己的业务接口，不需要和某个特定框架（包括 Spring 框架）的接口关联，从而达到了与框架解耦的目的。

Spring 中还添加了一个 InitDestroyAnnotationBeanPostProcessor ，该 Bean 后处理器将对标注了 @PostConstruct、@PreDestroy 注解的 Bean 进行处理，在 Bean 初始化后及销毁前执行相应的逻辑。如果在 ApplicationContext 中，则默认装配了该处理器。

BeanFactoryAware 接口可以让 Bean 感知容器（即 BeanFactory 实例），而 BeanNameAware 接口可以让 Bean 获得配置文件中对应的配置名称。如果希望 Bean 获取容器中的其他 Bean ，则可以通过属性注入的方式引用这些 Bean ，如果 Bean 希望在运行期获知在配置文件中的 Bean 名称，也可以简单地将名称作为属性注入。

所以除非想要编写一个基于 Spring 之上的扩展插件或子项目，否则用户完全可以抛开Bean 生命周期的接口类。

而 BeanPostProcessor 接口要求 Bean 去继承它，所以可以完全像一个插件那样，把它注册到 Spring 容器中，从而为容器提供额外功能。比如 Spring 容器就利用了 BeanPostProcessor 对 Bean 进行加工处理，比如 Spring 的 AOP 功能。

2 ApplicationContext 中 Bean 的生命周期

Bean 在应用上下文中的生命周期和在 BeanFactory 中的生命周期类似，不同是，如果 Bean 实现了 org.springframework.context.ApplicationContextAware 接口，则会增加一个调用该接口方法 setApplicationContext() 的步骤。

如果配置文件中定义了多个工厂后处理器，需要让它们实现 org.springframework.core.Ordered 接口，这样才能让 Spring 以确定的顺序调用它们。工厂后处理器是容器级的，仅在应用上下文初始化时调用一次，用于完成一些配置文件的加工处理工作。

ApplicationContext 和 BeanFactory 另一个不同之处是：前者会利用 Java 的反射机制自动识别出配置文件中定义的 BeanPostProcessor、InstantiationAwareBeanPostProcessor 和 BeanFactoryPostProcessor，并自动将它们注册到应用上下文中；而后者需要在代码中通过手工调用 addBeanPostProcessor() 方法进行注册。这也是为什么在应用开发时，我们普遍使用的是 ApplicationContext 而很少使用 BeanFactory 的原因之一。

在 ApplicationContext 中，我们只需要在配置文件中通过 <bean> 定义工厂后处理器和 Bean 后处理器，它们就会按照预期的方式运行。

ApplicationContext 中 Bean 的生命周期

现在请看一个使用工厂后处理器的实例，我们在此改变了 people 实例的 name：

public class CustomBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinition definition=beanFactory.getBeanDefinition("people");

        definition.getPropertyValues().addPropertyValue("name","jack");
        System.out.println("CustomBeanFactoryPostProcessor.postProcessBeanFactory()");
    }
}

ApplicationContext 在启动时，将首先为配置文件中每个 <bean> 生成一个 BeanDefinition 对象， BeanDefinition 是 <bean> 在 Spring 容器中的内部表示。

配置文件：

<bean id="people" class="net.deniro.spring4.IoC.People"
     init-method="customInit"
     destroy-method="customDestroy"
       />

<!-- 工厂的后处理器-->
<bean id="customBeanFactoryPostProcessor"
     class="net.deniro.spring4.bean.CustomBeanFactoryPostProcessor"/>

<!-- 注册 Bean 的后处理器-->
<bean id="customBeanPostProcessor"
     class="net.deniro.spring4.bean.CustomBeanPostProcessor"/>

定义的 BeanPostProcessor 和 BeanFactoryPostProcessor 会自动被 ApplicationContext 识别并注册到容器中。启动容器（比如 tomcat）就可以看到结果啦O(∩_∩)O哈哈~

注意：需要在 web.xml 中设置 spring 配置文件：

...
<!-- 加载 Spring 配置文件-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:beans2.xml</param-value>
</context-param>
...