Spring教程-Spring Bean的生命周期

理解 Spring bean 的生命周期很容易。当一个 bean 被实例化时，它可能需要执行一些初始化使它转换成可用状态。同样，当 bean 不再需要，并且从容器中移除时，可能需要做一些清除工作。

Bean的完整生命周期经历了各种方法调用，这些方法可以划分为以下几类：

1. Bean自身的方法：这个包括了Bean本身调用的方法和通过配置文件中<bean>的init-method和destroy-method指定的方法
2. Bean生命周期回调接口方法：这个包括了BeanNameAware、BeanFactoryAware、ApplicationContextAware、InitializingBean和DiposableBean这些接口的方法
3. 容器级生命周期接口方法：这个包括了BeanPostProcessor 和BeanFactoryPostProcessor 这两个接口实现，一般称它们的实现类为“后处理器”。

本文讲解均基于 Spring Framework 4.3.3.RELEASE。

Bean初始化回调

org.springframework.beans.factory.InitializingBean 接口指定一个单一的方法：

void afterPropertiesSet() throws Exception;

因此，你可以简单地实现上述接口和初始化工作可以在 afterPropertiesSet() 方法中执行，如下所示：

public class ExampleBean implements InitializingBean {
   public void afterPropertiesSet() throws Exception {
      // do some initialization work
   }
}

在基于 XML 的配置元数据的情况下，你可以使用 init-method 属性来指定带有 void 无参数方法的名称。例如：

<bean id="exampleBean" 
         class="examples.ExampleBean" init-method="init"/>

下面是ExampleBean 类的定义：

public class ExampleBean {
   public void init() {
      // do some initialization work
   }
}

Bean销毁回调

org.springframework.beans.factory.DisposableBean 接口指定一个单一的方法：

void destroy() throws Exception;

因此，你可以简单地实现上述接口并且结束工作可以在 destroy() 方法中执行，如下所示：

public class ExampleBean implements DisposableBean {
   public void destroy() throws Exception {
      // do some destruction work
   }
}

在基于 XML 的配置元数据的情况下，你可以使用 destroy-method 属性来指定带有 void 无参数方法的名称。例如：

<bean id="exampleBean"
         class="examples.ExampleBean" destroy-method="destroy"/>

下面是ExampleBean 类的定义：

public class ExampleBean {
   public void destroy() {
      // do some destruction work
   }
}

示例

下面通过一个简单的Spring Bean来演示Bean的生命周期，代码如下：

package com.bytebeats.spring.lifecycle;

/**
 * ${DESCRIPTION}
 *
 * @author Ricky Fung
 * @create 2016-12-28 22:46
 */
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * ${DESCRIPTION}
 *
 * @author Ricky Fung
 * @create 2016-12-28 22:44
 */
public class ExampleBean implements BeanFactoryAware, BeanNameAware, ApplicationContextAware,
        InitializingBean, DisposableBean {

    private BeanFactory beanFactory;
    private String beanName;
    private ApplicationContext applicationContext;

    public ExampleBean() {
        System.out.println("【构造器】调用Person的构造器实例化");
    }

    // 这是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out
                .println("【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
        this.beanFactory = beanFactory;
    }

    // 这是BeanNameAware接口方法
    @Override
    public void setBeanName(String beanName) {
        System.out.println("【BeanNameAware接口】调用BeanNameAware.setBeanName()");
        this.beanName = beanName;
    }

    // 这是ApplicationContextAware接口方法
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("【ApplicationContextAware接口】调用ApplicationContextAware.setApplicationContext()");
        this.applicationContext = applicationContext;
    }

    // 这是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
    }

    // 这是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("【DiposibleBean接口】调用DiposibleBean.destory()");
    }

    // 通过<bean>的init-method属性指定的初始化方法
    public void initMethod() {
        System.out.println("【init-method】调用<bean>的init-method属性指定的初始化方法");
    }

    // 通过<bean>的destroy-method属性指定的初始化方法
    public void destroyMethod() {
        System.out.println("【destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
    }

}

配置文件applicationContext.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <context:annotation-config/>
    <context:component-scan base-package="com.bytebeats.spring.lifecycle"/>

    <bean id="exampleBean" class="com.bytebeats.spring.lifecycle.ExampleBean" init-method="initMethod"
          destroy-method="destroyMethod" scope="singleton"/>

</beans>

测试类如下：

public class App {

    public static void main(String[] args) {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("Spring容器初始化成功");

        ExampleBean exampleBean = (ExampleBean) context.getBean("exampleBean");
        System.out.println(exampleBean);

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Spring容器开始关闭");
        context.close();
    }
}

运行结果如下：

十二月 28, 2016 11:06:31 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@4e1557af: startup date [Wed Dec 28 23:06:31 CST 2016]; root of context hierarchy
十二月 28, 2016 11:06:31 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContext.xml]
【构造器】调用Person的构造器实例化
【BeanNameAware接口】调用BeanNameAware.setBeanName()
【BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
【ApplicationContextAware接口】调用ApplicationContextAware.setApplicationContext()
【InitializingBean接口】调用InitializingBean.afterPropertiesSet()
【init-method】调用<bean>的init-method属性指定的初始化方法
Spring容器初始化成功
com.bytebeats.spring.lifecycle.ExampleBean@390f9eb5
Spring容器开始关闭
十二月 28, 2016 11:06:36 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@4e1557af: startup date [Wed Dec 28 23:06:31 CST 2016]; root of context hierarchy
【DiposibleBean接口】调用DiposibleBean.destory()
【destroy-method】调用<bean>的destroy-method属性指定的初始化方法