上篇文章中,详细介绍了spring中bean的scope,scope既是bean在spring容器中的存在方式,如prototype和singleton,且也带了一些存在周期的属性,如 session和request等。spring中 bean从实例化,到依赖注入、再到初始化、到最后消亡,有和完整的生命周期。它和scope一起构成bean完整的生命周期。本篇文章主要简单的描述下bean生命周期中的初始化方法(init())和消亡前(ondestroy(),以后称之为析构)的方法。本文主要讨论scope为prototype和singleton的bean,且由于prototype的bean在返回给客户端后,spring不在由spring进行管理,所以其销毁前的方法不会执行。
spring中bean的生命周期简单的如下图所示:
我们可以在生命周期函数中加入自己的一些定制化处理,比如说在初始化阶段,加载相关的资源,启动线程等,在析构阶段释放资源,关闭线程。需要牢记一点,初始化函数是在所有的依赖已经注入后才开始执行的。
生命周期回调
其中中bean的初始化和消亡前主要由以下几种方式:
1.Spring的接口InitializingBean和DisposableBean。示例如下:
/** * InitializingBean 接口从名字可以看出此方法在 bean的属性被spring赋值之后执行,但是和spring的接口耦合在了一起 */ @Override public void afterPropertiesSet() throws Exception { System.out.println(this+" i am afterPropertiesSet"); } /* * * DisposableBean 接口定义的 */ @Override public void destroy() throws Exception { System.out.println(this+" i am destroy"); }
2.采用元数据配置,即在bean的定义中配置,如init-method 和destroy-method属性,直接定义相关方法,另外在根标签<beans>可以配置default-init-method 和default-destroy-method 配置默认的 方法,如果<bean>中有定义,则覆盖默认的定义:
<bean id="user0" class="com.test.service.UserServiceIml" init-method="testInit" destroy-method="testBeforeDesstroy"> <property name="userDao" ref="userDao"></property> </bean> /** * @Description: 采用元数据配置,在xml中配置 * @param * @return void */ public void testInit(){ System.out.println(this+" i am testInit"); } /** * @Description: 采用元数据配置,在xml中配置 * @param * @return void */ public void testBeforeDesstroy(){ System.out.println(this+" i am testBeforeDesstroy"); }
3.采用JSR注解
/** * @Description: 采用jsr注解 * @param * @return void */ @PostConstruct public void testPostConstruct(){ System.out.println(this+" i am testPostConstruct"); } /** * @Description: 采用JSR的注解 * @param * @return void */ @PreDestroy public void testPreDesstroy(){ System.out.println(this+" i am testPreDesstroy"); }
混合机制
以上有三种回调函数实现的方式,他们可以单独使用,也可以混合使用,混合使用的时候,他们的顺序如下:
对于初始化函数:
1. @PostConstruct 注解的方法
2. InitializingBean接口定义的回调afterPropertiesSet()
3. Bean配置中自定义的初始化函数
对于析构则与上相同:
1. @PreDestroy注解的方法
2. DisposableBean接口定义的回调destroy()
3. Bean配置中自定义析构函数
详细的测试见后面。
startUp和shutDown回调
有时候我们可能需要一些组件的功能随着spring容器的启动而启动(如新开启一个线程来进行监听),容器的销毁而销毁。为此spring提供了一个接口,从方法名字很容易看到方法的作用:
public interface Lifecycle { void start(); void stop(); boolean isRunning(); }
当启动的时候,由于组件之间的依赖,启动的顺序是相当重要的。depends-on属性可以决定多个lifecycle的实现的顺序,但是有时候依赖是未知的。为此spring定义可一个新的接口,SmartLifecycle:
public interface Phased { int getPhase(); } public interface SmartLifecycle extends Lifecycle, Phased { boolean isAutoStartup(); void stop(Runnable callback); }
isAutoStartup决定是随着容器的启动自启动,Phased接口定义的方法则决定了启动顺序,其返回值越小启动越早,越大启动越晚。如果一个Lifecycle未实现Phased接口,则默认其值为0.
Stop方法可以异步的执行析构函数,spring默认会为每一个Phase等待30秒钟。这个时间是可以配置的。
测试
在非web环境下,要使析构函数执行,需要执行AbstractApplicationContext的registerShutdownHook()方法,见本文的示例:
本测试准备说明以下:
1. 混合生命周期回调的执行顺序
2. LifeCycle也可以看做为周期,其中start方法在初始化函数执行后被调用,stop方法在析构函数执行前被调用。Prototype 不会被调用start和 stop方法
3. Depend-on决定bean加载的顺序
4. <bean>定义的回调会覆盖<beans>定义的默认的回调。
代码
以下是测试程序,本程序依赖Spring之容器和配置初识这篇文章中的代码,并对其稍加改动:
代码结构如下:
首先是allbean.xml配置文件:
<!--使JSR注解生效 --> <bean id="postsss" class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/> <!-- 也可以使用这个配置 使JSR生效 <context:annotation-config/> --> <!-- 改变在容器关闭阶段,smartlifecycle 每个阶段 等待的时间 --> <bean id="lifecycleProcessor" class="org.springframework.context.support.DefaultLifecycleProcessor"> <!-- timeout value in milliseconds --> <property name="timeoutPerShutdownPhase" value="3000"/> </bean> <import resource="com/test/dao/dao.xml"/> <import resource="com/test/service/service.xml"/>
然后是service.xml
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-init-method="init" default-destroy-method="close" > <!-- 配置自己的初始化和析构,覆盖默认配置 --> <bean id="user0" class="com.test.service.UserServiceIml" init-method="testInit" destroy-method="testBeforeDesstroy"> <property name="userDao" ref="userDao"></property> </bean> <!-- 采用默认配置的初始化和析构 --> <bean id="user1" class="com.test.service.UserServiceIml"> <property name="userDao" ref="userDao"></property> </bean> <!-- 配置scope为 prototype,测试只执行初始化函数,不执行析构 --> <bean id="user2" class="com.test.service.UserServiceIml" scope="prototype"> <property name="userDao" ref="userDao"></property> </bean> <!-- 以下测试 depend-on --> <bean id="t1" class="com.test.service.Test1" depends-on="t2"> </bean> <bean id="t2" class="com.test.service.Test2" > </bean> </beans>
然后是UserServiceIml实现了相关的接口,使用了jsr注解和实现了bean中配置的初始化和析构函数:
package com.test.service; import java.util.List; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.context.SmartLifecycle; import com.test.bo.User; import com.test.dao.UserDao; /** *实现类,有个字段引用了UserDao接口,其具体的业务逻辑调用 {@link UserDao#getUser()}实现 * *且有一个set方法,此set方法由spring 容器注入使用,如果没有回报错, *这是spring容器依赖注入的一种方法--setter注入 */ public class UserServiceIml implements UserService,InitializingBean,DisposableBean,SmartLifecycle{ private volatile boolean isRunning = false; private UserDao userDao; @Override public List<User> getUser() { return userDao.getUser(); } public void setUserDao(UserDao userDao) { this.userDao = userDao; System.out.println(this+" i am setMethod"); } /** * InitializingBean 接口从名字可以看出此方法在 bean的属性被spring赋值之后执行,但是和spring的接口耦合在了一起 */ @Override public void afterPropertiesSet() throws Exception { System.out.println(this+" i am afterPropertiesSet"); } /* * * DisposableBean 接口定义的 */ @Override public void destroy() throws Exception { System.out.println(this+" i am destroy"); } /** * @Description: 采用jsr注解 * @param * @return void */ @PostConstruct public void testPostConstruct(){ System.out.println(this+" i am testPostConstruct"); } /** * @Description: 采用JSR的注解 * @param * @return void */ @PreDestroy public void testPreDesstroy(){ System.out.println(this+" i am testPreDesstroy"); } /** * @Description: 采用元数据配置,在xml中配置 * @param * @return void */ public void testInit(){ System.out.println(this+" i am testInit"); } /** * @Description: 采用元数据配置,在xml中配置 * @param * @return void */ public void testBeforeDesstroy(){ System.out.println(this+" i am testBeforeDesstroy"); } public void init(){ System.out.println(this+" i am init"); } public void close(){ System.out.println(this+" i am close"); } @Override public boolean isRunning() { returnisRunning; } @Override public void start() { System.out.println(this+"spring容器启动啦"); isRunning = true; } /** * */ @Override public void stop() { System.out.println(this+"spring容器关闭啦"); isRunning = false; } @Override public int getPhase() { return 0; } @Override public boolean isAutoStartup() { return true; } @Override public void stop(Runnable arg0) { arg0.run(); isRunning = false; System.out.println(this+" this is stop"); } }
主程序:
public class TestMain { public static void main(String[] args) { AbstractApplicationContext context = new ClassPathXmlApplicationContext("allbean.xml"); context.registerShutdownHook(); UserService userService0 = context.getBean("user0", UserService.class); System.out.println(userService0.getUser()); System.out.println("--------------user1采用默认的初始化函数--------------"); // UserService userService1 = context.getBean("user1", UserService.class); // System.out.println(userService1.getUser()); // UserService userService2 = context.getBean("user2", UserService.class); // System.out.println(userService2.getUser()); } }
测试结果
以上测试结果就不分析了。需要注意的的上面的测试结果第一行由于截图的关系空缺了。
结束语
Bean的生命周期spring是采用beanpostProcessor(称之为spring扩展点)来进行管理和扩展的,spring定义了很多内置的beanpostProcessor,它们的一些回调在bean的实例化(这里指返回客户端调用前,而不是new)过程中被调用,且如果bean实现了一些aware接口(如ApplicationContextAware 和 beanNameAwre
),这些接口的回调也会进入到生命周期中,这里暂且不讨论。见文章:http://developer.51cto.com/art/201104/255961.htm。而且,spring广泛采用代理机制,需要注意的是 生命周期函数运行在代理创建之前。本文的测试代码下载:本文代码完整下载