可以配置Bean的这个类的初始化和销毁的方法。
如何销毁这个bean?销毁必须得手动地关闭掉容器才行。而且销毁必须是在scope="singleton"下才有效。因为如果你scope="prototype"它就会生成N多的实例。它就不知道销毁哪个实例了。
Bean的生命周期。在Spring创建这个Bean的过程中总共有11个步骤。
所以Spring在生成Bean的生命周期的过程中总共有11个步骤。
需求:假设我有N多个Service,都需要在add()方法之前作权限校验,那么N个add方法都需要做权限校验.你每个类都打开,每个add()方法之前都加上权限校验的代码。特别麻烦。如果说不想要了,还得50个类都打开全部去掉。特别麻烦。
有了后处理bean之后可以把代码加在后处理bean上,不影响业务逻辑,不想要的时候最多在配置文件中把后处理bean去掉,想要的时候又在配置文件中把后处理bean加进来。
Spring类完整的生命周期记不记住无所谓,关键是后处理bean上。
package cn.itcast.spring3.demo4; 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:在配置文件中配置的类的标识.(就是id或者是name,如果你没id,name也行)
*/
//关键是第五步和第八步是怎么增强的.
//第五步和第八步只要你有一个类创建它都会执行的.整个生命周期不不用都记下来,关键是第五步和第八步.这两个可以做一些增强的操作.
//Spring有很多内容都是基于后处理bean:BeanPostProcessor的.BeanPostProcessor,都是基于它的.
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException { System.out.println("第五步:初始化之前执行....");//初始化之前执行
return bean;//什么都没干,直接返回bean.直接返回bean代表根本没增强,什么事都没干.
} public Object postProcessAfterInitialization(final Object bean, String beanName)
throws BeansException {
System.out.println("第八步:初始化后执行....");
//有bean对象,有它的实例 实例化一个,相当于又创建一个helloService,现在要增强它
//动态代理:Proxy.newProxyInstance()对实现接口的类生成代理 增强一个类的某个方法的时候有三种方式:继承、装饰者、动态代理。其中动态代理是最为灵活的一种方式
//jdk的动态代理是必须对实现接口的类生成代理 但是Spring里面有别的办法
//newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
//类的加载器,interfaces类实现的接口,InvocationHandler类的处理器
//if(bean.getClass().getName().equals("CustomerServiceImpl")){//调CustomerService里面的任何一个方法都相当于执行invoke
//if(bean.getClass().getName().equals("customerService")){//调CustomerService里面的任何一个方法都相当于执行invoke
//if(bean.getClass().getName().equals("CustomerService")){//调CustomerService里面的任何一个方法都相当于执行invoke
//if(beanName.equals("CustomerService")){//配置文件里面叫customerService
if(beanName.equals("customerService")){
Object proxy = Proxy.newProxyInstance(bean.getClass().getClassLoader(), bean.getClass().getInterfaces(), new InvocationHandler(){
//在外面调用任何一个方法都相当于执行我们这里面的这个invoke()方法
//要是只想对CustomerService增强,不想对别的Service增强,那就在这里加个判断,否则它是对所有的类都执行这个后处理bean的.
//调用目标方法的时候,调用invoke方法.
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//对它里面进行增强
//return method.invoke(bean,args);//相当于是没有进行增强
//如果不是对所有方法都进行增强,判断
if("add".equals(method.getName())){//是add()才增强
//进行时间监控或者是权限校验都可以
System.out.println(System.currentTimeMillis());//时间监控
//System.out.println("权限校验.....");
Object result = method.invoke(bean, args);
System.out.println(System.currentTimeMillis());//时间监控
return result;
}
return method.invoke(bean, args);//不是add()方法就不进行增强
} });//返回实现这个接口的一个代理
//第二个参数得到这个类实现的所有的接口
//第三个参数是一个处理器 处理器它是一个接口 两种办法 第一种办法你自己写个类实现这个接口,第二种办法直接匿名内部类
return proxy;//如果这个类是CutomerService,直接返回一个代理对象
} return bean;//其他的类不增强,return bean;
//放开if,不管你哪个类都会给你生成代理,给你增强
}
}
package cn.itcast.spring3.demo4; 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; public class CustomerServiceImpl implements CustomerService,BeanNameAware,ApplicationContextAware,InitializingBean,DisposableBean{
//演示CustomerService完整的生命周期 //第一步是实例化这个bean,那样就会调用它的构造方法
//第一步:只要一加载配置文件就帮我们创建这个类了。
@SuppressWarnings("unused")
private String name; public void setName(String name) {
System.out.println("第二步:属性的注入.");
this.name = name;
} public CustomerServiceImpl() {
super();
System.out.println("第一步:实例化类.");
} public void add(){//第九步:执行业务逻辑
System.out.println("添加客户....");
} public void find(){//第九步:执行业务逻辑
System.out.println("查询客户.....");
} public void setBeanName(String name) {
System.out.println("第三步:注入配置的类的名称"+name);//什么是类的名称?就是那个id
// <bean id="customerService" class="cn.itcast.spring3.demo4.CustomerService">
//就是我们在Spring中对这个类起了一个id。它就会把这个名字给你注入到这个程序里面,让我们这个类CustomerService了解Spring的容器。它就把你配置的那个id给你传过来了。 } //第四步也是让我们这个类来了解Spring容器,只不过它是把工厂注入进来了。它是把ApplicationContext注入进来了。
//它就让我们本身这个类了解Spring这个容器
//第三步和第四步都是为了让我们这个类来了解Spring容器。
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
System.out.println("第四步:注入applicationContext"+applicationContext);
} public void afterPropertiesSet() throws Exception {
System.out.println("第六步:属性设置后执行....."); } public void setup(){
System.out.println("第七步:调用手动设置的初始化方法...."); } public void destroy() throws Exception {
System.out.println("第十步:调用销毁的方法...."); }
public void teardown(){ System.out.println("第十一步:调用手动销毁的方法....");
}
}
package cn.itcast.spring3.demo4;
public interface CustomerService {
public void add();
public void find();
}package cn.itcast.spring3.demo4; import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; @SuppressWarnings("unused")
public class SpringTest4 { @Test
//Bean完整的生命周期 public void demo1(){
//ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); //CustomerServiceImpl customerService = (CustomerServiceImpl) applicationContext.getBean("customerService");
CustomerService customerService = (CustomerService) applicationContext.getBean("customerService");
customerService.add();
customerService.find();
applicationContext.close(); } }
<?xml version="1.0" encoding="UTF-8"?>
<!-- 别去schema,schema是文件,本地的文件,你得引那个头 --> <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">
<!-- demo1快速入门================================================= -->
<!-- 把接口和实现类在这个配置文件中配置,有了实现类的全路径之后到时候才能用工厂反射 --> <!-- 通过一个<bean>标签来设置类的信息,通过id属性为类起个标识. -->
<!-- 接口,实现类,配置文件也都有了 -->
<!-- 现在有一个工厂Spring为我们提供好了,其实就是解析这个XML文件 -->
<!-- 这个工厂你自己写会不会写?你用dom4j找里面的bean标签,找到class的属性值,然后就可以Class.forName()反射生成类的实例.其实Spring
也是这么做的,只不过工厂由Spring提供好了
-->
<bean id="helloService" class="cn.itcast.spring3.demo1.HelloServiceImpl">
<!-- 使用<property>标签注入属性
value指的是普通值
ref指的是对象
-->
<property name="info" value="传智播客"></property>
</bean>
<!-- demo1快速入门 -->
<!-- demo2Bean的实例化 -->
<!-- 默认情况下使用的就是无参数的构造方法. -->
<!--
<bean id="bean1" class="cn.itcast.spring3.demo2.Bean1"></bean>
-->
<!--
<bean name="bean1" class="cn.itcast.spring3.demo2.Bean1"></bean>
-->
<!-- 第二种使用静态工厂实例化 不能写class了,因为现在不是由Spring直接帮你创建对象了-->
<!--
<bean id="bean2" class="cn.itcast.spring3.demo2.Bean2Factory" factory-method="getBean2"></bean>
-->
<!-- 第三种使用实例工厂实例化 -->
<!--
<bean id="bean3" factory-bean="bean3Factory" factory-method="getBean3"></bean>
-->
<!-- 要先把Bean3Factory实例化 -->
<!--
<bean id="bean3Factory" class="cn.itcast.spring3.demo2.Bean3Factory"></bean>
-->
<!-- demo2Bean的实例化====================== end--> <!-- demo3Bean的作用范围======================= -->
<!--
<bean id="customer" class="cn.itcast.spring3.demo3.Customer" scope="prototype"></bean>
-->
<!--
<bean id="product" class="cn.itcast.spring3.demo3.Product" init-method="setup" destroy-method="teardown" scope="singleton">
<property name="name" value="空调">-->
<!-- 把Product类的属性name注入进来 -->
<!--
</property>
</bean>
--> <!-- demo4Bean的生命周期======================= -->
<bean id="customerService" class="cn.itcast.spring3.demo4.CustomerServiceImpl" init-method="setup" destroy-method="teardown"> <property name="name" value="itcast"></property>
</bean>
<!-- 后处理Bean是由Spring容器自动调用不用你管,我们起个id是为了我们在程序中去获得它。但是这个类不用由我们获得, 由Spring自动调用。cn.itcast.spring3.demo4.MyBeanPostProcessor是后处理Bean-->
<bean class="cn.itcast.spring3.demo4.MyBeanPostProcessor"></bean> </beans>