深入浅出JDK动态代理(二)-白红宇

代理类解密

对于JDK动态代理，生成的代理类是什么样的？为什么调用代理类的任何方法时都一定会调用invoke方法？下面来进行深入解密。

因为动态代理是在运行时动态生成字节码，编译期看不到相应的class文件，所以不能直观的看到代理类内容。那就从newProxyInstance方法开始(代码分析基于JDK7)，这个方法用于创建代理类对象，这里只关注重要的代码段，

Class
     cl = getProxyClass0(loader, intfs);        /*         * Invoke its constructor with the designated invocation handler.         */        try {            final Constructor
     cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {                // create proxy instance with doPrivilege as the proxy class may                // implement non-public interfaces that requires a special permission                return AccessController.doPrivileged(new PrivilegedAction

代码段中

final Constructor
     cons = cl.getConstructor(constructorParams);复制代码

用于获取代理类的构造函数，constructorParams参数其实就是一个InvocationHandler，所以从这里猜测代理类中有一个InvocationHandler类型的属性，并且作为构造函数的参数。那这个代理类是在哪里创建的？注意看上面的代码段中有

Class
     cl = getProxyClass0(loader, intfs);复制代码

这里就是动态创建代理类的地方，继续深入到getProxyClass0方法中，方法如下，

private static Class
     getProxyClass0(ClassLoader loader,                                           Class
    ... interfaces) {        if (interfaces.length > 65535) {            throw new IllegalArgumentException("interface limit exceeded");        }        // If the proxy class defined by the given loader implementing        // the given interfaces exists, this will simply return the cached copy;        // otherwise, it will create the proxy class via the ProxyClassFactory        return proxyClassCache.get(loader, interfaces);    }复制代码

继续跟踪代码，进入proxyClassCache.get(loader, interfaces)，这个方法中重点关注如下代码

Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));复制代码

继续跟踪代码，进入subKeyFactory.apply(key, parameter)，进入apply方法，这个方法中有很多重要的信息，如生成的代理类所在的包名，发现重要代码，

long num = nextUniqueNumber.getAndIncrement();String proxyName = proxyPkg + proxyClassNamePrefix + num;复制代码

上面代码用于生成代理类名称，nextUniqueNumber是AtomicLong类型，是一个全局变量，所以nextUniqueNumber.getAndIncrement()会使用当前的值加一得到新值；proxyClassNamePrefix声明如下，

private static final String proxyClassNamePrefix = "$Proxy";复制代码

所以，这里生成的代理类类名格式为：包名+$Proxy+num，如jdkproxy.$Proxy12。

代理类的类名已经构造完成了，那可以开始创建代理类了，继续看代码，

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);复制代码

这里就是真正创建代理类的地方，继续分析代码，进入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;    }复制代码

从这里可以很直白的看到，生成的代理类字节码文件被输出到某个目录下了，这里可能很难找到这个字节码文件，没关系，仔细查看这个方法，generateProxyClass方法可以重用，可以在外面调用generateProxyClass方法，把生成的字节码文件输出到指定位置。写到这里，终于可以解释上面实例代码中的createProxyClassFile方法了，这个方法把代理类的字节码文件输出到了/Users路径下，直接到路径下查看这个文件，使用反编译工具查看，得到的代码如下，

public final class LoginServiceProxy extends Proxy  implements LoginService{  private static Method m1;  private static Method m3;  private static Method m0;  private static Method m2;  public LoginServiceProxy(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 (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }  public final void login()    throws   {    try    {      this.h.invoke(this, m3, null);      return;    }    catch (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }  public final int hashCode()    throws   {    try    {      return ((Integer)this.h.invoke(this, m0, null)).intValue();    }    catch (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }  public final String toString()    throws   {    try    {      return (String)this.h.invoke(this, m2, null);    }    catch (Error|RuntimeException localError)    {      throw localError;    }    catch (Throwable localThrowable)    {      throw new UndeclaredThrowableException(localThrowable);    }  }  static  {    try    {      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });      m3 = Class.forName("jdkproxy.LoginService").getMethod("login", new Class[0]);      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);      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());    }  }}复制代码

从上面的代码可以看到，当代理类调用目标方法时，会调用InvocationHandler接口实现类的invoke方法，很明了的解释了为什么调用目标方法时一定会调用invoke方法。

总结：

1.静态代理方式虽然简单，但是会出现重复代码的情况；

2.动态代理使用上相对复杂些，但是可以动态创建代理类，避免手动编写重复代码；

3.因为Java的单继承性，JDK动态代理只能对接口创建代理类，不能对实现类创建。