JDK动态代理实现原理

概念

动态代理类的代理类并不是在Java代码中定义的，而是在运行时根据我们在Java代码中的“指示”动态生成的。相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。 动态代理的实现方式有两种，JDK实现和CGlib实现。本文重点讲解JDK实现原理，进一步了解动态代理。

简单使用

1、创建一个接口（JDK动态代理实现需要被代理对象必须实现一个接口）

public interface Calculator {
    int add(int i, int j);
}

2、为接口创建一个实现类

public class MyCalculator implements Calculator {

    @Override
    public int add(int i, int j) {
        return i + j;
    }
}

3、创建代理类实现InvocationHandler接口，可以在方法执行前后增加功能

public class MyProxy implements InvocationHandler {

    private Object obj;

    public Object getProxy(Object obj){
        this.obj = obj;
        ClassLoader classLoader = obj.getClass().getClassLoader();
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        return Proxy.newProxyInstance(classLoader, interfaces, this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("方法执行前");
        Object result = method.invoke(obj, args);
        System.out.println("方法执行后");
        return result;
    }
}

4、使用代理类

public class Test01 {
    public static void main(String[] args) {
        MyProxy proxy = new MyProxy();
        Calculator calculator = (Calculator)proxy.getProxy(new MyCalculator());
        System.out.println(calculator.add(1, 2));
    }
}

结果

方法执行前
方法执行后
3

源码分析

通过Proxy类中的newProxyInstance方法生成一个代理类，很明显这是关键。我们就从这里开始展开

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);
            }
            //以InvocationHandler作为参数获取代理类的构造方法
            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);
        }
    }

接下来就需要了解字节码文件是怎么生成的

    private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        //代理接口个数不能超过65535
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        //从缓存获取对应接口的代理类，没有则创建
        return proxyClassCache.get(loader, interfaces);
    }

看下是如何从缓存中获取，没有又是怎么进行创建

public V get(K key, P parameter) {
        Objects.requireNonNull(parameter);

        expungeStaleEntries();

        Object cacheKey = CacheKey.valueOf(key, refQueue);

        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        if (valuesMap == null) {
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        // 创建子键并检索缓存
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }
            
            if (factory == null) {
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

            if (supplier == null) {
                supplier = valuesMap.putIfAbsent(subKey, factory);
                if (supplier == null) {
                    supplier = factory;
                }
            } else {
                if (valuesMap.replace(subKey, supplier, factory)) {
                    supplier = factory;
                } else {
                    supplier = valuesMap.get(subKey);
                }
            }
        }
    }

缓存功能主要是通过当前类WeakCache实现的，缓存了Supplier函数式接口。需要获取时调用Supplier的get方法获取。Factory实现了Supplier函数式接口，实现具体代码在Factory类里。

    //使用synchronized加锁，防止多线程并发生成字节码文件
    public synchronized V get() { 
            //从缓存中获取，如果与当前对象不匹配则直接返回
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                return null;
            }

            V value = null;
            try {
                //获取Class对象
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // 加载失败则删除
                    valuesMap.remove(subKey, this);
                }
            }

            assert value != null;


            CacheValue<V> cacheValue = new CacheValue<>(value);

            reverseMap.put(cacheValue, Boolean.TRUE);

            if (!valuesMap.replace(subKey, this, cacheValue)) {
                throw new AssertionError("Should not reach here");
            }

            return value;
        }
    }

这个方法也只是加锁并做了一些判断，真正执行方法在ProxyClassFactory类中。ProxyClassFactory是Proxy的静态内部类，实现了BiFunction。所以接下来重点看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) {
                /*
                 * 校验类加载器能否通过接口名称加载
                 */
                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");
                }
                /*
                 *校验当前类是否接口
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * 校验接口是否重复
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }
            //代理类的包名
            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");
                    }
                }
            }
            
            if (proxyPkg == null) {
                // 为public访问权限的接口生成包名
                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) {
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

这个方法实际上就是生成包名，调用ProxyGenerator的generateProxyClass方法生成字节码文件。具体生成规则过于复杂我们也不需要了解，我们可以保持生成的字节码文件进行查看生成的代理类即可。

在生成代理类之前设置系统属性sun.misc.ProxyGenerator.saveGeneratedFiles值为true

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

再次调用测试方法，即可得到代理类字节码文件

package com.sun.proxy;

import com.proxy.Calculator;
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 Calculator {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;
    //我们自定义的InvocationHandler实现类
    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 int add(int var1, int var2) throws  {
        try {
            return (Integer)super.h.invoke(this, m3, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

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

    //静态代码块中生成每个方法的引用，通过执行InvocationHandler的invoke方法达到代理的目的
    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.proxy.Calculator").getMethod("add", Integer.TYPE, Integer.TYPE);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

至此我们可以清楚的知道，JDK动态代理的实现原理就是通过生成指定接口的代理类进行实现。我们可以将需要增强的功能实现在invoke方法中，然后通过代理类进行调用方法。

因为代理类需要继承Proxy类，java中只能单继承。所以实现JDK动态代理必须通过接口的方式进行实现，被代理的对象需要至少实现一个接口。

最后

以上就是平常小蘑菇为你收集整理的JDK动态代理实现原理的全部内容，希望文章能够帮你解决JDK动态代理实现原理所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。