0.一个简单的JDK动态代理的例子

创建代理类接口

public interface ProxyInterface {    public String proxy(String username);}

创建接口的实现

public class ProxyClass implements ProxyInterface {    public String proxy(String username) {        System.out.println("....processor....");        return String.format("Hello Proxy : %s", username);    }}

实现一个InvocationHandler

public class ProxyInvocationHandler implements InvocationHandler {    private Object target;    public ProxyInvocationHandler(Object target) {        this.target = target;    }    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("---Before---Method Name:" + method.getName());        Object retVal = method.invoke(target, args);        System.out.println("---After---Return Value:" + retVal);        return retVal;    }}

使用动态代理执行被代理类的方法

public class Main {    public static void main(String[] args) {        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler(new ProxyClass());        ProxyInterface proxy = (ProxyInterface) Proxy.newProxyInstance(Main.class.getClassLoader(), new Class[]{ProxyInterface.class}, proxyInvocationHandler);        proxy.proxy("sage");    }}

查看输出结果

---Before---Method Name:proxy....processor....---After---Return Value:Hello Proxy : sage

1.JDK动态代理的源码实现

    我们从上面的代码可以看出,JDK动态代理的使用非常简单,只需要调用Proxy.newProxyInstance方法即可,我们就从这里入手看一下JDK动态代理的源码实现.下面的代码,没有特殊说明,都是在Proxy类中~

public static Object newProxyInstance(ClassLoader loader,                                          Class
    [] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException    {        Objects.requireNonNull(h);        final Class
    [] intfs = interfaces.clone();        final SecurityManager sm = System.getSecurityManager();        if (sm != null) {            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);        }        /*         * 查找或生成动态代理类.(JDK如果在缓存中已经找到生成的动态代理类,会直接返回)         */        Class
     cl = getProxyClass0(loader, intfs);        /*         * 使用我们的InvocationHandler作为新生成的代理类的构造方法的参数,来获取代理类的实例         */        try {            if (sm != null) {                checkNewProxyPermission(Reflection.getCallerClass(), cl);            }            final Constructor
     cons = cl.getConstructor(constructorParams);            final InvocationHandler ih = h;            if (!Modifier.isPublic(cl.getModifiers())) {                AccessController.doPrivileged(new PrivilegedAction
    
     () {                    public Void run() {                        cons.setAccessible(true);                        return null;                    }                });            }            return cons.newInstance(new Object[]{h});        } catch (IllegalAccessException|InstantiationException e) {            throw new InternalError(e.toString(), e);        } catch (InvocationTargetException e) {            Throwable t = e.getCause();            if (t instanceof RuntimeException) {                throw (RuntimeException) t;            } else {                throw new InternalError(t.toString(), t);            }        } catch (NoSuchMethodException e) {            throw new InternalError(e.toString(), e);        }    }
    

    在这里最重要的地方就是注释的两个地方:

• getProxyClass0
• 使用InvocationHandler生成代理类的实例

1.1 getProxyClass0()

private static Class
     getProxyClass0(ClassLoader loader,                                           Class
    ... interfaces) {        //检查被代理类的接口数量,不能多于65535,问题是...谁会写那么多接口...        if (interfaces.length > 65535) {            throw new IllegalArgumentException("interface limit exceeded");        }        //JDK对生成的动态代理类进行了缓存,如果已经存在了相应的代理类,就直接返回,提高了性能        return proxyClassCache.get(loader, interfaces);}

    下面我们来看一下proxyClassCache,具体的缓存方式我就不详说了,就来看一下这个proxyClassCache是如何创建的吧,这里有一个很重要的东西.

private static final WeakCache
    
     [], Class
     >        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
    

    这里面使用了ProxyClassFactory来生成代理类,我们来看一下这个类的源码:ProxyClassFactory是Proxy的静态内部类.

private static final class ProxyClassFactory        implements BiFunction
    
     [], Class
     >    {        // 所有动态代理类的前缀都以 $Proxy 开头        private static final String proxyClassNamePrefix = "$Proxy";        // 用于生成代理类名字的计数器,也就是说,所有代理类的名字模式都一样,使用计数器来分别        private static final AtomicLong nextUniqueNumber = new AtomicLong();        @Override        public Class
      apply(ClassLoader loader, Class
     [] interfaces) {            //代理类的接口校验逻辑,不是很重要....            Map
     
      , Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);            for (Class
       intf : interfaces) {                /*                 * Verify that the class loader resolves the name of this                 * interface to the same Class object.                 */            }            //代理类的包名            String proxyPkg = null;                 int accessFlags = Modifier.PUBLIC | Modifier.FINAL;            //如果接口不是public的,那么生成代理类的包名和被代理类的包名相同            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");                    }                }            }            //如果在上面的逻辑中没有设置生成代理类的包名,则指定默认值:com.sun.proxy.            if (proxyPkg == null) {                // if no non-public proxy interfaces, use com.sun.proxy package                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";            }            //计数器增加,生成代理类的类名            long num = nextUniqueNumber.getAndIncrement();            String proxyName = proxyPkg + proxyClassNamePrefix + num;            //生成代理类的核心逻辑,这段代码木有开源,我们一会儿可以反编译看一下大概的内容            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(                proxyName, interfaces, accessFlags);            try {                return defineClass0(loader, proxyName,                                    proxyClassFile, 0, proxyClassFile.length);            } catch (ClassFormatError e) {                /*                 * A ClassFormatError here means that (barring bugs in the                 * proxy class generation code) there was some other                 * invalid aspect of the arguments supplied to the proxy                 * class creation (such as virtual machine limitations                 * exceeded).                 */                throw new IllegalArgumentException(e.toString());            }        }    }
     
    

1.2 ProxyGenerator.generateProxyClass()

    因为这个类是没有开源的,所以我们就大致来看一下这个方法的内容:

public static byte[] generateProxyClass(final String var0, Class
    [] var1, int var2) {        ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);        final byte[] var4 = var3.generateClassFile();        if(saveGeneratedFiles) {//这里是判断是否将生成的动态代理类保存到本地            AccessController.doPrivileged(new PrivilegedAction() {                public Void run() {                    try {                        int var1 = var0.lastIndexOf(46);                        Path var2;                        if(var1 > 0) {                            Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar), new String[0]);                            Files.createDirectories(var3, new FileAttribute[0]);                            var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");                        } else {                            var2 = Paths.get(var0 + ".class", new String[0]);                        }                        Files.write(var2, var4, new OpenOption[0]);                        return null;                    } catch (IOException var4x) {                        throw new InternalError("I/O exception saving generated file: " + var4x);                    }                }            });        }        return var4;    }

saveGeneratedFiles:来判断是否将生成的动态代理类保存到本地的变量,是通过环境变量来判断的的.

sun.misc.ProxyGenerator.saveGeneratedFiles

2.通过实例查看生成的动态代理类

    还使用最开始的例子, 先在main方法的最开始配置环境变量:

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

    运行Main方法,然后进入com/sun/proxy包,查看一下生成的代理类:

public final class $Proxy0 extends Proxy implements ProxyInterface {    private static Method m1;    private static Method m2;    private static Method m3;    private static Method m0;    public $Proxy0(InvocationHandler var1) throws  {        super(var1);//就是将InvocationHandler赋值给Proxy的h变量    }    public final boolean equals(Object var1) throws  {        try {            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();        } 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 String proxy(String var1) throws  {        try {            return (String)super.h.invoke(this, m3, new Object[]{var1});        } catch (RuntimeException | Error var3) {            throw var3;        } catch (Throwable var4) {            throw new UndeclaredThrowableException(var4);        }    }    public final int hashCode() throws  {        try {            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();        } catch (RuntimeException | Error var2) {            throw var2;        } catch (Throwable var3) {            throw new UndeclaredThrowableException(var3);        }    }    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]);            m3 = Class.forName("test.sage.proxy.ProxyInterface").getMethod("proxy", new Class[]{Class.forName("java.lang.String")});            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);        } catch (NoSuchMethodException var2) {            throw new NoSuchMethodError(var2.getMessage());        } catch (ClassNotFoundException var3) {            throw new NoClassDefFoundError(var3.getMessage());        }    }}

    观察这个类的特点如下:

• 生成的代理类继承了Proxy类,同时实现了代理接口.这就说明了为什么JDK动态代理只支持接口的原因,因为Java不支持多继承.
• 提供了一个构造函数,传入InvocationHandler,并赋值给Proxy的h变量
• 所有的方法,包括我们自己的方法,都只是简单的调用了invocationHandler的invoke方法.所以,我们的InvocationHandler其实都可以不用调用我们自己的方法,而执行别的逻辑.

3.总结

    通过上面的解析,我们可以总结出来:

• JDK动态代理的类必须实现接口
• 代理的增强类需要实现InvocationHandler
• 通过Proxy.newProxyInstance来创建代理对象
• 生成代理类的核心是:ProxyClassFactory,并通过saveGeneratedFiles来判断是否将动态代理的类生成到本地
• 生成的代理类的包路径是com.sun.proxy,通过一个AtomicLong来进行类名的生成
• 生成的代理类默认继承了Proxy类,并以我们自定义的InvocationHandler作为构造参数