Java 动态代理原理

动态代理

代理模式

代理模式强调在对被代理对象的控制。代理模式知识点不做赘述。

静态代理，代理类的代码是在编译期间就已经确定好的。

动态代理，代理类的代码编译期间是没有的，只有在运行期间才能确定。

简单回顾下静态代理相关代码，以统计方法耗时为例。

//声明接口类
public interface IDoSth {
    void doSth(String s);
}
//声明实际类
public class DoSth implements IDoSth{
    @Override
    public void doSth(String s) {
        System.out.println("doSth:" + s);
    }
}
//声明静态代理类，可对被代理的对象进行定制化处理，此处将 xx 掉包
public class ProxyDoSth implements IDoSth{
    private IDoSth instance;
    public ProxyDoSth(IDoSth ins) {
        this.instance = ins;
    }
    @Override
    public void doSth(String s) {
        long start = System.currentTimeMillis();
        instance.doSth(s);
        System.out.println(System.currentTimeMillis()-start);
    }
}

动态代理相关语法

// 动态代理相关代码
        IDoSth ins = new DoSth();
      IDoSth proxy = (IDoSth) Proxy.newProxyInstance(Test.class.getClassLoader(), ins.getClass().getInterfaces(), new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            long start = System.currentTimeMillis();
            Object res = method.invoke(ins, args);
            System.out.println("method: " + method.getName() + " costTime : "
                + (System.currentTimeMillis() - start));
            return res;
        }
      });
        proxy.doSth("做饭");
        // 打印 proxy 对象相关类和接口信息
        System.out.println(proxy.getClass()); 
      System.out.println(proxy.getClass().getSuperclass());
      for (Class cls : proxy.getClass().getInterfaces()) {
            System.out.println(cls);
      }
}
//输出结果
doSth:做饭
method: doSth costTime : 1 // 方法耗时
class com.sun.proxy.$Proxy0 //proxy 类的类名
class java.lang.reflect.Proxy //proxy 类父类
interface jjava.dynamicProxy.IDoSth //proxy 类实现的接口

由 proxy 对象可知，其类名com.sun.proxy.$Proxy0 ，该类父类为 java.lang.reflect.Proxy且实现了 IDoSth 接口。

这里面有两个关键类，一个是 Proxy，一个是InvocationHandler。Proxy 主要负责代理类的生成，InvocationHandler 主要负责用户自定义实现代理类的功能。

动态代理的本质

动态代理没那么玄乎，仅仅是在程序运行期间生成了代理类的代码而已。那这份代码长什么样子呢？

我们将动态生成的 Proxy 类的代码保存在class 文件中，这一步代码如下

//$Proxy0 为生成的代理类的名字，path 为保存的文件名，实际上就是将byte 数组保存到本地，newProxyInstance() 方法内部就是通过这种方式生成的 代理类的 byte[]
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", ins.getClass().getInterfaces());
      String path = "/${projectPath}/jjava/dynamicProxy/$Proxy0.class";
      try(FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(classFile);
            fos.flush();
            System.out.println("cls 文件写入成功");
      } catch (Exception e) {
            System.out.println("cls 文件写入失败");
            e.printStackTrace();
      }

生成的 $Proxy0 类的代码如下

public final class $Proxy0 extends Proxy implements IDoSth {
    private static Method m1;   //java.lang.Object#equals()
    private static Method m2;   //java.lang.Object#toString()
    private static Method m3;   //jjava.dynamicProxy.IDoSth#doSth()
    private static Method m0;   //java.lang.Object#hashcode()
    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }
        // 通过 proxy.doSth(xx) 时，本质上调的是这个方法，内部是通过调用 InvocationHandler 中的 invoke 方法实现的。
    public final void doSth(String var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("jjava.dynamicProxy.IDoSth").getMethod("doSth", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }   
}

通过类信息，可以和签名的log信息互相验证。同时由于所有动态代理产生的类都是Proxy 的子类，所以我们在使用时，只能用 interfaces 中的任一接口承接，而不能用自定义的其他类型，否则会报 ClassCastException。

可以看到 $Proxy0类的构造函数，包括一个 InvocationHandler 类型的参数，并将该参数传给了父类的函数，该阐述就是我们调用Proxy.newProxyInstance() 方法传入的 h。

我们在调用代理类的方法时，如 proxy.doSth()，本质上是通过super.h.invoke(this, m3, new Object[]{var1}); 实现的。h为我们传入的 InvocationHandler 的实例，m3 为一个Method 对象，最终是通过调用 m3.invoke(target,args ) 实现被代理对象的方法调用。m3 是一个 Method 类的实例。与此同时，代理类 $Proxy0 除了实现所有接口类的方法外，还自动帮我们添加了Object 类的3个方法，分别是 toString（）、hashcode()、equals()。并且在代理类的类初始化阶段对这几个Method 实例进行赋值。

动态代理类的名字规则

类全路径名名 = pkgName + className
包名主要主要取决于接口是否是public 的。如果要代理的接口全都是public 的，则类的全路径名是 com.sun.proxy，否则就是非public 接口的包名。
类名为 {n}，n为当前已经创建的动态代理类的个数，由于有缓存的逻辑，只有不同数组接口的代理，才会创建新的类。n从0开始，在同进程内依次递增。源码如下：

    Proxy$ProxyClassFactory#apply()                 
                        /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            for (Class intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";// 默认值 com.sun.proxy.
            }

            /*
             * Choose a name for the proxy class to generate.
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num; //proxyClassNamePrefix 为“$Proxy”

个人理解

动态代理是对接口的代理，而不是对类的代理。没有接口则无从代理。

jvm由于不支持运行时修改一个类或修改方法，如修改方法内容，添加方法等。动态代理由于是在运行期间生产了新的代理类去扩展功能，也算是对此种不足提供了一种支持。

动态代理是 AOP 思想的一种实现，完美的实现了一个切面。方便我们在每个方法执行前后定制功能。最常见的就是统计每个方法的执行耗时，在方法执行前记录时间戳，方法执行完后再记录一次。

静态代理也可以做切面编程，只不过当使用静态代理时，手动编写代理接口类的成本太大。相对于静态代理，动态代理是在此层面上做了一层抽象和封装。定制化需求只需要在 InvocationHandler 的 invoke（）方法中添加就可以了。而且 invoke() 方法传入的参数是一个 object，意味着任何类的实例都可以被代理（只要实现相应接口），大大增强了InvocationHandler 子类复用性。

public interface InvocationHandler {
    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

很多 android 和 java 框架都应用了动态代理技术。如 Spring，retrofit等。