day38 09-Spring类的完整生命周期及后处理Bean

可以配置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>

巴特西

day38 09-Spring类的完整生命周期及后处理Bean

最新文章

热门文章