java动态代理ProxyGenerator

　　jdk自带实现动态代理核心逻辑即是在调用  java.lang.reflect.Proxy#newProxyInstance 时，根据用户指定实现的接口动态创建一个Proxy类定义的byte[]，然后调用native 的defineClass返回该代理类的实例；

 

核心逻辑实例：

 

String className = "com.sun.$Proxy";
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        Class<?>[] cls = new Class<?>[]{Executor.class};

        byte[] bytes = ProxyGenerator.generateProxyClass(className, cls, accessFlags);
        
        System.out.println("byteLen: " + bytes.length);
        Path path = Paths.get("D:\\misc\\Proxy.class");

        try {
            Files.createFile(path);
            OutputStream outputStream = Files.newOutputStream(path, StandardOpenOption.WRITE);
            outputStream.write(bytes);
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

 

这里将byte[] 写入文件，二进制文件Proxy.class 反编译后类似：

 

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.sun;

import indi.joynic.actscase.gen.aopalliance.Executor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy extends Proxy implements Executor {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy(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);
        }
    }

    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 char execute() throws  {
        try {
            return (Character)super.h.invoke(this, m3, (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"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("indi.joynic.actscase.gen.aopalliance.Executor").getMethod("execute");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

 

生成了一个新的Proxy代理子类，可以看到实际返回的类定义写入了 hashCode() 、toString()、equals()和 用户接口方法 execute(), 而且将方法调用委派给用户指定的 InvocationHandler。

 

所以本质上来说“动态代理”仍旧是“静态代理”，“动态”表现在不用修改代码的情况下运行时通过“魔改”，然后“偷梁换柱”的方式返回给用户代理对象；

对用户来说，调用返回的代理对象本身就实现了用户接口 （implements Executor）。

从用户的角度语义上讲即为：“塞给java.lang.reflect.Proxy任意接口和目标对象，Poxy都能给出用户指定增强目标对象接口方法逻辑的代理对象”；

 

如果不制定具体是哪个接口，java.lang.reflect.Proxy 无法得知在从何处抽取出接口方法生成class byte数组。

无接口AOP增强类方法就要依靠cglib之类工具了。