动态代理原理

简介

java.lang.reflect.Proxy是整个jdk中实现动态代理的核心 类，本文主要介绍Proxy类的实现，关于Proxy类的使用请自行查阅其他资料。

Field

• constructorParams：构造函数的参数，用于代理类的核心的逻辑实现，关于InvocationHandler这个接口的介绍不是本文的重点，此处不做介绍。

private static final Class<?>[] constructorParams =
    { InvocationHandler.class };

• proxyClassCache： 代理类的缓存，此类是一个二级缓存的实现，利用WeakReference的特性，当内存占用过高的时候会JVM自动进行回收缓存中的数据。

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

• h： InvocationHandler接口，用于此代理实例的调用处理程序。

Inner Class

• KeyFactory：顾名思义，缓存代理的key的工厂实现，此类仅一个方法，实现了BiFunction接口，具体代码如下

private static final class KeyFactory
    implements BiFunction<ClassLoader, Class<?>[], Object>
{
    @Override
    public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
        switch (interfaces.length) {
            case 1: return new Key1(interfaces[0]); // the most frequent
            case 2: return new Key2(interfaces[0], interfaces[1]);
            case 0: return key0;
            default: return new KeyX(interfaces);
        }
    }
}

由以上代码可见，该类的实现分为委托给了Key0,Key1,Key2,KeyX这四个类实现，其中key0是一个Object，其他的类Key1,Key2,KeyX则是分别用不同的实现对hashcode和equals方法进行了不同的实现，大同小异。这里则分别简单的做一下解释。

private static final class Key1 extends WeakReference<Class<?>> {
    private final int hash;
​
    Key1(Class<?> intf) {
        super(intf);
        this.hash = intf.hashCode();
    }
​
    @Override
    public int hashCode() {
        return hash;
    }
​
    @Override
    public boolean equals(Object obj) {
        Class<?> intf;
        return this == obj ||
               obj != null &&
               obj.getClass() == Key1.class &&
               (intf = get()) != null &&
               intf == ((Key1) obj).get();
    }
}

private static final class Key2 extends WeakReference<Class<?>> {
    private final int hash;
    private final WeakReference<Class<?>> ref2;
​
    Key2(Class<?> intf1, Class<?> intf2) {
        super(intf1);
        hash = 31 * intf1.hashCode() + intf2.hashCode();
        ref2 = new WeakReference<Class<?>>(intf2);
    }
​
    @Override
    public int hashCode() {
        return hash;
    }
​
    @Override
    public boolean equals(Object obj) {
        Class<?> intf1, intf2;
        return this == obj ||
               obj != null &&
               obj.getClass() == Key2.class &&
               (intf1 = get()) != null &&
               intf1 == ((Key2) obj).get() &&
               (intf2 = ref2.get()) != null &&
               intf2 == ((Key2) obj).ref2.get();
    }
}

private static final class KeyX {
    private final int hash;
    private final WeakReference<Class<?>>[] refs;
​
    @SuppressWarnings("unchecked")
    KeyX(Class<?>[] interfaces) {
        hash = Arrays.hashCode(interfaces);
        refs = (WeakReference<Class<?>>[])new WeakReference<?>[interfaces.length];
        for (int i = 0; i < interfaces.length; i++) {
            refs[i] = new WeakReference<>(interfaces[i]);
        }
    }
​
    @Override
    public int hashCode() {
        return hash;
    }
​
    @Override
    public boolean equals(Object obj) {
        return this == obj ||
               obj != null &&
               obj.getClass() == KeyX.class &&
               equals(refs, ((KeyX) obj).refs);
    }
​
    private static boolean equals(WeakReference<Class<?>>[] refs1,
                                  WeakReference<Class<?>>[] refs2) {
        if (refs1.length != refs2.length) {
            return false;
        }
        for (int i = 0; i < refs1.length; i++) {
            Class<?> intf = refs1[i].get();
            if (intf == null || intf != refs2[i].get()) {
                return false;
            }
        }
        return true;
    }
}

• ProxyClassFactory： 顾名思义， 代理类的生产工厂类，用于生成代理类，此类也是实现了BiFunction,技能一个apply方法，最终根据ClassLoader,Interface,proxyName参数调用java.lang.reflect.Proxy#defineClass0这个本地方法生成代理类。

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的代理接口的包，以至于代理类的定义是相同的包，验证所有的非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));