投稿
  1. 极客之音首页
  2. 技术随笔

JDK动态代理原理 源码详解

小半 • • 技术随笔 • 阅读 265

导读：本篇文章讲解 JDK动态代理原理 源码详解，希望对大家有帮助，欢迎收藏，转发！站点地址：www.bmabk.com

前言

Java中代理有静态代理、动态代理，动态代理中又分JDK动态代理和CGLib动态代理

本文讲一下JDK动态代理的使用和源码实现

基于jdk1.8.0_161

附上其他两种代理的博文
Java静态代理

CGLib动态代理原理 源码详解

使用

步骤

1.新建接口

2.新建被代理类

3.新建InvocationHandler接口的实现类，Override invoke方法

4.使用Proxy生成动态代理

代码

为了方便，上述步骤的接口、类都写到一个类下面

package com.jaylin.jaylin.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKProxyTest {
    //接口
    public interface ITestClass {
        void testMethod();
    }
    //被代理类
    static class TestClass implements ITestClass {
        @Override
        public void testMethod() {
            System.out.println("TestClass");
        }
    }
    //InvocationHandler实现类
    static class Ih implements InvocationHandler {
        //目标对象
        private Object target;
        public Ih(Object target) {
            this.target = target;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object obj = method.invoke(target, args);
            return obj;
        }
    }

    public static void main(String[] args) {
        //生成$Proxy0的class文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        //参数分别为1.加载接口的类加载器 2.接口 3.InvocationHandler实现类
        ITestClass iTestClass = (ITestClass) Proxy.newProxyInstance(
                ITestClass.class.getClassLoader(),
                new Class[]{ITestClass.class},
                new Ih(new TestClass())
        );
        iTestClass .testMethod();
    }
}

源码解读

动态代理入口

ITestClass iTestClass = (ITestClass) Proxy.newProxyInstance(
                ITestClass.class.getClassLoader(), 
                new Class[]{ITestClass.class},
                new Ih(new TestClass())
        );

新建代理实例 Proxy.newProxyInstance

/**
 * 返回指定接口的代理类的实例，该实例将方法调用分派到指定的调用处理程序
 *
 * @param   loader 定义代理类的类加载器
 * @param   interfaces 代理类要实现的接口列表
 * @param   h 分发方法调用的调用处理器
 * @return  一个代理实例，具有代理类的具体调用处理器，由指定的类加载器定义，实现了指定的接口
 * @throws  IllegalArgumentException 非法参数异常
 * @throws  SecurityException 安全异常
 * @throws  NullPointerException 空指针异常
 */
@CallerSensitive
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);
    }

    //查找或生成指定的代理类
    Class<?> cl = getProxyClass0(loader, intfs);

    //用指定的调用处理器调用其构造函数
    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<Void>() {
                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);
    }
}

获取代理对象 Proxy.getProxyClass0;

    /**
     * 生成代理类
     * 在调用此方法之前，必须调用checkProxyAccess方法执行权限检查
     */
    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // 如果存在由 实现了给定接口的 给定加载器 定义的代理类
		// 将返回缓存的副本
		// 否则，将通过ProxyClassFactory创建代理类
        return proxyClassCache.get(loader, interfaces);
    }

看一下proxyClassCache，第二个参数为ProxyClassFactory

/**
 * 代理类的缓存
 */
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

可以先忽略WeakCache的实现，先考虑ProxyClassFactory的作用

调用链

Proxy.getProxyClass0
	return proxyClassCache.get(loader, interfaces);
↓
WeakCache.get
	V value = supplier.get();
↓
WeakCache$Factory.get
	value = Objects.requireNonNull(valueFactory.apply(key, parameter));
↓
Proxy$ProxyClassFactory.apply

走到aplly方法中

产生代理对象 ProxyClassFactory.apply

private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
    // 所有代理类名称的前缀
    private static final String proxyClassNamePrefix = "$Proxy";

    // 下一个用于生成唯一代理类名称的数字
    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());
            }
        }
 		//生成的代理类的包名 
        String proxyPkg = null;   
        //代理类访问控制符: public ,final
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        /*
         * 记录非公共代理接口的包，以便在同一包中定义代理类
         * 验证所有非公共代理接口都在同一程序包中
         */
        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) {
            // 如果没有非公共代理接口，使用com.sun.proxy
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        /*
         * 选择要生成的代理类的名称
         * 代理类全限定名，如com.sun.proxy.$Proxy0.calss
         */
        long num = nextUniqueNumber.getAndIncrement();
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        /*
         * 生成指定的代理类字节码
         */
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            // 将代理类加载到JVM中
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }
}

生成字节码文件 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<Void>() {
            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));
                        Files.createDirectories(var3);
                        var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
                    } else {
                        var2 = Paths.get(var0 + ".class");
                    }

                    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定义如下

private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));

所以我们在创建动态代理时，可以加这句

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

查看生成的代理类

在com.sun.proxy.$Proxy0.class，

可以看到，除了equals、toString、hashCode方法，还有被代理类的testMethod方法

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

package com.sun.proxy;

import com.jaylin.jaylin.Test.ITestClass;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

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

    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);
        }
    }

    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 testMethod() throws  {
        try {
            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.jaylin.jaylin.Test$ITestClass").getMethod("testMethod");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

参考：

java中的三种代理模式

JDK动态代理实现原理

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/93735.html

赞 (0)
小半的头像小半
0 0

相关推荐

极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！