java动态代理

原文出处： forever

具体场景

为了使代理类和被代理类对第三方有相同的函数，代理类和被代理类一般实现一个公共的interface，该interface定义如下

1 2 3 4

public interface Calculator {     public Integer add(Integer num1, Integer num2);     public Integer minus(Integer num1, Integer num2); }

被代理类定义如下

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public class CalculatorImpl implements Calculator {       @Override     public Integer add(Integer num1, Integer num2) {         int ret = num1 + num2;         System.out.println("in calculatorImpl, res: " + ret);         return ret;     }           @Override     public Integer minus(Integer num1, Integer num2) {         int ret = num1 - num2;         System.out.println("int calculatorImpl, res: " + ret);         return ret;     }   }

代理需求：在add函数和minus函数调用前后分别输出before invocation和after invocation字样

静态代理解决方案

代码如下：简单直接，无需赘言，如果calculator里边不仅有add和minus，还有divide，product,log,sin…呢，呵呵哒

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

public class StaticCalculatorProxy implements Calculator {     Calculator obj;           public StaticCalculatorProxy(Calculator obj) {         this.obj = obj;     }       @Override     public Integer add(Integer num1, Integer num2) {         System.out.println("in StaticCalculatorProxy, before invocation");         Integer ret = obj.add(num1, num2);         System.out.println("in StaticCalculatorProxy, after invocation");         return ret;     }       @Override     public Integer minus(Integer num1, Integer num2) {         System.out.println("in StaticCalculatorProxy, before invocation");         Integer ret = obj.minus(num1, num2);         System.out.println("in StaticCalculatorProxy, after invocation");         return ret;     }   }

动态代理解决方案

首先编写实现InvocationHandler接口的类，用于请求转发，实现如下

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class CalculatorHandler implements InvocationHandler {           private Object obj; //被代理类           public CalculatorHandler(Object obj) {         this.obj = obj;     }       @Override     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {         System.out.println("in calculatorhandler, before invocation");                   Object ret = method.invoke(obj, args);  //执行被代理类方法                   System.out.println("in calculationhandler, after invocation");         return ret;     }   }

生成动态代理

1 2 3 4 5

CalculatorImpl calculatorImpl = new CalculatorImpl();//被代理类 CalculatorHandler calculatorHandler = new CalculatorHandler(calculatorImpl); Calculator calculator = (Calculator) Proxy.newProxyInstance(calculatorImpl.getClass().getClassLoader(), calculatorImpl.getClass().getInterfaces(), calculatorHandler); System.out.println(calculator.add(1,2)); System.out.println(calculator.minus(1, 2));

无论calculator中包含多少函数，动态代理只需实现一次，实际工程中，System.out.println(“in calculatorhandler, before invocation”)可能是加缓存，打日志等操作

动态代理如何工作的

为了搞清楚动态代理如何工作，首先看看生成的动态代理的代码是什么，借助[1]中ProxyUtil代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

public class ProxyUtils {       /**      * Save proxy class to path      *      * @param path path to save proxy class      * @param proxyClassName name of proxy class      * @param interfaces interfaces of proxy class      * @return      */     public static boolean saveProxyClass(String path, String proxyClassName, Class[] interfaces) {         if (proxyClassName == null || path == null) {             return false;         }           // get byte of proxy class         byte[] classFile = ProxyGenerator.generateProxyClass(proxyClassName, interfaces);         FileOutputStream out = null;         try {             out = new FileOutputStream(path);             out.write(classFile);             out.flush();             return true;         } catch (Exception e) {             e.printStackTrace();         } finally {             try {                 out.close();             } catch (IOException e) {                 e.printStackTrace();             }         }         return false;     } }

得到了生成的动态代理代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112

public final class $Proxy0 extends Proxy     implements Calculator {       public $Proxy0(InvocationHandler invocationhandler)     {         super(invocationhandler);     }       public final boolean equals(Object obj)     {         try         {             return ((Boolean)super.h.invoke(this, m1, new Object[] {                 obj             })).booleanValue();         }         catch(Error _ex) { }         catch(Throwable throwable)         {             throw new UndeclaredThrowableException(throwable);         }     }       public final String toString()     {         try         {             return (String)super.h.invoke(this, m2, null);         }         catch(Error _ex) { }         catch(Throwable throwable)         {             throw new UndeclaredThrowableException(throwable);         }     }       public final Integer minus(Integer integer, Integer integer1)     {         try         {             return (Integer)super.h.invoke(this, m4, new Object[] {                 integer, integer1             });         }         catch(Error _ex) { }         catch(Throwable throwable)         {             throw new UndeclaredThrowableException(throwable);         }     }       public final Integer add(Integer integer, Integer integer1)     {         try         {             return (Integer)super.h.invoke(this, m3, new Object[] {                 integer, integer1             });         }         catch(Error _ex) { }         catch(Throwable throwable)         {             throw new UndeclaredThrowableException(throwable);         }     }       public final int hashCode()     {         try         {             return ((Integer)super.h.invoke(this, m0, null)).intValue();         }         catch(Error _ex) { }         catch(Throwable throwable)         {             throw new UndeclaredThrowableException(throwable);         }     }       private static Method m1;     private static Method m2;     private static Method m4;     private static Method m3;     private static Method m0;       static     {         try         {             m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {                 Class.forName("java.lang.Object")             });             m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);             m4 = Class.forName("com.langrx.mq.Calculator").getMethod("minus", new Class[] {                 Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer")             });             m3 = Class.forName("com.langrx.mq.Calculator").getMethod("add", new Class[] {                 Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer")             });             m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);         }         catch(NoSuchMethodException nosuchmethodexception)         {             throw new NoSuchMethodError(nosuchmethodexception.getMessage());         }         catch(ClassNotFoundException classnotfoundexception)         {             throw new NoClassDefFoundError(classnotfoundexception.getMessage());         }     } }

有点长，按照初始化顺序慢慢来分析，首先分析静态代码块：

1 2 3 4 5 6 7 8 9 10 11

m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {                     Class.forName("java.lang.Object")                 }); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m4 = Class.forName("com.langrx.mq.Calculator").getMethod("minus", new Class[] {                     Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer")                 }); m3 = Class.forName("com.langrx.mq.Calculator").getMethod("add", new Class[] {                     Class.forName("java.lang.Integer"), Class.forName("java.lang.Integer")                 }); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

得到公共interface中的add函数和minus函数对应的Method方法，同事也得到了equals，toString，hashCode三个函数的Method，所以调用代理类的equals，toString，hashCode也是要执行被代理类的方法的，知道这点很有必要

构造函数

1 2 3 4

public $Proxy0(InvocationHandler invocationhandler) {         super(invocationhandler); }

初始化了内部的InvocationHandler变量，也就是下文的super.h

以add为例看一下请求的转发

1 2 3 4 5 6 7 8 9 10 11 12 13 14

public final Integer add(Integer integer, Integer integer1) {     try     {         return (Integer)super.h.invoke(this, m3, new Object[] {             integer, integer1         });     }     catch(Error _ex) { }     catch(Throwable throwable)     {         throw new UndeclaredThrowableException(throwable);     } }

super.h.invoke就是invocationhandler.invoke就是传入的CalculatorHandler中实现的

1 2 3 4 5 6 7 8 9

@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {     System.out.println("in calculatorhandler, before invocation");           Object ret = method.invoke(obj, args);  //执行被代理类方法           System.out.println("in calculationhandler, after invocation");     return ret; }

最终执行的就是CalculatorHandler对应的invoke函数

总结

1	Calculator calculator = (Calculator) Proxy.newProxyInstance(calculatorImpl.getClass().getClassLoader(), calculatorImpl.getClass().getInterfaces(), calculatorHandler);

生成动态代理的过程步骤如下[2]：

1 2 3 4 5 6 7 8 9 10 11 12

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发 // 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用 InvocationHandler handler = new InvocationHandlerImpl(..);    // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象 Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });    // 通过反射从生成的类对象获得构造函数对象 Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });    // 通过构造函数对象创建动态代理类实例 Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

Proxy.newProxyInstance帮我们做了2，3，4步，直接返回给我们一个动态代理对象，代理对象最终执行InvocationHandler中invoke函数。顺便强推文章[2]

References

1. https://github.com/android-cn/android-open-project-demo/tree/master/java-dynamic-proxy
2. https://www.ibm.com/developerworks/cn/java/j-lo-proxy1/index.html