最近在看 Spring AOP 部分的源码，所以对 JDK 动态代理具体是如何实现的这件事产生了很高的兴趣，而且能从源码上了解这个原理的话，也有助于对 spring-aop 模块的理解。话不多说，上代码。

    1. /**
    2.  * 一般会使用实现了 InvocationHandler接口 的类作为代理对象的生产工厂，
    3.  * 并且通过持有 被代理对象target，来在 invoke()方法 中对被代理对象的目标方法进行调用和增强，
    4.  * 这些我们都能通过下面这段代码看懂，但代理对象是如何生成的？invoke()方法 又是如何被调用的呢？
    5.  */
    6. public class ProxyFactory implements InvocationHandler {
    8.     private Object target = null;
    10.     public Object getInstanse(Object target){
    12.         this.target = target;
    13.         return Proxy.newProxyInstance(target.getClass().getClassLoader(),
    14.                 target.getClass().getInterfaces(), this);
    15.     }
    17.     @Override
    18.     public Object invoke(Object proxy, Method method, Object[] args)
    19.             throws Throwable {
    21.         Object ret = null;
    22.         System.out.println("前置增强");
    23.         ret = method.invoke(target, args);
    24.         System.out.println("后置增强");
    25.         return ret;
    26.     }
    27. }
    29. /**
    30.  * 实现了 接口MyInterface 和接口的 play()方法，可以作为被代理类
    31.  */
    32. public class TargetObject implements MyInterface {
    34.     @Override
    35.     public void play() {
    36.         System.out.println("妲己，陪你玩 ~");
    37.     }
    38. }
    40. /**
    41.  * 测试类
    42.  */
    43. public class ProxyTest {
    45.     public static void main(String[] args) {
    46.         TargetObject target = new TargetObject();
    47.         // ProxyFactory 实现了 InvocationHandler接口，其中的 getInstanse()方法 利用 Proxy类
    48.         // 生成了 target目标对象 的代理对象，并返回；且 ProxyFactory 持有对 target 的引用，可以在
    49.         // invoke() 中完成对 target 相应方法的调用，以及目标方法前置后置的增强处理
    50.         ProxyFactory proxyFactory = new ProxyFactory();
    51.         // 这个 mi 就是 JDK 的 Proxy类 动态生成的代理类 $Proxy0 的实例，该实例中的方法都持有对
    52.         // invoke()方法 的回调，所以当调用其方法时，就能够执行 invoke() 中的增强处理
    53.         MyInterface mi = (MyInterface) proxyFactory.getInstanse(target);
    54.         // 这样可以看到 mi 的 Class 到底是什么
    55.         System.out.println(mi.getClass());
    56.         // 这里实际上调用的就是 $Proxy0代理类 中对 play()方法 的实现，结合下面的代码可以看到
    57.         // play()方法 通过 super.h.invoke() 完成了对 InvocationHandler对象(proxyFactory)中
    58.         // invoke()方法 的回调，所以我们才能够通过 invoke()方法 实现对 target对象 方法的
    59.         // 前置后置增强处理
    60.         mi.play();
    61.         // 总的来说，就是在 invoke()方法 中完成 target目标方法 的调用，及前置后置增强，
    62.         // JDK 动态生成的代理类中对 invoke()方法 进行了回调
    63.     }
    65.     /**
    66.      * 将 ProxyGenerator 生成的动态代理类的输出到文件中，利用反编译工具 luyten 等就可
    67.      * 以看到生成的代理类的源码咯，下面给出了其反编译好的代码实现
    68.      */
    69.     @Test
    70.     public void generatorSrc(){
    71.         byte[] bytesFile = ProxyGenerator.generateProxyClass("$Proxy0", TargetObject.class.getInterfaces());
    72.         FileOutputStream fos = null;
    73.         try{
    74.             String path = System.getProperty("user.dir") + "\\$Proxy0.class";
    75.             File file = new File(path);
    76.             fos = new FileOutputStream(file);
    77.             fos.write(bytesFile);
    78.             fos.flush();
    79.         } catch (Exception e){
    80.             e.printStackTrace();
    81.         } finally{
    82.             try {
    83.                 fos.close();
    84.             } catch (IOException e) {
    85.                 // TODO Auto-generated catch block
    86.                 e.printStackTrace();
    87.             }
    88.         }
    89.     }
    90. }
    92. /**
    93.  * Proxy 生成的代理类，可以看到，其继承了 Proxy，并且实现了 被代理类的接口MyInterface
    94.  */
    95. public final class $Proxy0 extends Proxy implements MyInterface {
    96.     private static Method m1;
    97.     private static Method m0;
    98.     private static Method m3;
    99.     private static Method m2;
    101.     static {
    102.         try {
    103.             $Proxy0.m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
    104.             $Proxy0.m0 = Class.forName("java.lang.Object").getMethod("hashCode", (Class<?>[])new Class[0]);
    105.             // 实例化 MyInterface 的 play()方法
    106.             $Proxy0.m3 = Class.forName("com.shuitu.test.MyInterface").getMethod("play", (Class<?>[])new Class[0]);
    107.             $Proxy0.m2 = Class.forName("java.lang.Object").getMethod("toString", (Class<?>[])new Class[0]);
    108.         }
    109.         catch (NoSuchMethodException ex) {
    110.             throw new NoSuchMethodError(ex.getMessage());
    111.         }
    112.         catch (ClassNotFoundException ex2) {
    113.             throw new NoClassDefFoundError(ex2.getMessage());
    114.         }
    115.     }
    117.     public $Proxy0(final InvocationHandler invocationHandler) {
    118.         super(invocationHandler);
    119.     }
    121.     public final void play() {
    122.         try {
    123.             // 这个 h 其实就是我们调用 Proxy.newProxyInstance()方法 时传进去的 ProxyFactory对象(它实现了
    124.             // InvocationHandler接口)，该对象的 invoke()方法 中实现了对目标对象的目标方法的增强。
    125.             // 看到这里，利用动态代理实现方法增强的实现原理就全部理清咯
    126.             super.h.invoke(this, $Proxy0.m3, null);
    127.         }
    128.         catch (Error | RuntimeException error) {
    129.             throw new RuntimeException();
    130.         }
    131.         catch (Throwable t) {
    132.             throw new UndeclaredThrowableException(t);
    133.         }
    134.     }
    136.     public final boolean equals(final Object o) {
    137.         try {
    138.             return (boolean)super.h.invoke(this, $Proxy0.m1, new Object[] { o });
    139.         }
    140.         catch (Error | RuntimeException error) {
    141.             throw new RuntimeException();
    142.         }
    143.         catch (Throwable t) {
    144.             throw new UndeclaredThrowableException(t);
    145.         }
    146.     }
    148.     public final int hashCode() {
    149.         try {
    150.             return (int)super.h.invoke(this, $Proxy0.m0, null);
    151.         }
    152.         catch (Error | RuntimeException error) {
    153.             throw new RuntimeException();
    154.         }
    155.         catch (Throwable t) {
    156.             throw new UndeclaredThrowableException(t);
    157.         }
    158.     }
    160.     public final String toString() {
    161.         try {
    162.             return (String)super.h.invoke(this, $Proxy0.m2, null);
    163.         }
    164.         catch (Error | RuntimeException error) {
    165.             throw new RuntimeException();
    166.         }
    167.         catch (Throwable t) {
    168.             throw new UndeclaredThrowableException(t);
    169.         }
    170.     }
    171. }