Java 动态代理-JDK动态代理源码简析

简述

Java动态代理有两种，即JDK提供的原生的动态代理（要求被代理类实现某个接口）或者CGLIB（要求被代理类可继承，即不使用final修饰），本文主要是对jdk原生的动态代理的源码进行简单的分析。

如何使用JDK动态代理创建一个动态代理？

方法：调用Proxy.newProxyInstance方法即可

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException

作用：Proxy.newProxyInstance 的作用是生成一个实现了 interfaces指定的一个或者多个接口的代理类。

参数：
1）loader：这里的classloader通常是AppClassLoader，其作用是用来加载生成的代理类到JVM中去。

2）interfaces：代理类要实现的接口，即被代理类的想要被代理的接口保持一致。（不一定是被代理类实现的所有接口）

2）InvocationHandler 核心的代理逻辑，即用户使用此代理的目的，可以是日志记录，调用统计，鉴权等。

使用示例：

ISet iset = (ISet) Proxy.newProxyInstance(ISet.class.getClassLoader(), new Class[]{ISet.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法：" + method.getName() + "开始调用");
                //SetImpl是被代理类，是Iset接口的某个实现类
                Object res = method.invoke(new SetImpl(), args);
                System.out.println("方法：" + method.getName() + "调用结束");
                System.out.println("方法调用结果："+res);
                return res;
            }
        });
        iset.set();

Iset接口：

public interface ISet {
    void set();
}

输出：

方法：set开始调用
set invoke
方法：set调用结束
/*
* 需要注意的是Java反射的method的invoke方法总是有返回值，如果
* method代表的是一个无返回值的函数，那么invoke后会返回null
* 
*/
方法调用结果：null

源码简析

newProxyInstance方法：

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        //Java的安全检查，非核心不用细看
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
		
        /*
         * 生成代理类的class类--见下方getProxyClass0方法分析
         */
        Class<?> cl = getProxyClass0(loader, intfs);
  
        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
           /*
           * 获取参数是InvocationHandler的代理类的构造方法，默认
           * 生成的代理类都有这么一个构造方法
           */
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            /*
            * 生成的代理类可能是默认访问权限，原因见下方--
            * 新建代理类的方法：ProxyClassFactory.apply分析
            * /
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                       //设置构造方法可访问
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //创建代理类实例并返回，这里把h:InvocationHandler传进来
            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方法：

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
        // 这里使用一个WeakCache作为缓存，如果缓存中有相应的代理类（由classloader和interface决定）直接拿出来使用即可，否则需要新建一个代理类。
        //--详见下方新建代理类的方法：ProxyClassFactory.apply分析
        return proxyClassCache.get(loader, interfaces);
    }

新建代理类的方法：ProxyClassFactory.apply

    private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // prefix for all proxy class names
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, 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.
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

 			/*
             * 如果指定的接口有不是public权限的，那么要求这些接口要属于同一个包  
             * 最终生成的代理类的名字通常是这样的：com.sun.proxy.$Proxy(数字，创建了几个代理类就       
             * 是几)，前提是interfaces都是public的访问权限
             * 如果interfaces中有一个以上的不是public权限（即为default权限）的，那么要求它们必须都
             * 是属于一个包，并且此时代理类的所属包也是这个包。
             *  原因很简单，接口只有两种访问权限，public和default，如果要实现的接口有一个以上是
             * default的话，代理类在其他包无法访问到这些接口，因此要和这些接口的在一个包下面。
             */
            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                   /*
                   * 这里把生成的代理类去掉public访问权限，使得该类只能被属于同一个包的其他类访问到
                   * 原因可能只是和接口的权限保持一致？
                   */
                    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 + ".";
            }
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
            
            /*
             * 使用ProxyGenerator.generateProxyClas方法创建一个实现指定接口的代理类的class类文
             * 件，并返回它的二进制流，供defineClass0创建一个代理类的class类
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

可以通过ProxyGenerator.generateProxyClass方法返回代理类class文件的二进制流，将其写入文件输出流，即可将生成的代理类保存下来，如下所示：

SetProxy 代理类：

public final class SetProxy extends Proxy implements ISet {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public SetProxy(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 void set() throws  {
        try {
           /*
           	* 这个h就是 Proxy.newProxyInstance方法创建代理类实例时传入的InvocationHandler（代理逻
           	* 辑），调用代理类的接口方法最终等于调用
           	*  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法：" + method.getName() + "开始调用");
                //SetImpl是被代理类，是Iset接口的某个实现类
                Object res = method.invoke(new SetImpl(), args);
                System.out.println("方法：" + method.getName() + "调用结束");
                System.out.println("方法调用结果："+res);
                return res;
            }
            * proxy就是代理类本身，method就是  
           	* Class.forName("com.hans.thriftserver.impl.ISet").getMethod("set");的ISet接口的set方法
           	* args则是参数，这里没有参数，所以为Object[])null
           */
            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("com.hans.thriftserver.impl.ISet").getMethod("set");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

注：
1）
CallerSensitive注解的作用（仅供参考）

参考链接

Java 动态代理详解