Java动态代理

• 代理模式

• Java动态代理

• 动态代理实现

---

代理是一种设计模式。在一些情况下，一个对象并不能或者并不希望被其他某些调用，代理就可以在这其中起到中介的作用。
这样既可以使用真实对象的方法，又可以保护目标对象，还可以在真实方法调用的前后进行一些操作。

常见的代理模式实现方式如下：
定义一个接口：

public interface Subject {    String doSth(String name);    }

实现接口：

    public class RealSubject implements Subject{    public String doSth(String name) {        return String.format("I'm %s, i am doing Real thing now...",new String[]{name});    }    }

如果有这样的情况，我们并不想让测试类直接调用RealSubject的doSth方法。
实现接口，创建一个代理的类，让代理类来调用RealSubject对象的方法 ：

    public class ProxySubject implements Subject{    private  Subject realSubject;    public  ProxySubject(Subject realSubject)  {this.realSubject = realSubject ;}    public String doSth(String name)  {        System.out.println("Proxy start -----");        System.out.println(realSubject.doSth(name));  // 此处执行真实对象的request方法        System.out.println("Proxy end -----");        return "OK";    }    }

测试：

    public class Test {    public static void main(String[] args) {        RealSubject realSubject = new RealSubject();        Subject subject = new ProxySubject(realSubject);        subject.doSth("Irving");    }    }

返回的结果：
Proxy start —–
I’m Irving, i am doing Real thing now…
Proxy end —–

上面实现了一个简单的代理模式，被代理对象的类(RealSubject)和代理类(ProxySubject)都需要实现同一个接口，这会导致
1. 增加维护的复杂度；将来修改接口的时候要改动两个实现，
2. 增加代码量：而且ProxySubject在这里只做了一个“壳”的作用，特意给它写个类实在有点不划算。

此时的代理方式，在程序运行之前就已经确定了谁代理谁。然后按照固定的方式将被代理的对象传入代理类，然后再调用代理类中的方法。

这是静态代理方式。

JDK提供了一种“动态代理”方式：
动态代理类的源码是在程序运行期间由JVM根据反射等动态机制生成的，所以不存在代理类的字节码文件，代理类和被代理的类是在运行期间确定的代理关系。

接下来看看如何使用动态代理的方式生成上面的接口实现RealSubject的代理。

先实现一个处理器，实现InvocationHandler，invoke方法定义了如何处理方法调用时的逻辑，简单处理下：

    public class DynamicProxy implements InvocationHandler{    private Object object;    public DynamicProxy(Object obj){        object = obj;    }    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("Dynamic Proxy start -----");        System.out.println(method.invoke(object, args));        System.out.println("Dynamic Proxy end -----");        return "OK";    }    }

调用类实现：

    public class TestDynamic {    public static void main(String[] args) {        Subject realSubject = new RealSubject();        InvocationHandler invocationHandler = new DynamicProxy(realSubject);        Class cls = realSubject.getClass();        Subject subject = (Subject)Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),invocationHandler);        subject.doSth("IRVING");    }    }

从DEBUG说起，可以DEBUG看看生成的Subject subject是什么类型的：

$Proxy0类型的，这明显不是我们自定义的类型。

内部类的定义有规范是 A $ B 的格式，但是这里是以$开头的。感觉应该是标记说明是运行时生成的类对象。观察发现这个对象可以转化成Subject对象，说明这个类可能是实现了这个接口(也可能继承了这个接口的实现类)。

这个对象是如何生成的？
Proxy.newProxyInstance方法传入了三个参数：
加载被代理类的ClassLoader、被代理类型的接口列表、自定义的InvocationHandler实现。
该方法中，有这样一句：

    Class<?> cl = getProxyClass0(loader, interfaces);

核心的，这个方法有如下代码：

     String proxyName = proxyPkg + proxyClassNamePrefix + num;                /*                 * Verify that the class loader hasn't already                 * defined a class with the chosen name.                 */                /*                 * Generate the specified proxy class.                 */                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                    proxyName, interfaces);                try {                    proxyClass = defineClass0(loader, proxyName,                        proxyClassFile, 0, proxyClassFile.length);                } catch (ClassFormatError e) {

其中的proxyClassNamePrefix 就是：

        /** prefix for all proxy class names */    private final static String proxyClassNamePrefix = "$Proxy";

所以我们的代理类命名为：$Proxy加上一个数字。

    byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                proxyName, interfaces);

这句生成了代理类的字节数组，并且结合后面一句，从内存中加载出来创建了代理类。

再简要看看ProxyGenerator的generateProxyClass方法：

        public static byte[] generateProxyClass(final String var0, Class[] var1) {        ProxyGenerator var2 = new ProxyGenerator(var0, var1);        final byte[] var3 = var2.generateClassFile();        if(saveGeneratedFiles) {            AccessController.doPrivileged(new PrivilegedAction() {                public Void run() {                    try {                        FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");                        var1.write(var3);                        var1.close();                        return null;                    } catch (IOException var2) {                        throw new InternalError("I/O exception saving generated file: " + var2);                    }                }            });        }        return var3;    }

除了返回class的字节数组，甚至还发现，如果saveGeneratedFiles参数为true的时候，还能把该class保存到磁盘。
稍微修改下main方法：

    public class TestDynamic {    public static void main(String[] args) {        Subject realSubject = new RealSubject();        InvocationHandler invocationHandler = new DynamicProxy(realSubject);        Class cls = realSubject.getClass();        byte[] data = ProxyGenerator.generateProxyClass("$myProxy0", cls.getInterfaces());        FileOutputStream out = null;        try {            out = new FileOutputStream("E:\\$myProxy0.class");            out.write(data);            out.flush();        } catch (Exception e) {            e.printStackTrace();        } finally {            try {                out.close();            } catch (IOException ex) {                ex.printStackTrace();            }        }    }    }

用反编译工具查看class的内容：

import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class $myProxy0 extends Proxy  implements Subject{  private static Method m1;  private static Method m0;  private static Method m3;  private static Method m2;  public $myProxy0(InvocationHandler paramInvocationHandler)    throws   {    super(paramInvocationHandler);  }  public final boolean equals(Object paramObject)    throws   {    try    {      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();    }    catch (RuntimeException localRuntimeException)    {      throw localRuntimeException;    }    catch (Throwable localThrowable)    {    }    throw new UndeclaredThrowableException(localThrowable);  }  public final int hashCode()    throws   {    try    {      return ((Integer)this.h.invoke(this, m0, null)).intValue();    }    catch (RuntimeException localRuntimeException)    {      throw localRuntimeException;    }    catch (Throwable localThrowable)    {    }    throw new UndeclaredThrowableException(localThrowable);  }  public final String doSth(String paramString)    throws   {    try    {      return (String)this.h.invoke(this, m3, new Object[] { paramString });    }    catch (RuntimeException localRuntimeException)    {      throw localRuntimeException;    }    catch (Throwable localThrowable)    {    }    throw new UndeclaredThrowableException(localThrowable);  }  public final String toString()    throws   {    try    {      return (String)this.h.invoke(this, m2, null);    }    catch (RuntimeException localRuntimeException)    {      throw localRuntimeException;    }    catch (Throwable localThrowable)    {    }    throw new UndeclaredThrowableException(localThrowable);  }  static  {    try    {      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);      m3 = Class.forName("Subject").getMethod("doSth", new Class[] { Class.forName("java.lang.String") });      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);      return;    }    catch (NoSuchMethodException localNoSuchMethodException)    {      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());    }    catch (ClassNotFoundException localClassNotFoundException)    {    }    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());  }}

$myProxy0类继承自Proxy并且实现了Subject接口。
除了重写了hashCode和equals方法之外，它也有一个doSth方法，这和我们之前静态代理模式的代理是一个方式，并且doSth方法触发了InvocationHandler对象h的invoke方法。也就是我们自己实现的Handler。
即，调用代理的doSth方法，也就是调用了InvocationHandler的invoke方法。

return (String)this.h.invoke(this, m3, new Object[] { paramString });