动态代理技术

1分析代理类的作用与原理及AOP概念

 当我们已经开发好了一个类，这时我们需要为这个类添加日志，计数，事务管理 那我们什么做？？？这时我们可以考虑使用代理。
代理模式是对象的结构型模式，代理模式给某一个对象提供了一个代理对象，并由代理对象控制对原对象的引用。

代理分为静态代理和动态代理

    1.        代理分类
    a)       静态代理:代理类的方法要和接口方式一致！
    b)       动态代理，JDK动态代理只能对实现了接口的类进行代理，采用JDK动态代理必须实现InvocationHandler接口，采用Proxy类创建相应的代理类。
    c)       动态代理的优缺点：
    d)      面向接口编程方便   
    e)       使用的是Java反射机制 开销比较大。

2. 分析JVM通过反射生成代理类

   JDK 1.5 中代理对象的生成，是通过Proxy 类生成的；
   1、创建一个实例对象，先找到有参的构造方法。
   2、编写一个最简单的InvotationHander
   3、调用动态的方法调用动态的实例对象

代码：三种生成代理对象的方法

packageorg.nagi.proxy;
importjava.lang.reflect.Constructor;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collection;
/**
 *三种方法生成Collection的代理对象
 *@author dell
 *
 */
publicclass TestProxy {

   privatestaticCollectionc;
   publicstaticvoid main(String[] args)throws Exception {

      TestProxy.CreateProxy1();
      TestProxy.CreateProxy2();
      TestProxy.getProxy(c);

   }


   /**
    *
    * 第一种生成代理对象
    */
   publicstaticvoid CreateProxy1()throws Exception{

      //得到代理类
      Class classParxy  = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
      //得到其构造方法
      Constructor con = classParxy.getConstructor(InvocationHandler.class);
      //实现InvocationHander接口
      class MyInvocationHanderimplements InvocationHandler{

        public Object invoke(Object proxy, Method method,Object[] args)
             throws Throwable {
          returnnull;
        }
      }
      //生成了Collection的一个代理对象
      Collection proxy1 = (Collection)con.newInstance(new MyInvocationHander());

   } 



   /**
    *
    * 第二种生成代理对象
    */
   publicstaticvoid CreateProxy2()throws Exception{

      //得到代理类
      Class classParxy  = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);
      //得到其构造方法
      Constructor con = classParxy.getConstructor(InvocationHandler.class);
      //生成了Collection的一个代理对象
      Collection proxy1 = (Collection)con.newInstance(new InvocationHandler(){

        @Override
        public Object invoke(Object proxy, Method method,Object[] args)
             throws Throwable {
          returnnull;
        }

      });

   } 
   /**
    *
    * 第三种生成代理对象
    */
   publicstatic Object getProxy(final Object target) {
      Object proxy3 = Proxy.newProxyInstance(
          //得到目标对象的字节码
          target.getClass().getClassLoader(),
          //得到目标对象所实现的接口
          target.getClass().getInterfaces(),
          //实现InvocationHandler接口
          new InvocationHandler(){

             public Object invoke(Object proxy, Method method,Object[] args)
                   throws Throwable {
                returnnull;
             }
          }
          );
      return proxy3;
   }

}

    2.创建动态类及查看其方法列表信息
    3.创建动态类的实例对象及调用其方法
    4.完成InvocationHandler对象的内部功能

public Object invoke(Object proxy, Method method,Object[] args)
             throws Throwable {
          returnnull;
        }

5.分析InvocationHandler对象的运行原理

   我们在调用代理对象的时候，每一次都执行Invocation 里面Invoke方法，
而在Invoke 方法需要接收三个数据：哪一个代理对象执行，方法、参数；

5.总结分析动态代理类的设计原理与结构

 思考：我们在调用代理对象的时候都要执行InvocationHander 接口里面的Invoke()方法；如果有一千个类都需要生成代理对象并且他们所需添加功能不一样 那我们什么办？

这时候我们就需要重构以一下我们的所生成的代理方法，使它可以适应为任何类添加的心新功能和生成代理对象； 我们就引出AOP 的思想；在为一个类生成代理对象的时候，我们只徐告诉它目标和需要添加的方法，为了提高可复用性和灵活性，我们把需要生成代理的类写进配置文件里面。

6.编写可生成代理和插入通告的通用方法
通知的方法：

importjava.lang.reflect.Method;
/**
 *通知的借口
 *即将插入进来的方法
 *如：执行的时间
 *   记日记  事务管理
 *@author dell
 *
 */
publicinterface Adrice {
   publicvoid beforeClass(Method method);
   publicvoid afterClass(Method method);
}
importjava.lang.reflect.Method;

/**
 *实现通知方法
 *@author dell
 *
 */
publicclass MyAdriceimplements Adrice {
   @Override
   publicvoid beforeClass(Method method) {
      long begain = System.currentTimeMillis();

      System.out.println("start....." + begain);
   }
   @Override
   publicvoid afterClass(Method method) {
      long after = System.currentTimeMillis();

      System.out.println("end....." + after);
   }
}

/**
    * 万能代理生成器
    * @param target需要代理的对象
    * @param adrice需要添加的方法
    * @return 代理对象
    */
   publicstatic Object CreatProxy(final Object target,final Adrice adrice){
      Object proxy = Proxy.newProxyInstance(
          target.getClass().getClassLoader(),
          target.getClass().getInterfaces(),
          new InvocationHandler() {

             @Override
             public Object invoke(Object proxy, Method method,Object[] args)
                   throws Throwable {
                   adrice.beforeClass(method);
                   Object retVal = method.invoke(target, args);
                   adrice.afterClass(method);
                return retVal;
             }
          });
      return proxy;
   }

7.实现类似spring的可配置的AOP框架

首先AOP 存在常用接口：

BeanFactory:负责生产Bean
ProxyFactoryBean:负责生产Bean 代理对象
Adrice: 定义通知的方法接口
Config.properties : 配置为哪一个类产生代理对象

代码：

BeanFactory 工厂类
packageorg.nagi.Aop;
importjava.io.IOException;
importjava.io.InputStream;
importjava.util.Properties;
/**
 * bean工厂
 *@author dell
 *
 */
publicclass BeanFactory {
   Properties prop = new Properties();
   public BeanFactory(InputStream is ) {
      try {
        //从输入流中加载文件
        prop.load(is);
      } catch (IOException e) {
        e.printStackTrace();
      }
   }
   //通过name得到Bean
   public Object getBean(String name)throws Exception{
    //从配置文件里面加载类
    StringclassName = prop.getProperty(name);
    //得到文件内存的字节码
    Classclazz = Class.forName(className);
    //生成一个代理对象
    Objectbean = clazz.newInstance();
       // 如果是代理工厂的对相的话，就加载代理目标类，和通知adrice
      if(beaninstanceof ProxyFactoryBean){
        //如果是代理对象，将其转为ProxyFactoryBean
        ProxyFactoryBean proxyFactoryBean =(ProxyFactoryBean)bean;
        //加载目标代理类
        Object target = Class.forName(prop.getProperty(name +".target")).newInstance();
         //加载目标的通知
        AopAdvice advice = (AopAdvice) Class.forName(prop.getProperty(name +".advice")).newInstance();
        //设置通知
        proxyFactoryBean.setAdvice(advice);
        //设置代理目标类
        proxyFactoryBean.setTarget(target);
        Object proxy =proxyFactoryBean.CreatProxy();
        return proxy;
      }
      return bean; 
   }
}

代理工厂产生类
packageorg.nagi.Aop;
importjava.lang.reflect.InvocationHandler;
importjava.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
 * 代理工厂
 * @author dell
 *
 */
public classProxyFactoryBean {

   private AopAdvice advice;
   private Object target;
   /**
    * 万能代理生成器
    *@param target 需要代理的对象
    *@param adrice 需要添加的方法
    *@return  代理对象
    */
   public Object CreatProxy(){
      Object proxy = Proxy.newProxyInstance(
           target.getClass().getClassLoader(),
           target.getClass().getInterfaces(),
           new InvocationHandler() {

              @Override
              public Object invoke(Object proxy,Method method, Object[] args)
                    throws Throwable {
                    advice.beforeClass(method);
                    Object retVal = method.invoke(target,args);
                    advice.afterClass(method);
                 return retVal;
              }
           });
      return proxy;

   }
   public AopAdvice getAdvice() {
      return advice;
   }
   public void setAdvice(AopAdvice advice) {
      this.advice = advice;
   }



   public Object getTarget() {
      return target;
   }



   public void setTarget(Object target) {
      this.target = target;
   }

}
通知接口类
packageorg.nagi.Aop;

importjava.lang.reflect.Method;

/**
 *通知的借口
 *即将插入进来的方法
 *如：执行的时间
 *   记日记  事务管理
 *@author dell
 *
 */
publicinterface BaseAdvice {

   publicvoid beforeClass(Method method);
   publicvoid afterClass(Method method);

}
具体通知实现类
 package org.nagi.Aop;
importjava.lang.reflect.Method;
/**
 *通知的具体实现类
 *@author dell
 *
 */
publicclass AopAdviceimplements BaseAdvice{

   @Override
   publicvoid beforeClass(Method method) {
      long begain = System.currentTimeMillis();

      System.out.println("start....." + begain);
   }

   @Override
   publicvoid afterClass(Method method) {
      long after = System.currentTimeMillis();

      System.out.println("end....." + after);
   }

}

配置文件：config.properties

nagi=org.nagi.Aop.ProxyFactoryBean
nagi.advice=org.nagi.Aop.AopAdvice
nagi.target=java.util.ArrayList

主函数：

packageorg.nagi.Aop;

importjava.io.InputStream;

/**
 *测试类
 *@author dell
 *
 */
publicclass TestAop {

   publicstaticvoid main(String[] args) {

      InputStream is = TestAop.class.getResourceAsStream("config.properties");
      BeanFactory factory = new BeanFactory(is);
      try {
        Object nagi = factory.getBean("nagi");
        System.out.println(nagi.getClass().getName());
      } catch (Exception e) {
        e.printStackTrace();
      }
   }
}

运行结果生成一个代理对象：com.sun.proxy.$Proxy0