Spring 生命周期回调机制

爱被打了一巴掌 2021-09-21 03:34 344阅读 0赞

# 一、Spring 生命周期回调机制可选方式 #

Spring[官方文档][Link 1]注明从Spring 2.5开始，您可以使用三种方式来控制Bean生命周期行为：

*  [InitializingBean][]和[DisposableBean][]回调接口
 *  自定义**`init()`**和**`destroy()`**方法
 *  [@PostConstruct 和 @PreDestroy ][PostConstruct _ _PreDestroy]注解。

**您可以组合以上这些机制来控制给定的 bean。**

注：如果为 bean 配置了多个生命周期机制，并且每个机制配置了不同的方法名称，则每个配置的方法都按照下面的顺序执行。但是，如果配置了相同的方法名称 - 对于 example，`init()`用于初始化方法 - 对于多个这些生命周期机制，该方法将执行一次，如[前一节][Link 2]中所述。（--翻译自原文）

## 二、各种回调机制方式执行顺序 ##

为同一bean配置的多个生命周期机制，使用不同的初始化方法，调用顺序如下：

1、用**`@PostConstruct`**注解的方法

2、由**InitializingBean**回调接口定义的**afterPropertiesSet()**方法

3、自定义配置的**init()**方法（xml中的**init-method**或者`@Bean`的**`initMethod`**属性）

销毁方法调用顺序相同：

1、用**`@`PreDestroy**注释的方法

2、由**DisposableBean**回调接口定义的**destroy()**方法

3、自定义配置的**destroy()**方法（xml中的**destroy-method**或者`@Bean`的**`destroyMethod`**属性）

# 三、代码测试 #

采用xml配置启动Spring应用（Spring版本为5.0.5.RELEASE）：

<?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:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:annotation-config/>
        <bean id="x" class="com.dxc.opentalk.springtest.service.X" init-method="customInit"
        destroy-method="customDestroy">
        </bean>
    
        <bean id="y" class="com.dxc.opentalk.springtest.service.Y"></bean>
    </beans>

测试类X：

package com.dxc.opentalk.springtest.service;
    
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    /**
     * @author dxc
     * @since 2020-02-10
     */
    public class X implements InitializingBean, DisposableBean {
    
        @Autowired
        private Y y;
    
        private String s;
    
        public X() {
            System.out.println("Construct X");
        }
    
        /**三种初始化回调方法*/
        public void customInit() {
            System.out.println("init-method exec...");
        }
    
        public void afterPropertiesSet() throws Exception {
            System.out.println("InitializingBean exec...");
        }
    
        @PostConstruct
        public void annotationInit() {
            System.out.println("@PostConstruct exec...");
        }
    
    
        /**三种销毁回调方法*/
        public void destroy() throws Exception {
            System.out.println("DisposableBean exec...");
        }
    
        public void customDestroy() {
            System.out.println("destroy-method exec...");
        }
    
        @PreDestroy
        public void annotationDestroy() {
            System.out.println("@PreDestroy exec...");
        }
    
    }

启动类：

package com.dxc.opentalk.springtest;
    
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * @author dxc
     * @since 2020-02-29
     */
    public class XmlBootStrap {
    
        public static void main(String[] args) {
            ClassPathXmlApplicationContext applicationContext = new
                    ClassPathXmlApplicationContext("applicationContext.xml");
            //关闭上下文，测试bean销毁回调方法
            applicationContext.close();
        }
    }

程序运行结果：

Construct X
    Construct Y
    @PostConstruct exec...
    InitializingBean exec...
    init-method exec...
    @PreDestroy exec...
    DisposableBean exec...
    destroy-method exec...

可以看出，初始化回调方法以及销毁回调方法与上述的顺序一致。另外，需要说明的是如果这三种方式中的两个或者三个用到一个方法上，那么这个方法只会被调用一次。测试如下：

修改xml配置：

让三种方式都配置到一个方法上：

package com.dxc.opentalk.springtest.service;
    
    import org.springframework.beans.factory.DisposableBean;
    import org.springframework.beans.factory.InitializingBean;
    import org.springframework.beans.factory.annotation.Autowired;
    
    import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    /**
     * @author dxc
     * @since 2020-02-10
     */
    public class X implements InitializingBean, DisposableBean {
    
        @Autowired
        private Y y;
    
        private String s;
    
        public X() {
            System.out.println("Construct X");
        }
    
    
        public void customInit() {
            System.out.println("init-method exec...");
        }
    
        @PostConstruct
        public void afterPropertiesSet() throws Exception {
            System.out.println("InitializingBean exec...");
        }
    
    
        public void annotationInit() {
            System.out.println("@PostConstruct exec...");
        }
    
        @PreDestroy
        public void destroy() throws Exception {
            System.out.println("DisposableBean exec...");
        }
    
        public void customDestroy() {
            System.out.println("destroy-method exec...");
        }
    
    
        public void annotationDestroy() {
            System.out.println("@PreDestroy exec...");
        }
    
    }

程序运行结果如下：

Construct X
    Construct Y
    InitializingBean exec...
    DisposableBean exec...

可见，这种情况下初始化回调方法和销毁回调方法都只执行了一次。

[Link 1]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-factory-lifecycle-combined-effects
[InitializingBean]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-factory-lifecycle-initializingbean
[DisposableBean]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-factory-lifecycle-disposablebean
[PostConstruct _ _PreDestroy]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-postconstruct-and-predestroy-annotations
[Link 2]: https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/core.html#beans-factory-lifecycle-default-init-destroy-methods