JDK7动态代理源码分析

IObject proxy = (IObject) Proxy.newProxyInstance(IObject.class.getClassLoader(),                                   
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　new Class[]{IObject.class},
                   　　　　　　　　　　　　　　　　　　new DynamicProxyHandler(real) );

使用Proxy类的静态方法newProxyInstance创建一个动态代理类

查看API文档：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException
loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 指派方法调用的调用处理程序 

1、JDK动态代理要求，被代理的必须是个接口，单纯的类则不行，即interfaces必须是接口

2、JDK代理所生成的代理类都会继承Proxy类，同时代理类会实现所有传入的接口列表（即interfaces），因此可以强制类型转换成接口类型。

3、如果非要代理一个没有实现接口的类，同时该类的方法与其他接口的方法相同，则需要利用反射实现

//利用反射获取你想代理的类的方法
Method myMethod = targetClass.getClass().getDeclaredMethod(method.getName(), method.getParameterTypes());
    myMethod.setAccessible(true);

4、newProxyInstance方法相当于getProxyClass方法

Proxy.getProxyClass(loader, interfaces).
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });

源码分析：

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        if (h == null) {
            throw new NullPointerException();
        }

        //拷贝一份所有接口的数组
        final Class<?>[] intfs = interfaces.clone();
        /**
         * 安全管理器主要用来防止恶意攻击，根据java安全策略文件觉得将哪组权限授予类
         * 每个java应用都有自己的安全管理器，
         * 如果要使用，可以在jvm启动时设定-Djava.security.manager选项，还可以同时指定安全策略文件。
         * 如果在应用中启用了Java安全管理器，却没有指定安全策略文件，那么Java安全管理器将使用默认的安全策略，它们是由位于目录$JAVA_HOME/jre /lib/security中的java.policy定义的。
         */
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
        /**
         * 调用getProxyClass0方法拿到代理类的Class对象
         */
        Class<?> cl = getProxyClass0(loader, intfs);

调用getProxyClass0:

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

private static Class<?> getProxyClass0(ClassLoader loader,
                                           Class<?>... interfaces) {
        //如果目标类的接口数大于65535
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }

        // 如果代理类已经在缓存中，则直接取出，否则用ProxyClassFactory创建新代理类
        return proxyClassCache.get(loader, interfaces);
    }

调用WeakCache的get方法：

private final ReferenceQueue<K> refQueue
        = new ReferenceQueue<>();    
    /**
     * K 表示key
     * P 表示parameters
     * V 表示value
     */
    public V get(K key, P parameter) {
        //NullObject判断方法
        Objects.requireNonNull(parameter);
        //清理持有弱引用的WeakHashMap这种数据结构
        expungeStaleEntries();
        //从队列中获取cacheKey
        Object cacheKey = CacheKey.valueOf(key, refQueue);

调用CacheKey的valueOf

java.lang.ref.Reference
Reference(T referent, ReferenceQueue<? super T> queue) {
        this.referent = referent;
        this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }

private static final class CacheKey<K> extends WeakReference<K> {

        // a replacement for null keys
        private static final Object NULL_KEY = new Object();

        static <K> Object valueOf(K key, ReferenceQueue<K> refQueue) {
            return key == null ? NULL_KEY : new CacheKey<>(key, refQueue);
        }

        private final int hash;

        private CacheKey(K key, ReferenceQueue<K> refQueue) {
            super(key, refQueue);
　　　　　　　//返回给定对象的哈希码，
            //该代码与默认的方法 hashCode() 返回的代码一样，无论给定对象的类是否重写 hashCode()。null 引用的哈希码为 0。
            this.hash = System.identityHashCode(key);
        }

ReferenceQueue的源码先暂时不分析，回到WeakCache中get方法

//利用懒加载的方式获取cacheKey对应的Supplier
        ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
        //如果map中不存在cache键值对，则把cacheKey对应的键值对放进map
        if (valuesMap == null) {
            ConcurrentMap<Object, Supplier<V>> oldValuesMap
                = map.putIfAbsent(cacheKey,
                                  valuesMap = new ConcurrentHashMap<>());
            if (oldValuesMap != null) {
                valuesMap = oldValuesMap;
            }
        }

        // create subKey and retrieve the possible Supplier<V> stored by that
        // subKeyFactory.apply调用Proxy中KeyFactory静态类的apply方法
        Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));

subKeyFactory.apply调用Proxy中KeyFactory静态类的apply方法

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

Key1、Key2、KeyX都是Proxy的内部类

/*
     * Key1 and Key2 都是用来给实现了1个或者2个接口的代理类使用
     */
    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();
        }
    }

    /*
     * 用来给实现了3个或3个以上接口的代理类使用
     */
    private static final class KeyX {
        private final int hash;
        private final WeakReference<Class<?>>[] refs;

        KeyX(Class<?>[] interfaces) {
            hash = Arrays.hashCode(interfaces);
            refs = 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;
        }
    }

回到get方法：

//
        Supplier<V> supplier = valuesMap.get(subKey);
        Factory factory = null;

        while (true) {
            if (supplier != null) {
                //调用Factory实现的get方法，返回实现InvokeHandler的类，并包含了所需要的信息
                V value = supplier.get();
                if (value != null) {
                    return value;
                }
            }

            //懒加载构建工厂
            if (factory == null) {
                /**
                 *创建一个工厂
                 key           classloader
                 parameter  interfaces接口
                 subkey     存储interfaces的对象
                 valuesMap     cacheKey键值对
                 */
                factory = new Factory(key, parameter, subKey, valuesMap);
            }

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

调用Supplier子类Factory的get方法：

@Override
        public synchronized V get() {
            // 重新检查supplier
            Supplier<V> supplier = valuesMap.get(subKey);
            if (supplier != this) {
                return null;
            }

            V value = null;
            try {
                //调用Proxy类种ProxyFactoryClass的apply方法，apply才是真正创建代理类的方法
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            // the only path to reach here is with non-null value
            assert value != null;

            // wrap value with CacheValue (WeakReference)
            CacheValue<V> cacheValue = new CacheValue<>(value);

            // try replacing us with CacheValue (this should always succeed)
            if (valuesMap.replace(subKey, this, cacheValue)) {
                // put also in reverseMap
                reverseMap.put(cacheValue, Boolean.TRUE);
            } else {
                throw new AssertionError("Should not reach here");
            }

            // successfully replaced us with new CacheValue -> return the value
            // wrapped by it
            return value;
        }

调用ProxyFactoryClass的apply方法：

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

        //最终动态代理类的名字一般都是$ProxyN (N=0,1,2,3,4,5,6,7,8)
        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) {
                }
                //如果使你自己定义的ClassLoader加载的class与你传入的class不一样，则抛出异常
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * 判断Class对象是否是一个接口
                 */
                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;     // package to define proxy class in

            /*
             * 检查传入的接口里有没有不是public的接口，如果有，这些接口必须在一个包里
             */
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    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 package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            //为生成的代理类选择一个名字 com.sun.proxy $Proxy0
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            //生成代理类字节码
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces);
            try {
                //根据代理类的字节码生成代理类的实例
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {

                throw new IllegalArgumentException(e.toString());
            }
        }
    }

调用ProxyGenerator.generateProxyClass( proxyName, interfaces);生成接口对应的字节码

public static byte[] generateProxyClass(final String name,
                        Class[] interfaces)
    {
    ProxyGenerator gen = new ProxyGenerator(name, interfaces);
    //生成字节码
    final byte[] classFile = gen.generateClassFile();

    if (saveGeneratedFiles) {
        java.security.AccessController.doPrivileged(
        new java.security.PrivilegedAction() {
        public Object run() {
            try {
            FileOutputStream file =
                new FileOutputStream(dotToSlash(name) + ".class");
            file.write(classFile);
            file.close();
            return null;
            } catch (IOException e) {
            throw new InternalError(
                "I/O exception saving generated file: " + e);
            }
        }
        });
    }

    return classFile;
    }

调用Proxy.defineClass0本地方法把字节码生成代理类的实例