Java动态代理（JDK）

来源：互联网发布：windows.h有哪些函数编辑：程序博客网时间：2024/06/05 05:22

JAVA的动态代理

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

按照代理的创建时期，代理类可以分为两种：

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

动态代理：在程序运行时，运用反射机制动态创建而成。

静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

1.定义一个Count.java接口

package net.battier.dao;    public interface Count {      // 查看账户方法      public void queryCount();        // 修改账户方法      public void updateCount();    }

2.接口实现类CountImpl.java

package net.battier.dao.impl;    import net.battier.dao.Count;    public class CountImpl implements Count {        @Override      public void queryCount() {          System.out.println("查看账户方法...");        }        @Override      public void updateCount() {          System.out.println("修改账户方法...");        }    }

3.代理类CountProxy.java

package net.battier.dao.impl;    import net.battier.dao.Count;  public class CountProxy implements Count {      private CountImpl countImpl;        /**      * 覆盖默认构造器      *       * @param countImpl      */      public CountProxy(CountImpl countImpl) {          this.countImpl = countImpl;      }        @Override      public void queryCount() {          System.out.println("事务处理之前");          // 调用委托类的方法;          countImpl.queryCount();          System.out.println("事务处理之后");      }        @Override      public void updateCount() {          System.out.println("事务处理之前");          // 调用委托类的方法;          countImpl.updateCount();          System.out.println("事务处理之后");        }    }

4.测试Count类

package net.battier.test;    import net.battier.dao.impl.CountImpl;  import net.battier.dao.impl.CountProxy;  public class TestCount {      public static void main(String[] args) {          CountImpl countImpl = new CountImpl();          CountProxy countProxy = new CountProxy(countImpl);          countProxy.updateCount();          countProxy.queryCount();        }  }

观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。

动态代理：在程序运行时，运用反射机制动态创建而成。

1.先定义一个相亲接口

/**  * 相亲接口  *   * @author Administrator  * @time Jun 3, 2095 3:13:03 PM  */  public interface XiangQinInterface {      /**      * 相亲方法      */      public void xiangQin();  }

2.相亲接口的实现类

/**  * 张三相亲实现类  *   * @author Administrator * @time Jun 3, 2095 3:14:48 PM  */  public class ZhangSanXiangQinInterfaceImpl implements XiangQinInterface {      public void xiangQin() {          System.out.println("张三去相亲，娶个漂亮老婆。");      }  }

3.相亲接口的实现类，也就是张三相亲类

import java.lang.reflect.InvocationHandler;  import java.lang.reflect.Method;    /**  * 相亲可是一辈子的大事，相亲前要准备一下，打扮得帅气些。  *   * @author Administrator * @time Jun 3, 2095 3:15:48 PM  */  public class ReadyInvocationHandler implements InvocationHandler {      private Object zhangSan = null;        public ReadyInvocationHandler(Object realSubject) {          this.zhangSan = realSubject;      }        public Object invoke(Object proxy, Method m, Object[] args) {          Object result = null;          try {              /**              * 动态代理类$Proxy0调用xiangQin方法时会调用它自己的xiangQin方法，              *  而它自己的xiangQin方法里面调用的是super.h.invoke(this, , )，也就是父类Proxy的h的 invoke方法，              * 也就是ReadyInvocationHandler类的invoke方法。              *  所 以，invoke(Object proxy, Method m, Object[] args) 种的proxy实际上就是动态代理类$Proxy0，              *  如果你将其强转成XiangQinInterface然后调用它的xiangQin方法，然后它就会调用 super.h.invoke(this, , )，这样就会死循环。              */                          System.out.println(proxy.getClass().getSimpleName());              System.out.println("张三相亲前，代理人给他打扮了打扮。");              result = m.invoke(zhangSan, args);          } catch (Exception ex) {              System.exit(1);          }          return result;      }  }

4.为相亲的实现类实例化

import java.lang.reflect.InvocationHandler;  import java.lang.reflect.Method;  import java.lang.reflect.Proxy;    /**  * 张三来到了婚介所(相亲现场)，开始相亲。  *   * @author Administrator  * @time Jun 3, 2095 3:17:16 PM  */  public class HunJieSuo {      public static void main(String args[]) {          //先将张三相亲这个相亲的实现类实例化，也就是得到XiangQinInterface接口的一个实例对象          XiangQinInterface zhangSan = new ZhangSanXiangQinInterfaceImpl();          /**          *  得到ZhangSanXiangQinInterfaceImpl这个类的一个代理类，同时为代理类绑定了一个处理类 ReadyInvocationHandler。          * 听着很绕口，其实就是每次调用ZhangSanXiangQinInterfaceImpl这个子类的xiangQin方法时，          * 不是zhangSan这个ZhangSanXiangQinInterfaceImpl类的实例去调用，          *  而是这个ZhangSanXiangQinInterfaceImpl的代理类ReadyInvocationHandler去调用它自己的invoke 方法,          * 这个invoke方法里呢可以调用zhangSan这个实例的xiangQin方法          */          /**          * 在java种怎样实现动态代理呢          * 第一步，我们要有一个接口，还要有一个接口的实现类，而这个实现类呢就是我们要代理的对象，          * 所谓代理呢也就是在调用实现类的方法时，可以在方法执行前后做额外的工作，这个就是代理。          * 第二步，我们要自己写一个在要代理类的方法执行时，能够做额外工作的类，而这个类必须继承InvocationHandler接口，          * 为什么要继承它呢？因为代理类的实例在调用实现类的方法的时候，不会调真正的实现类的这个方法，          * 而是转而调用这个类的invoke方法（继承时必须实现的方法），在这个方法中你可以调用真正的实现类的这个方法。          * 第三步，在要用代理类的实例去调用实现类的方法的时候，写出下面两段代码。          */          XiangQinInterface proxy = (XiangQinInterface) Proxy.newProxyInstance(                  zhangSan.getClass().getClassLoader(),                  zhangSan.getClass().getInterfaces(),                  new ReadyInvocationHandler(zhangSan));          proxy.xiangQin();          /**          * 这里要解释下中部那段长长的代码的意思，以及具体做了哪些工作？          * 第一，根据zhangSan.getClass().getClassLoader()这个要代理类的类加载器和          * zhangSan.getClass().getInterfaces()要代理类所实现的所有的接口          *  作为参数调用 Proxy.getProxyClass(ClassLoader loader, Class<?>... interfaces)          * 的方法返回代理类的java.lang.Class对象，也就是得到了java动态生成的代理类$Proxy0的Class对象。          * 同时，java还让这个动态生成的$Proxy0类实现了要代理类的实现的所有接口，并继承了Proxy接口。          *  第二，实例化这个动态生成的$Proxy0类的一个实例，实例化代理类的构造函数为Proxy(InvocationHandler h)，          * 也就是说要实例化这个动态生成的$Proxy0类，必须给它一个InvocationHandler参数，也就是我们自己实现的用来在代理类          * 方法执行前后做额外工作的类ReadyInvocationHandler。          *  这段代码 Proxy.newProxyInstance(zhangSan.getClass().getClassLoader(),zhangSan.getClass().getInterfaces(),new ReadyInvocationHandler(zhangSan))          *  得到的其实是一个类名 叫$Proxy0 extends Proxy implements XiangQinInterface的 类。          * 第三，将这个$Proxy0类强制转型成XiangQinInterface类型，调用xiangQin方法。          */      }  }

可以看到，动态生成的代理类有如下特性：

继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
提供了一个使用InvocationHandler作为参数的构造方法。
生成静态代码块来初始化接口中方法的Method对象，以及Object类的equals、hashCode、toString方法。
重写了Object类的equals、hashCode、toString，它们都只是简单的调用了InvocationHandler的invoke方法，即可以对其进行特殊的操作，也就是说JDK的动态代理还可以代理上述三个方法。
在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。

1 0