Spring学习-08:Bean的生命周期

配置Bean的初始化和销毁的方法：

bean：Product类

package com.helloSpring.demo4;

public class Product {
	public void setup(){
		System.out.println("初始化方法执行...");
	}
	public void teardown(){
		System.out.println("销毁方法执行...");
	}
}

配置bean和初始化、销毁方法：

<bean id="product" class="com.helloSpring.demo4.Product" init-method="setup" destroy-method="teardown"></bean>

编写测试类：

package com.helloSpring.demo4;
/**
 * 测试配置bean的初始化和销毁方法
 */
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest4 {
	@Test
	public void TestSet(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		Product product = (Product) applicationContext.getBean("product");
	}
}

运行单元测试：

对于bean的销毁，我们必须得是手动关闭工厂，而且必须是scope=“singleton”下才有效，因为对于scope=“prototype”，每个bean有多个实例，无法确定去销毁哪一个实例。

因为默认情况下就是单例模式，所以操作一下关闭工厂即可：

修改测试类如下：（因为ApplicationContext类没有提供close()方法，但是它的子类ClassPathXmlApplicationContext提供了close()方法）

package com.helloSpring.demo4;
/**
 * 测试配置bean的初始化和销毁方法
 */
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest4 {
	@Test
	public void TestSet(){
		ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		Product product = (Product) classPathXmlApplicationContext.getBean("product");
		classPathXmlApplicationContext.close();
	}
}

运行结果如下：

Bean的生命周期的11个步骤：

1.instantiatebean对象实例化

2.populateproperties 封装属性

3.如果Bean实现BeanNameAware 执行 setBeanName

4.如果Bean实现BeanFactoryAware 或者ApplicationContextAware 设置工厂 setBeanFactory或者上下文对象 setApplicationContext

5.如果存在类实现BeanPostProcessor（后处理Bean），执行 postProcessBeforeInitialization

6.如果Bean实现InitializingBean 执行 afterPropertiesSet

7.调用<bean init-method="init">指定初始化方法 init

8.如果存在类实现BeanPostProcessor（处理Bean），执行 postProcessAfterInitialization

9. 执行业务处理

10.如果Bean实现DisposableBean 执行 destroy

11.调用<bean destroy-method="customerDestroy"> 指定销毁方法 customerDestroy

下面举个例子演示一下bean的生命周期：

新建类：

package com.js.demo5;

import org.springframework.beans.BeansException;
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;

/**
 * 演示bean的生命周期
 * 第三步和第四步是让bean了解我们的Spring容器
 * @author js
 *
 */
public class CustomerService implements BeanNameAware,ApplicationContextAware,InitializingBean,DisposableBean{
	private String nameString;
	public void setNameString(String nameString) {
		System.out.println("第二步：完成属性注入...");
		this.nameString = nameString;
	}
	public CustomerService() {
		super();
		System.out.println("第一步：实例化类...");
	}
	public void add(){
		System.out.println("第九步：执行业务方法-添加客户...");
	}
	public void find(){
		System.out.println("第九步：执行业务方法-查询客户...");
	}
	@Override
	public void setBeanName(String arg0) {
		System.out.println("第三步：注入配置的类的名称"+arg0);
	}
	@Override
	public void setApplicationContext(ApplicationContext arg0)
			throws BeansException {
		System.out.println("第四步：注入applicationContext"+arg0);
	}
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("第六步：属性设置之后执行");
	}
	public void setup(){
		System.out.println("第七步：调用手动设置的初始化方法...");
	}
	public void teardown(){
		System.out.println("第十一步：调用手动配置的销毁方法...");
	}
	@Override
	public void destroy() throws Exception {
		System.out.println("第十步：执行destroy方法...");
	}
}

新建bean处理类：

package com.js.demo5;

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

public class MyBeanPostProcessor implements BeanPostProcessor {
/**
 * bean:实例对象
 * beanName：在配置文件中配置的类的标识
 */
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
			System.out.println("第八步：初始化之后执行...");
		return bean;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("第五步：初始化之前执行...");
		return bean;
	}

}

新建测试类：

package com.js.demo5;
/**
 * 测试bean的完整生命周期
 */
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5 {
	@Test
	public void testFunction(){
		ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		CustomerService customerService = (CustomerService)classPathXmlApplicationContext.getBean("customerService");
		customerService.add();
		customerService.find();
		classPathXmlApplicationContext.close();
	}
}

配置bean和bean处理类：

<bean id="customerService" class="com.js.demo5.CustomerService" init-method="setup" destroy-method="teardown">
<property name="nameString" value="蒋帅"></property>
</bean>
<bean class="com.js.demo5.MyBeanPostProcessor"></bean>

运行：

再来，第五步和第八步很重要，因为它们可以实现功能增强。

比如，在CustomerService的add方法之前进行权限校验。一种方法是在add()方法中进行校验，当需要校验的方法很多时，显然处理起来非常繁琐并且工作量太大。那么，我们就可以在后处理bean方法中来实现看看。

咱们想去增强一个类的某个方法的时候，有好几种方式：继承、装饰者、动态代理(Proxy)。

修改MyBeanProcessor类(动态代理)：

package com.js.demo5;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

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

public class MyBeanPostProcessor implements BeanPostProcessor {
/**
 * bean:实例对象
 * beanName：在配置文件中配置的类的标识
 */
	@Override
	public Object postProcessAfterInitialization(final Object bean, String beanName)
			throws BeansException {
			System.out.println("第八步：初始化之后执行...");
			//动态代理：
			//第三个参数是一个处理接口，可以新建一个类实现这个接口，也可以像我这样使用匿名内部类
			if(beanName.equals("customerService")){
				Object proxy = Proxy.newProxyInstance(bean.getClass().getClassLoader(),bean.getClass().getInterfaces() , new InvocationHandler() {
					//调用目标方法的时候，都相当于是调用目标方法
					@Override
					public Object invoke(Object proxy, Method method, Object[] args)
							throws Throwable {
						if("add".equals(method.getName())){
							System.out.println(System.currentTimeMillis());
							Object result=method.invoke(bean, args);
							System.out.println(System.currentTimeMillis());
							return result;
						}
						return method.invoke(bean, args);
					}
				});
				return proxy;
			}
		return bean;
	}

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("第五步：初始化之前执行...");
		return bean;
	}

}

新建接口：

package com.js.demo5;

public interface CustomerService {
	public void add();
	public void find();
}

新建接口实现类：

package com.js.demo5;

import org.springframework.beans.BeansException;
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;

/**
 * 演示bean的生命周期
 * 第三步和第四步是让bean了解我们的Spring容器
 * @author js
 *
 */
public class CustomerServiceImpl implements CustomerService, BeanNameAware,ApplicationContextAware,InitializingBean,DisposableBean{
	private String nameString;
	public void setNameString(String nameString) {
		System.out.println("第二步：完成属性注入...");
		this.nameString = nameString;
	}
	public CustomerServiceImpl() {
		super();
		System.out.println("第一步：实例化类...");
	}
	public void add(){
		System.out.println("第九步：执行业务方法-添加客户...");
	}
	public void find(){
		System.out.println("第九步：执行业务方法-查询客户...");
	}
	@Override
	public void setBeanName(String arg0) {
		System.out.println("第三步：注入配置的类的名称"+arg0);
	}
	@Override
	public void setApplicationContext(ApplicationContext arg0)
			throws BeansException {
		System.out.println("第四步：注入applicationContext"+arg0);
	}
	@Override
	public void afterPropertiesSet() throws Exception {
		System.out.println("第六步：属性设置之后执行");
	}
	public void setup(){
		System.out.println("第七步：调用手动设置的初始化方法...");
	}
	public void teardown(){
		System.out.println("第十一步：调用手动配置的销毁方法...");
	}
	@Override
	public void destroy() throws Exception {
		System.out.println("第十步：执行destroy方法...");
	}
}

修改配置文件：

<bean id="customerService" class="com.js.demo5.CustomerServiceImpl" init-method="setup" destroy-method="teardown">

运行结果：也就是只对类CustomerService类中的add()方法增强。