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和初始化、销毁方法：

编写测试类：

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.调用指定初始化方法 init

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

9. 执行业务处理

10.如果Bean实现DisposableBean 执行 destroy

11.调用 指定销毁方法 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处理类：

运行：

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

比如，在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方法...");
	}
}

修改配置文件：

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