[关闭]
@22221cjp 2016-09-18T12:17:59.000000Z 字数 17126 阅读 944

动态代理

技术

先来一个接口Moveable和类Tank，Tank实现了Moveable接口

  1. -----------------------------------------Moveable-----------------------------------
  2. package com.chen.proxy;
  3. public interface Moveable {
  4.     void move();
  5. }
  6. -----------------------------------------Tank-----------------------------------
  7. package com.chen.proxy;
  9. import java.util.Random;
  11. public class Tank implements Moveable {
  12.     @Override
  13.     public void move() {
  14.         System.out.println("Tank moving...");
  15.         try {
  16.             Thread.sleep(new Random().nextInt(10000));
  17.         } catch (InterruptedException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }
  21. }

现在有一个需求，我想记录一下Tank这个类中move方法的运行时间，常用的设计方法有两种：1.继承 2.组合。代码分别如下：
1. 继承（定义Tank1类，继承Tank，然后重写其中的move方法）

  1. package com.chen.proxy;
  3. public class Tank1 extends Tank {
  5.     @Override
  6.     public void move() {
  7.         long start = System.currentTimeMillis();
  8.         super.move();
  9.         long end = System.currentTimeMillis();
  10.         System.out.println("move time: " + (end - start));
  11.     }
  12. }

这样，只需要new一个Tank1的对象，然后调用move方法就能知道Tank中的move方法运行的时间。
2. 组合（定义一个类TankTimeProxy，也实现Moveable接口，此接口中还持有一个Moveable接口的引用。

  1. package com.chen.proxy;
  3. public class TankTimeProxy implements Moveable {
  4.     Moveable m;
  6.     @Override
  7.     public void move() {
  8.         long start = System.currentTimeMillis();
  9.         m.move();
  10.         long end = System.currentTimeMillis();
  11.         System.out.println("move time:" + (end - start));
  12.     }
  14.     public TankTimeProxy(Moveable moveable) {
  15.         this.m = moveable;
  16.     }
  17. }

要想知道Tank中的move方法运行的时间，只要以下测试代码即可。

  1. package com.chen.proxy;
  3. public class Test {
  4.     public static void main(String[] args) {        
  5.         Moveable ttp = new TankTimeProxy(new Tank());
  6.         ttp.move();
  7.     }
  8. }

以上两种方法哪种比较好？
第二种！只从语法上来说，第二种的TankTimeProxy实现了一个接口，但是还可以从其他的类继承，而第一种已经不能从其他的类继承了，不够灵活。但是这并不是主要的原因，想想更深层原因，如果我现在想再记录一下坦克move的日志，也就是当坦克移动开始的时候打印”move start”，坦克移动结束的时候打印”move stop”，如果采用继承的方法，就需要定义一个Tank2类继承Tank1，然后重写Tank1中的move方法，但是我若想调换这两个需求的位置，先记录坦克移动的日志，然后记录坦克的运行时间，这样就必须从Tank重新继承一个Tank3，先记录一下日志，然后再来一个Tank5继承Tank3，然后重写move方法，在开始和介绍的位置加上时间的记录，可以想象采用继承的方式是相当不灵活的，会导致“类爆炸”，那么采用接口的方式会如何呢？按照上面的思路，我们定义一个TankLogProxy类如下：

  1. ----------------------------TankLogProxy-----------------------------
  2. package com.chen.proxy;
  4. public class TankLogProxy implements Moveable {
  5.     Moveable m;
  7.     @Override
  8.     public void move() {
  9.         System.out.println("tank start");
  10.         m.move();
  11.         System.out.println("tank stop");
  12.     }
  14.     public TankLogProxy(Moveable m) {
  15.         this.m = m;
  16.     }
  17. }

若我想先记录时间，然后记录日志，可以采用如下的代码：

  1. package com.chen.proxy;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         Tank tank = new Tank();
  7.         Moveable tlp = new TankLogProxy(tank);
  8.         Moveable ttp = new TankTimeProxy(tlp);
  9.         ttp.move();
  10.     }
  11. }

若反过来，我先记录坦克日志，然后记录时间，则可以采用如下的代码：

  1. package com.chen.proxy;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         Tank tank = new Tank();
  7.         Moveable ttp = new TankTimeProxy(tank);
  8.         Moveable tlp = new TankLogProxy(ttp);
  9.         tlp.move();
  10.     }
  11. }

因为TankTimeProxy和TankLogProxy中持有一个Moveable的引用，而TankTimeProxy和TankLogProxy都实现了Moveable接口，所以这两个类的对象都是可以初始化这两个类中的字段 m ，所以上面想调换一下这两个需求的位置只需要初始化的位置调换一下就可以了，这个是相当灵活的。观察一下TankTimeProxy和TankLogProxy这两个类，可以发现，这两个类和Tank都实现了同一个接口Moveable，而这两个类中又都有一个Moveable接口的引用 m ，且在实现move方法的时候，核心的代码逻辑只是简单的调用了 m.move()方法，若将 m 初始化为Tank的对象，那么核心的代码逻辑就是调用Tank对象的move方法，实际上TankTimeProxy对象此时就是一个Tank对象的代理，因为这个代理有名有姓，又是我们自己实现的，是写死了的，所以也叫静态代理。
注意一下静态代理产生的方式：
1. 被代理类必须实现了一个接口
2. 代理类也实现了与被代理类相同的接口，且有一个此接口的引用。
3. 代理类有一个构造函数，其中可以初始化这个引用。
现在只考虑TankTimeProxy这个类，这个类虽然能产生Tank对象的代理，记录Tank对象move方法的运行时间，但是还不够灵活，因为它只能产生Moveable接口对象中的move方法的运行时间，若我想产生任何对象中任何方法的运行时间，该怎么办呢？
刚才的TankTimeProxy是我们写死了的，若我们能将TankTimeProxy这个类动态的生成，然后动态的编译不就能动态的产生一个Tank的时间代理类了么，虽然此时还不能完全实现对任何对象产生时间的代理类，但是已经向这个目标迈进了一步。
定义一个类Proxy（JDK中类名也是这个），其中有一个静态方法getNewInstance，这个方法就用来实现对Tank对象的时间的代理类。

  1. package com.chen.proxy;
  3. import java.io.File;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  6. import java.lang.reflect.Constructor;
  7. import java.lang.reflect.InvocationTargetException;
  8. import java.net.MalformedURLException;
  9. import java.net.URL;
  10. import java.net.URLClassLoader;
  12. import javax.tools.JavaCompiler;
  13. import javax.tools.StandardJavaFileManager;
  14. import javax.tools.ToolProvider;
  15. import javax.tools.JavaCompiler.CompilationTask;
  17. public class Proxy {
  18.     public static Object getNewInstance() {
  19.         String src = "package com.chen.proxy;" +
  21.         "public class TankTimeProxy implements Moveable {" + " Moveable m;" +
  23.         "@Override" + "\r\n" + "public void move() {"
  24.                 + "long start = before();" + "m.move();" + "after(start);"
  25.                 + "}" +
  27.                 "private void after(long start) {" + "long end = before();"
  28.                 + "System.out.println(\"move time: \" + (end - start));" + "}" +
  30.                 "private long before() {"
  31.                 + "long start = System.currentTimeMillis();" + "return start;"
  32.                 + "}" +
  34.                 "public TankTimeProxy(Moveable tank) {" + "this.m = tank;"
  35.                 + "}" + "}";
  36.         System.out.println(System.getProperty("user.dir"));
  37.         String fileName = System.getProperty("user.dir")
  38.                 + "/src/com/chen/proxy/TankTimeProxy.java";
  39.         File file = new File(fileName);
  40.         try {
  41.             FileWriter fileWriter = new FileWriter(file);
  42.             fileWriter.write(src);
  43.             fileWriter.flush();
  44.             fileWriter.close();
  45.         } catch (IOException e) {
  46.             e.printStackTrace();
  47.         }
  49.         // 编译
  50.         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  51.         StandardJavaFileManager fileManager = compiler.getStandardFileManager(
  52.                 null, null, null);
  53.         Iterable iterable = fileManager.getJavaFileObjects(fileName);
  54.         CompilationTask task = compiler.getTask(null, fileManager, null, null,
  55.                 null, iterable);
  56.         task.call();
  57.         try {
  58.             fileManager.close();
  59.         } catch (IOException e) {
  60.             e.printStackTrace();
  61.         }
  63.         // 加载到内存并实例化
  64.         URL[] urls;
  65.         Moveable moveable = null;
  66.         try {
  67.             urls = new URL[] { new URL("file:/"
  68.                     + System.getProperty("user.dir") + "/src/") };
  69.             URLClassLoader urlClassLoader = new URLClassLoader(urls);
  70.             Class clazz = urlClassLoader
  71.                     .loadClass("com.chen.proxy.TankTimeProxy");
  72.             System.out.println(clazz);
  74.             Constructor constructor = clazz.getConstructor(Moveable.class);
  75.             moveable = (Moveable) constructor.newInstance(new Tank());
  77.         } catch (MalformedURLException e) {
  78.             e.printStackTrace();
  79.         } catch (ClassNotFoundException e) {
  80.             e.printStackTrace();
  81.         } catch (SecurityException e) {
  82.             e.printStackTrace();
  83.         } catch (NoSuchMethodException e) {
  84.             e.printStackTrace();
  85.         } catch (IllegalArgumentException e) {
  86.             e.printStackTrace();
  87.         } catch (InstantiationException e) {
  88.             e.printStackTrace();
  89.         } catch (IllegalAccessException e) {
  90.             e.printStackTrace();
  91.         } catch (InvocationTargetException e) {
  92.             e.printStackTrace();
  93.         }
  94.         return moveable;
  95.     }
  96. }

这段代码有点长，我们把刚才的TankTimeProxy类中的完全代码拷贝到getNewInstance方法中，并定义成一个字符串，如果我们能把这个字符串动态的编译，那么我们就不需要刚才的TankTimeProxy类了，现在的问题是如何动态的编译一个类的字符串形式呢？有如下几种方法：
1. JDK1.6以上自带了动态编译的api
2. 使用第三方的类库，如：CGLib ASM等，这些工具直接可以生产java的二进制文件，不需要生产中间的XXX.java和XXX.class文件。

这里我们使用的就是第一种。我们把原来的TankTimeProxy删掉，调用getNewInstance方法就可以在src目录下重新生成一个TankTimeProxy类。
此时src目录下只需三个类即可，Moveable接口，Tank类，Proxy类（如上）。
通过以下测试类，可以测试运行结果：

  1. package com.chen.proxy;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         Moveable m = (Moveable) Proxy.getNewInstance();
  6.         m.move();
  7.     }
  8. }

运行的截图如下：
image_1asujkv261g041ud81cbhq9t5o79.png-11.9kB

运行完成后，刷新src目录，可以看到动态生成的TankTimeProxy类。需要注意的是，上面需要获得java的编译器，那么项目的运行环境不能为jre1.6，因为jre中是不带java的编译器的，所以需求将项目的运行环境改为jdk1.6，更改方法见博客。
评论：上面代码的确能够动态的生成Tank的时间代理类，但是在字符串src中，接口Moveable是写死了的，我们要产生实现任何接口的动态代理类就不能将接口写死，解决方案很简单，不写死就让接口成为一个参数传入getNewInstance方法，再getNewInstance内通过反射可以得到，这个是可以办到的，所以可以修改getNewInstance方法如下（下面的代码来自视频源码）：

  1. package com.bjsxt.proxy;
  3. import java.io.File;
  4. import java.io.FileWriter;
  5. import java.lang.reflect.Constructor;
  6. import java.lang.reflect.Method;
  7. import java.net.URL;
  8. import java.net.URLClassLoader;
  10. import javax.tools.JavaCompiler;
  11. import javax.tools.StandardJavaFileManager;
  12. import javax.tools.ToolProvider;
  13. import javax.tools.JavaCompiler.CompilationTask;
  16. public class Proxy {
  17.     public static Object newProxyInstance(Class infce) throws Exception { //JDK6 Complier API, CGLib, ASM
  18.         String methodStr = "";
  19.         String rt = "\r\n";
  21.         Method[] methods = infce.getMethods();
  23.         //通过反射拿到方法名称，然后在前面和后面加上记录时间的代码
  24.         for(Method m : methods) {
  25.             methodStr += "@Override" + rt + 
  26.                          "public void " + m.getName() + "() {" + rt +
  27.                             "   long start = System.currentTimeMillis();" + rt +
  28.                             "   System.out.println(\"starttime:\" + start);" + rt +
  29.                             "   t." + m.getName() + "();" + rt +
  30.                             "   long end = System.currentTimeMillis();" + rt +
  31.                             "   System.out.println(\"time:\" + (end-start));" + rt +
  32.                          "}";
  33.         }
  35.         String src = 
  36.             "package com.bjsxt.proxy;" +  rt +
  37.             "public class $Proxy1 implements " + infce.getName() + "{" + rt +
  38. 			"    public $Proxy1(Moveable t) {" + rt +
  39.             "        this.t = t;" + rt +
  40.             "    }" + rt +
  42.             "    Moveable t;" + rt +
  44.             methodStr +
  45.             "}";
  46.         String fileName = 
  47.             "d:/src/com/bjsxt/proxy/$Proxy1.java";
  49.         File f = new File(fileName);
  50.         FileWriter fw = new FileWriter(f);
  51.         fw.write(src);
  52.         fw.flush();
  53.         fw.close();
  55.         //compile
  56.         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  57.         StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
  58.         Iterable units = fileMgr.getJavaFileObjects(fileName);
  59.         CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
  60.         t.call();
  61.         fileMgr.close();
  63.         //load into memory and create an instance
  64.         URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
  65.         URLClassLoader ul = new URLClassLoader(urls);
  66.         Class c = ul.loadClass("com.bjsxt.proxy.$Proxy1");
  67.         System.out.println(c);
  69.         Constructor ctr = c.getConstructor(Moveable.class);
  70.         //这里传了Tank对象，返回了此对象的代理对象。
  71.         Object m = ctr.newInstance(new Tank());
  72.         return m;
  73.     }
  74. }

这个getNewInstance和上面的区别仅仅是在前面拼字符串的时候通过反射拿到了传入进来接口的方法名，然后将每个方法的前面和后面都加上记录时间的代码。此外，此段代码会在d:/src/com/bjsxt/proxy/目录下生产$Proxy1.java文件，看一下这个文件中生产的代码如下：

  1. package com.bjsxt.proxy;
  2. public class $Proxy1 implements com.bjsxt.proxy.Moveable{
  3.     public $Proxy1(Moveable t) {
  4.         this.t = t;
  5.     }
  6.     Moveable t;
  7. @Override
  8. public void move() {
  9.    long start = System.currentTimeMillis();
  10.    System.out.println("starttime:" + start);
  11.    t.move();
  12.    long end = System.currentTimeMillis();
  13.    System.out.println("time:" + (end-start));
  14. }}

虽然产生的代码和以前是一样的，但是这里是将接口传进来以后产生的代码，也就是说，只要把传入的接口一变，不论这个接口中有多少方法，都可以生产这个接口中所有方法记录时间的处理逻辑。
此外还要注意，这个中间代码的生成的文件我们可以写到任何地方，作为使用这个类的客户端，甚至都不知道中间产生了一个文件，如果借助CGLib等第三方的类库，可以完全不用生成这些中间文件，而直接编译这些代码产生对象。这件事情很神奇，我们只要将被代理类实现的接口传入getNewInstance方法，就能获得被代理类的一个代理对象。看如下测试代码：

  1. package com.bjsxt.proxy;
  3. public class Client {
  4.     public static void main(String[] args) throws Exception {
  5.         Moveable moveable = (Moveable) Proxy.newProxyInstance(Moveable.class);
  6.         moveable.move();
  7.     }
  8. }

运行的截图如下：
image_1astmrpnb12ei1clt1psd111gb2j9.png-10.8kB

评论：以上的程序虽然可以对任意的接口生成记录方法运行时间的代理类对象，但是此代理类还是不太灵活，因为getNewInstance只能产生记录时间的处理逻辑，也就是说代理的处理行为是写死的，如何随意地定义生成代理对象的处理逻辑呢？
要在哪个方向上保持灵活，就要在哪个方向上进行抽象，处理逻辑显然抽象成一个接口更合适，抽象成如下接口InvocationHandler（jdk中也是这个名称）

  1. package com.bjsxt.proxy;
  3. import java.lang.reflect.Method;
  5. public interface InvocationHandler {
  6.     public void invoke(Object o, Method m);
  7. }

这里的参数也是模仿jdk中的，o为最终生成的代理对象，m为接口中的方法，这里用的是反射（可以先不了解这两个参数的意义，往下看）。
那么如何使用这个接口来生成代理对象，假如还是记录时间的需求，代码如下：

  1. package com.bjsxt.proxy;
  3. import java.lang.reflect.Method;
  5. public class TimeHandler implements InvocationHandler {
  7.     private Object target;   //用于产生传进来的这个对象的代理对象
  9.     public TimeHandler(Object target) {
  10.         super();
  11.         this.target = target;
  12.     }
  14.     @Override
  15.     public void invoke(Object o, Method m) {
  16.         long start = System.currentTimeMillis();
  17.         System.out.println("starttime:" + start);
  18.         System.out.println(o.getClass().getName());
  19.         try {
  20.             m.invoke(target);
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.         }
  24.         long end = System.currentTimeMillis();
  25.         System.out.println("time:" + (end - start));
  26.     }
  27. }

在invoke方法中，打印了 o 的名字是看一下这个参数是什么意思。m.invoke(target);实际上是调用了target这个对象的 m 方法，到底是如何调用的呢？接着看。
需要产生任意逻辑的代理对象，就需要修改getNewInstance方法，将处理逻辑的抽象InvocationHandler传进去。代码如下：

  1. package com.bjsxt.proxy;
  3. import java.io.File;
  4. import java.io.FileWriter;
  5. import java.lang.reflect.Constructor;
  6. import java.lang.reflect.Method;
  7. import java.net.URL;
  8. import java.net.URLClassLoader;
  10. import javax.tools.JavaCompiler;
  11. import javax.tools.StandardJavaFileManager;
  12. import javax.tools.ToolProvider;
  13. import javax.tools.JavaCompiler.CompilationTask;
  16. public class Proxy {
  17.     public static Object newProxyInstance(Class infce, InvocationHandler h) throws Exception { //JDK6 Complier API, CGLib, ASM
  18.         String methodStr = "";
  19.         String rt = "\r\n";
  21.         Method[] methods = infce.getMethods();
  23.         //对每个方法，都生成相同的处理逻辑。
  24.         //这里的h.invoke(this,md)会调用具体的InvocationHandler实现类中的invoke方法，而传的两个参数分别为this，也就是代理类对象本身，而md是传进来接口中的方法。
  25.         for(Method m : methods) {
  26.             methodStr += "@Override" + rt + 
  27.                          "public void " + m.getName() + "() {" + rt +
  28.                          "    try {" + rt +
  29.                          "    Method md = " + infce.getName() + ".class.getMethod(\"" + m.getName() + "\");" + rt +
  30.                          "    h.invoke(this, md);" + rt +
  31.                          "    }catch(Exception e) {e.printStackTrace();}" + rt +
  33.                          "}";
  34.         }
  36.         String src = 
  37.             "package com.bjsxt.proxy;" +  rt +
  38.             "import java.lang.reflect.Method;" + rt +
  39.             "public class $Proxy1 implements " + infce.getName() + "{" + rt +
  40. 			"    public $Proxy1(InvocationHandler h) {" + rt +
  41.             "        this.h = h;" + rt +
  42.             "    }" + rt +
  44.             "    com.bjsxt.proxy.InvocationHandler h;" + rt +
  46.             methodStr +
  47.             "}";
  48.         String fileName = 
  49.             "d:/src/com/bjsxt/proxy/$Proxy1.java";
  51.         File f = new File(fileName);
  52.         FileWriter fw = new FileWriter(f);
  53.         fw.write(src);
  54.         fw.flush();
  55.         fw.close();
  57.         //compile
  58.         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  59.         StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);
  60.         Iterable units = fileMgr.getJavaFileObjects(fileName);
  61.         CompilationTask t = compiler.getTask(null, fileMgr, null, null, null, units);
  62.         t.call();
  63.         fileMgr.close();
  65.         //load into memory and create an instance
  66.         URL[] urls = new URL[] {new URL("file:/" + "d:/src/")};
  67.         URLClassLoader ul = new URLClassLoader(urls);
  68.         Class c = ul.loadClass("com.bjsxt.proxy.$Proxy1");
  69.         System.out.println(c);
  71.         Constructor ctr = c.getConstructor(InvocationHandler.class);
  72.         //这里创建一个对象，且将h传了进去，实际上这里返回的就是一个代理对象，h是构造函数的参数
  73.         Object m = ctr.newInstance(h);
  75.         return m;
  76.     }
  77. }

这里和上面生成的中间类$Proxy1不同的地方是上面的类中只是Moveable接口的引用，如下：

  1. package com.bjsxt.proxy;
  2. public class $Proxy1 implements com.bjsxt.proxy.Moveable{
  3.     public $Proxy1(Moveable t) {
  4.         this.t = t;
  5.     }
  6.     Moveable t;
  7. @Override
  8. public void move() {
  9.    long start = System.currentTimeMillis();
  10.    System.out.println("starttime:" + start);
  11.    t.move();
  12.    long end = System.currentTimeMillis();
  13.    System.out.println("time:" + (end-start));
  14. }}

处理逻辑也是在生成的中间类写死的。再看看这次生成的中间类：

  1. package com.bjsxt.proxy;
  2. import java.lang.reflect.Method;
  3. public class $Proxy1 implements com.bjsxt.proxy.Moveable{
  4.     public $Proxy1(InvocationHandler h) {
  5.         this.h = h;
  6.     }
  7.     com.bjsxt.proxy.InvocationHandler h;
  8. @Override
  9. public void move() {
  10.     try {
  11.     Method md = com.bjsxt.proxy.Moveable.class.getMethod("move");
  12.     h.invoke(this, md);
  13.     }catch(Exception e) {e.printStackTrace();}
  14. }}

类中有一个InvocationHandler引用，在方法的处理逻辑中通过这个引用调用invoke方法，注意上面Method md = com.bjsxt.proxy.Moveable.class.getMethod("move");中的”move”是根据public void move() 确定的，也就说用生成的代理对象调用接口中的哪个方法，这里的md就会是哪个方法，根据多态h.invoke(this,md)会调用InvocationHandler实现类中的invoke方法，看看上面的TimeHandler类：

  1. package com.bjsxt.proxy;
  3. import java.lang.reflect.Method;
  5. public class TimeHandler implements InvocationHandler {
  7.     private Object target;   //用于产生传进来的这个对象的代理对象，此对象是被代理对象
  9.     public TimeHandler(Object target) {
  10.         super();
  11.         this.target = target;
  12.     }
  14.     @Override
  15.     public void invoke(Object o, Method m) {
  16.         long start = System.currentTimeMillis();
  17.         System.out.println("starttime:" + start);
  18.         System.out.println(o.getClass().getName());
  19.         try {
  20.             m.invoke(target);
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.         }
  24.         long end = System.currentTimeMillis();
  25.         System.out.println("time:" + (end - start));
  26.     }
  27. }

这时会调用这里面的invoke方法，所以这里的两个参数的意思我们也就能够理解了，o 为生成的代理对象的引用，而 m 是代理对象调用什么方法，这里的 m 就是什么，m 是什么下面的 m.invoke(target)当然就会调用被代理对象中相应的方法，而我们可以在调用被代理方法的前面和后面任意的加上我们想要的处理逻辑。这件事情更神奇了，我们要想拿到一个对象（实现了接口infac）的代理对象，并自由的定义代理对象的处理逻辑，我们只需要做如下几件事情就可以了。
1. 定义一个逻辑处理类（如TimeHandler）实现InvocationHandler，并在此类中定义一个Object引用（用来引用被代理的对象），然后实现invoke方法，其中m.invoke(target)是固定的，前后随便写，这里的 o参数只是一个代理对象的引用，可以不用。
2. new 一个TimeHandler的对象(h)，并把被代理对象传进去。
3. 调用Proxy.getNewInstance(infac.class,h)就能返回一个代理对象。
看测试代码如下：

  1. package com.bjsxt.proxy;
  3. public class Client {
  4.     public static void main(String[] args) throws Exception {
  5.         InvocationHandler h = new TimeHandler(new Tank());
  6.         Moveable m = (Moveable) Proxy.newProxyInstance(Moveable.class, h);
  7.         m.move();
  8.     }
  9. }

运行的截图如下：
image_1astn968bfeqf34mvrvn5fdk13.png-12kB

以上我们自己模拟实现了一个动态代理，接下来看看jdk的动态代理的api，以及如何使用这些api。

image_1astnbuei4h2crd1qui56f1iui1g.png-201.1kB

和我们自己实现的动态代理类相比，多了一个ClassLoader参数，注意这里的ClassLoader必须和被代理对象使用相同的ClassLoader，第二个参数是一个接口数组，因为一个类可能实现多个接口，那么可以对多个接口中的方法同时加上相同的处理逻辑。再看一下jdk中InvocationHandler接口是什么样子的，文档如下：

image_1astne9ju1i2b1ig7dkaon04de1t.png-75.6kB

这里比我们实现的多了一个Object[]数组，作为方法调用的参数，但是我们不要去管这个args形参，因为此方法的调用是在自动生成的中间代理类中，可以想象，你调用了哪个方法，那么内部实现肯定是通过反射获得此方法的参数列表，然后传递此方法，若代理对象调用的接口方法中没有参数，则这里的args为null。我们上面的实现中为了简单没有考虑参数问题，但是原理是一样的。另外此方法还有一个返回值，这个返回值就是代理对象调用接口方法的返回值，若接口方法没有返回值，那么这里可以返回null。注意：不论是args还是返回值，都是Object的，若原来的接口方法中是基本类型，会自动装箱成对应的包装类对象。
使用jdk自带的api，实现坦克move时间的代理类代码如下：

  1. -------------------------Moveable接口-------------------------
  2. package com.jdk.proxy;
  4. public interface Moveable {
  5.     void move();
  6. }
  7. -----------------Tank类实现了Moveable接口-----------------------
  8. package com.jdk.proxy;
  10. import java.util.Random;
  12. public class Tank implements Moveable {
  14.     @Override
  15.     public void move() {
  16.         System.out.println("Tank Moving...");
  17.         try {
  18.             Thread.sleep(new Random().nextInt(10000));
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23. }
  24. ------------定义代理类的处理逻辑（实现InvocationHandler接口）--------------
  25. package com.jdk.proxy;
  27. import java.lang.reflect.InvocationHandler;
  28. import java.lang.reflect.Method;
  30. public class TimeHandler implements InvocationHandler {
  31.     private Moveable m;
  33.     @Override
  34.     public Object invoke(Object proxy, Method method, Object[] args)
  35.             throws Throwable {
  37.         // 看看jdk自动生成的类的类名是什么
  38.         System.out.println(proxy.getClass());
  39.         System.out.println(args == null); // 这里应该输出true，因为接口方法move没有参数
  40.         long start = System.currentTimeMillis();
  41.         System.out.println("start time:" + start);
  42.         Object obj = method.invoke(m, args); // 固定写法，不用管args参数是什么
  43.         long end = System.currentTimeMillis();
  44.         System.out.println("run time:" + (end - start));
  45.         return obj; // move没有返回值，这里返回null
  46.     }
  48.     public TimeHandler(Moveable m) {
  49.         this.m = m;
  50.     }
  51. }
  52. ------------------测试类Test---------------------
  53. package com.jdk.proxy;
  55. import java.lang.reflect.InvocationHandler;
  56. import java.lang.reflect.Proxy;
  58. public class Test {
  59.     public static void main(String[] args) {
  60.         Moveable tank = new Tank();
  61.         InvocationHandler timeHandler = new TimeHandler(tank);
  62.         Moveable m = (Moveable) Proxy.newProxyInstance(
  63.                 Test.class.getClassLoader(), new Class[] { Moveable.class },
  64.                 timeHandler);
  65.         m.move();
  66.     }
  67. }

输出的结果为：
image_1astngh4bl4h1vokuk1vq81fjd2a.png-11.3kB
因为被代理对象和代理对象必须是相同的ClassLoader，所以更好的测试代码可以这样写：

  1. package com.jdk.proxy;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Proxy;
  6. public class Test {
  7.     public static void main(String[] args) {
  8.         // 更好的测试代码可以这样写
  9.         Moveable tank = new Tank();
  10.         InvocationHandler timeHandler = new TimeHandler(tank);
  11.         Moveable m = (Moveable) Proxy
  12.                 .newProxyInstance(tank.getClass().getClassLoader(), tank
  13.                         .getClass().getInterfaces(), timeHandler);
  14.         m.move();
  15.     }
  16. }

后记：动态代理是相当重要的设计模式，也是设计模式中比较难的，Spring中的两大核心思想之一AOP就是动态代理的一种应用，因为我们可以“神不知，鬼不觉”的在一个对象的方法运行的前面和后面做一些事情，而这个方法本身是完全不知觉的。如在一个方法调用前，我对调用的请求进行身份验证，还可以在插入用户的时候记录日志，如果插入用户和记录日志是在不同的数据库中进行的，那么我们就没有办法将这两个动作放到同一个事务中，因为事务的边界是基于session，而一个session只是与一个数据库实例的会话连接，若在不同的数据库中插入数据，通常我们没有办法将它们放到同一个事务中，但是有了动态代理，这事就好办了，我们可以将这两个方法调用之前做一点事情，之后也做一点事情，两个方法的调用中间也可以做一些事情，这样就可以在一个动作处理失败的时候，进行一些自定义的回滚操作，保证两个动作的事务性。事实上，Spring也的确提供了这样的功能，而此前仅仅凭借Hibernate是做不到的。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注