深入理解JDK动态代理

1 package jdkproxy;
2 
3 public interface Moveable {
4     void move(int i);
5 }

 1 package jdkproxy;
 2 
 3 import java.util.Random;
 4 
 5 public class Car implements Moveable {
 6     @Override
 7     public void move(int i) {
 8         try {
 9             Thread.sleep(new Random().nextInt(1000));
10             System.out.println("汽车行驶中..."+i);
11         } catch (InterruptedException e) {
12             e.printStackTrace();
13         }
14     }
15 
16 }

 1 package jdkproxy;
 2 
 3 import java.lang.reflect.InvocationHandler;
 4 import java.lang.reflect.Method;
 5 
 6 public class TimeHandler implements InvocationHandler {
 7     private Object target;
 8 
 9     public TimeHandler(Object target){
10         this.target=target;
11     }
12 
13     @Override
14     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
15         long start=System.currentTimeMillis();
16         System.out.println("汽车开始行驶...");
17         method.invoke(target,args);
18         long end=System.currentTimeMillis();
19         System.out.println("汽车结束行驶，行驶时间为："+(end-start)+"毫秒");
20         return null;
21     }
22 }

 1 package jdkproxy;
 2 
 3 import sun.misc.ProxyGenerator;
 4 
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 
 8 public class ProxyGeneratorUtils {
 9     public static void writeProxyClassToHardDisk(String path) {
10         byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", Car.class.getInterfaces());
11         FileOutputStream out = null;
12         try {
13             out = new FileOutputStream(path);
14             out.write(classFile);
15             out.flush();
16         } catch (Exception e) {
17             e.printStackTrace();
18         } finally {
19             try {
20                 out.close();
21             } catch (IOException e) {
22                 e.printStackTrace();
23             }
24         }
25     }
26 }

  1 package jdkproxy;
  2 
  3 import java.lang.reflect.InvocationHandler;
  4 import java.lang.reflect.Proxy;
  5 /*
  6 loader：类加载器
  7 interfaces：目标对象实现的接口
  8 h：InvocationHandler的实现类
  9 
 10 Proxy.newProxyInstance方法：
 11 通过getProxyClass0方法生成代理类cl
 12 调用getProxyClass0方法如果缓存中有的话就直接返回，否则会通过ProxyClassFactory类生成
 13 ProxyClassFactory类中规定了所有代理类的前缀为$Proxy，接着通过反射
 14 cl.getConstructor.newInstance获取代理类的构造器并生成代理对象
 15 
 16 ProxyGenerator得到JDK生成的$Proxy0.class，再反编译得到的$Proxy0
 17 import java.lang.reflect.InvocationHandler;
 18 import java.lang.reflect.Method;
 19 import java.lang.reflect.Proxy;
 20 import java.lang.reflect.UndeclaredThrowableException;
 21 import jdkproxy.Moveable;
 22 
 23 public final class $Proxy0 extends Proxy implements Moveable {
 24     private static Method m1;
 25     private static Method m2;
 26     private static Method m3;
 27     private static Method m0;
 28 
 29     public $Proxy0(InvocationHandler var1) throws  {
 30         super(var1);
 31     }
 32 
 33     public final boolean equals(Object var1) throws  {
 34         try {
 35             return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
 36         } catch (RuntimeException | Error var3) {
 37             throw var3;
 38         } catch (Throwable var4) {
 39             throw new UndeclaredThrowableException(var4);
 40         }
 41     }
 42 
 43     public final String toString() throws  {
 44         try {
 45             return (String)super.h.invoke(this, m2, (Object[])null);
 46         } catch (RuntimeException | Error var2) {
 47             throw var2;
 48         } catch (Throwable var3) {
 49             throw new UndeclaredThrowableException(var3);
 50         }
 51     }
 52 
 53     public final void move(int var1) throws  {
 54         try {
 55             super.h.invoke(this, m3, new Object[]{Integer.valueOf(var1)});
 56         } catch (RuntimeException | Error var3) {
 57             throw var3;
 58         } catch (Throwable var4) {
 59             throw new UndeclaredThrowableException(var4);
 60         }
 61     }
 62 
 63     public final int hashCode() throws  {
 64         try {
 65             return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
 66         } catch (RuntimeException | Error var2) {
 67             throw var2;
 68         } catch (Throwable var3) {
 69             throw new UndeclaredThrowableException(var3);
 70         }
 71     }
 72 
 73     static {
 74         try {
 75             m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
 76             m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
 77             m3 = Class.forName("jdkproxy.Moveable").getMethod("move", new Class[]{Integer.TYPE});
 78             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
 79         } catch (NoSuchMethodException var2) {
 80             throw new NoSuchMethodError(var2.getMessage());
 81         } catch (ClassNotFoundException var3) {
 82             throw new NoClassDefFoundError(var3.getMessage());
 83         }
 84     }
 85 }   
 86      
 87 运行结果：
 88 汽车开始行驶...
 89 汽车行驶中...1
 90 汽车结束行驶，行驶时间为：968毫秒     
 91 */
 92 public class Test {
 93     public static void main(String[] args) {
 94         Car car=new Car();
 95         InvocationHandler h=new TimeHandler(car);
 96         Moveable m= (Moveable) Proxy.newProxyInstance(car.getClass().getClassLoader(),car.getClass().getInterfaces(),h);
 97         m.move(1);
 98         ProxyGeneratorUtils.writeProxyClassToHardDisk("D:\\idea\\study\\src\\jdkproxy\\$Proxy0.class");
 99     }
100 }