java动态代理

一、代理的概念与作用

 

        首先代理是一种常用的设计模式，其目的就是为其它对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息转发消息，以及进行消息被委托执行后的后续处理。程序中的代理是：要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的菜吗。（类似于装饰模式）

 

            代理模式类关系图：

 

                                           

 

二、AOP（面向切面编程）

 

       面向切面编程是目前软件开发中的一个热点，也是 Spring 框架中的一个重要内容。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发效率。

 

          主要功能为：日志记录、性能统计、安全控制、事务处理、异常处理等。

 

三、Java 动态代理技术

 

       如果为系统中的各种接口的类增加代理功能，那就需要太多的代理类，全部采用静态代理将是一件很恐怖的事情！JVM 可以在运行期间动态生成出类的字节码，这种动态生成的类往往被使用作代理类，即动态代理。

 

          1、动态代理的注意要点：

 

         （1）JVM 生成的动态类必须实现一个或多个接口，所以 JVM 生成的动态类只能用作具有相同接口的目标代理类的代理。

         （2）如果要代理的类并没有实现任何接口，那么 CGLIB 库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理。

         （3）代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的四个位置加上系统功能代码：1、在调用目标方法之前。2、在调用目标方法之后。3、在调用目标方法的前和后。4、在处理目标方法异常的 catch 块中。

 

          编程实例：创建 Collection 的代理类，并且返回该代理类的构造方法和普通方法。

 public class A {

     public static void main(String[] args) throws Exception {

         Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class); // 获取动态代理类的字节码
         Constructor[] constructors = clazzProxy.getConstructors(); // 通过字节码获取代理类的所有构造方法
         Method[] methods = clazzProxy.getMethods(); //通过字节码获取代理类的所有普通方法

         System.out.println("-----获取构造方法-----");
         for (Constructor constructor : constructors) {
             String constructorName = constructor.getName(); // 获取构造方法的方法名
             StringBuilder sb = new StringBuilder(constructorName);
             Class[] clazzParameters = constructor.getParameterTypes(); // 获取该构造方法的所有参数类型
             sb.append("(");
             for (Class clazzParameter : clazzParameters) {
                 sb.append(clazzParameter.getName()).append(",");
             }
             if (clazzParameters.length != 0)
                 sb.deleteCharAt(sb.length() - 1);
             sb.append(")");
             System.out.println(sb);
         }

         System.out.println("-----获取通方法-----");
         for (Method method : methods) {
             String methodName = method.getName();
             StringBuilder sb = new StringBuilder(methodName);
             Class[] clazzParameters = method.getParameterTypes();
             sb.append("(");
             for (Class clazzParameter : clazzParameters) {
                 sb.append(clazzParameter.getName()).append(",");
             }
             if (clazzParameters.length != 0)
                 sb.deleteCharAt(sb.length() - 1);
             sb.append(")");
             System.out.println(sb);
         }
     }
 }

输出结果：

 -----获取构造方法-----
 $Proxy0(java.lang.reflect.InvocationHandler)
 -----获取通方法-----
 add(java.lang.Object)
 hashCode()
 clear()
 equals(java.lang.Object)
 toString()
 contains(java.lang.Object)
 isEmpty()
 addAll(java.util.Collection)
 iterator()
 size()
 toArray([Ljava.lang.Object;)
 toArray()
 remove(java.lang.Object)
 containsAll(java.util.Collection)
 removeAll(java.util.Collection)
 retainAll(java.util.Collection)
 isProxyClass(java.lang.Class)
 getProxyClass(java.lang.ClassLoader,[Ljava.lang.Class;)
 getInvocationHandler(java.lang.Object)
 newProxyInstance(java.lang.ClassLoader,[Ljava.lang.Class;,java.lang.reflect.InvocationHandler)
 wait()
 wait(long,int)
 wait(long)
 getClass()
 notify()
 notifyAll()

 

           2、创建动态代理类的实例对象

 

         （1）通过实现 InvocationHandler 接口创建自己的调用处理器。

         （2）通过为 Proxy 类指定 ClassLoader 对象和一组 Interface 来创建动态代理类。

         （3）通过反射机制获得动态代理类的构造函数。指定处理器。

         （4）通过构造函数创建 动态代理实例，构造时调用处理器对象作为参数被传入。

 

          编程实例：创建 Collection 的代理类实例。

 public class A {

     public static void main(String[] args) throws Exception {

         Class clazzProxy = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class); // 获取代理类的字节码

         Constructor constructor = clazzProxy.getConstructor(InvocationHandler.class); // 获取字节码中的构造函数信息

         Collection proxyCollection = (Collection) constructor
                 .newInstance(new InvocationHandler() { // 创建实例对象
                     public Object invoke(Object proxy, Method method,
                             Object[] args) throws Throwable {
                         return null;
                     }
                 });

         System.out.println(proxyCollection); // 此时会打印出 null，因为上面并没有指定要代理哪个类，下面会讲到
         System.out.println(proxyCollection.add("DriverKing_斌")); // 会有空指针异常，还是因为没有指定目标类
         proxyCollection.clear(); // 正常，因为此代理类也实现了 Collection 接口，所以具有此方法
         System.out.println(proxyCollection.size()); // 会有空指针异常，还是因为没有指定目标类，返回的是上面的 return null 所以将 null 转为 int 不可行
     }
 }

 

           上面创建代理类实例的过程步骤是：告诉编译器目标类实现了哪些接口，是哪个加载器加载 ----> 再用反射得到构造器 ----> 用构造器的 newInstance 方法构造实例对象，并且还要给构造器一个 InvocationHandler 的实例对象。

 

           这些步骤有些复杂，其实我们可以通过一步就可以创建出动态代理类的实例。

 

           编程实例：简化创建 Collection 的代理类实例。

 public class A {

     public static void main(String[] args) throws Exception {

         Collection collection = (Collection) Proxy.newProxyInstance(
                 Collection.class.getClassLoader(),
                 new Class[] { Collection.class }, new InvocationHandler() {
                     // 需要一个目标类，如果这个目标类在 invoke方法里面是不行的，
                     // 因为每次调用代理类的方法，实际上是调用了目标类的方法，
                     // 那么每次就生成了一个目标类的实例
                     ArrayList target = new ArrayList();

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

                         return method.invoke(target, args);
                     }
                 });

         collection.add("DriverKing_斌");
         System.out.println(collection.size());
         System.out.println(collection);
     }
 }
 // 输出：
 // 1
 // [DriverKing_斌]

 

          3、分析 InvocationHandler 内部实现

 

                在我们创建一个动态代理类的实例对象时，总是要指定一个 InvocationHandler 实例对象，那么根据经验分析，一个构造函数指定了一个参数，那么在这个类的内部肯定是要用到这个对象，也就是说在类的成员变量里面一定有一个 private InvocationHandler handler; 字段。在 InvocationHandler 的实现类中是有一个方法：invoke(Object proxy, Method method, Object[] args)。这三个参数分别是：

                Object proxy -----> 调用的代理对象 

                Method method -----> 调用代理对象的哪个方法

                Object[] args -----> 这个方法传递的哪些参数

 

 <span style="font-size:13px;">public class A {

     public static void main(String[] args) throws Exception {

         Collection collection = (Collection) Proxy.newProxyInstance(
                 Collection.class.getClassLoader(),
                                                        // a1
                 new Class[] { Collection.class }, new InvocationHandler() {
                     ArrayList target = new ArrayList();

                     @Override
                            // 1            // a           // b
                     public Object invoke(Object proxy, Method method,
                              //c
                             Object[] args) throws Throwable {
                         //2
                         Object retVal = method.invoke(target, args);
                                 //3
                         return retVal;
                     }
                 });

         //4                        //b1       //c1
         Object retVal = collection.add("DriverKing_斌");

 //      4的 Object 是从1来的，1的 Object 是从3来的，3中的 Object 是从 2 来的
 //      a是从 a1 来的，b 是从  b1 来的，c 是从 c1 来的
     }
 }</span>

            4、动态代理工作原理：

            

                   客户端调用代理 -----> 代理的构造方法接受一个 InvocationHandler 对象 -----> 客户端调用代理的各个方法 -----> 代理将各个方法的请求转给 InvocationHandler 对象的 invoke 方法（可以在这里面加入新的功能，比如上图中的 log()） -----> invoke 再将相应方法分发给目标类的各个方法

 

           5、将代理类中的新增功能抽取为对象

 

                 传递一个功能对象给 InvocationHandler ，然后在 invoke 方法中调用这个对象中的某个方法，就实现了动态绑定。这个功能对象就是系统功能代码模块，即将切面代码以参数的形式提供。

 

           编程实例：将获取代理提取为方法。

 public class A {

     public static void main(String[] args) throws Exception {

         // ArrayList target = new ArrayList();
         // Collection b = (Collection) getProxy(target, new ProxyTest());
         // b.add("DriverKing_斌");

         Map map = new HashMap();
         Map newMap = (Map) getProxy(map, new ProxyTest());
         newMap.put("DriverKing_斌", "King");

         Proxy p = (Proxy)getProxy(map, new ProxyTest());
     }

     public static Object getProxy(final Object target, final IActive active) {
         Object objProxy = Proxy.newProxyInstance(target.getClass()
                 .getClassLoader(), target.getClass().getInterfaces(),
                 new InvocationHandler() {

                     @Override
                     public Object invoke(Object proxy, Method method,
                             Object[] args) throws Throwable {
                         active.befordMethod(method);
                         Object retVal = method.invoke(target, args);
                         active.afterMethod(method);
                         return retVal;
                     }
                 });
         return objProxy;
     }
 }

 interface IActive {
     void befordMethod(Method method);

     void afterMethod(Method method);
 }

 class ProxyTest implements IActive {

     long beginTime;

     @Override
     public void afterMethod(Method method) {
         long endTime = System.currentTimeMillis();
         System.out.println(method.getName() + " 方法结束时间:" + beginTime);
         System.out.println("用时：" + (endTime - beginTime) + " 毫秒");
     }

     @Override
     public void befordMethod(Method method) {
         beginTime = System.currentTimeMillis();
         System.out.println(method.getName() + " 方法开始时间:" + beginTime);
     }
 }
 // 输出：
 // add 方法开始时间:1309677944129
 // add 方法结束时间:1309677944129
 // 用时：0 毫秒

 // put 方法开始时间:1309678419613
 // put 方法结束时间:1309678419613
 // 用时：1 毫秒

 

六、实现 Spring 中的可配置的 AOP 框架

 

      思路分析：

• 工厂类 BeanFactory 负责创建目标类或代理类的实例对象，并通过配置文件实现切换。其 getBean 方法根据参数字符串返回一个相应的实例对象，如果参数字符串在配置文件中对应的类名不是 ProxyFactoryBean，则直接返回该类的实例对象，否则返回该类实例对象的 getProxy 方法返回的对象。
• BeanFactory 的构造方法接收代表配置文件的输入流对象，配置文件的格式如下：

         #xxx=java.util.ArrayList

         xxx=cn.driverking.ProxyFactoryBean

         xxx.target=java.util.ArrayList

         xxx.advice=cn.driverking.ProxyTest

 

         代码：

 package cn.driverking;

 import java.io.InputStream;
 import java.util.Properties;

 public class BeanFactory {

     public BeanFactory(InputStream in) throws Exception {
         this.properties.load(in);
     }

     private Properties properties = new Properties();

     public Object getBean(String name) throws Exception {
         Object bean = null;
         String className = properties.getProperty(name);
         Class clazz = Class.forName(className);
         bean = clazz.newInstance();
         if (bean instanceof ProxyFactoryBean) {
             ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) bean;
             IAdvice advice = (IAdvice) Class.forName(properties.getProperty(name + ".advice")).newInstance();
             Object target = Class.forName(properties.getProperty(name + ".target")).newInstance();
             proxyFactoryBean.setAdvice(advice);
             proxyFactoryBean.setTarget(target);
             return proxyFactoryBean.getProxy();
         }
         return bean;
     }
 }

 

[

 package cn.driverking;

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

 public class ProxyFactoryBean {

     private IAdvice advice;
     private Object target;

     public IAdvice getAdvice() {
         return advice;
     }

     public void setAdvice(IAdvice advice) {
         this.advice = advice;
     }

     public Object getTarget() {
         return target;
     }

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

     public Object getProxy() {
         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.befordMethod(method);
                         Object retVal = method.invoke(target, args);
                         advice.afterMethod(method);
                         return retVal;
                     }
                 });
         return proxy;
     }
 }

 

 package cn.driverking;

 import java.lang.reflect.Method;

 public interface IAdvice {

     void befordMethod(Method method);

     void afterMethod(Method method);

 }

 

 package cn.driverking;

 import java.lang.reflect.Method;

 public class ProxyTest implements IAdvice {

     long beginTime;

     @Override
     public void afterMethod(Method method) {
         long endTime = System.currentTimeMillis();
         System.out.println(method.getName() + " 方法结束时间:" + beginTime);
         System.out.println("用时：" + (endTime - beginTime) + " 毫秒");
     }

     @Override
     public void befordMethod(Method method) {
         beginTime = System.currentTimeMillis();
         System.out.println(method.getName() + " 方法开始时间:" + beginTime);
     }
 }

 

 package cn.driverking;

 import java.io.InputStream;
 import java.util.Collection;

 public class Test {

     public static void main(String[] args)throws Exception {
         InputStream in = Test.class.getResourceAsStream("config.properties");
         Object bean = new BeanFactory(in).getBean("xxx");
         System.out.println(bean.getClass().getName());
         ((Collection)bean).add("DriverKing_斌");
     }
 }

 

 xxx=java.util.ArrayList
 #xxx=cn.driverking.ProxyFactoryBean
 xxx.advice=cn.driverking.ProxyTest
 xxx.target=java.util.ArrayList