JDK中的动态代理之一

JDK中的动态代理

       写到代理模式这章，不得不提到JDK中的动态代理，它是java语言自身对动态代理的支持，类似于JDK中在java.util包中提供Observable类和Observer接口提供对观察者模式的语言级支持。关于动态代理的好处可以从网络上流行的<<JAVA中用动态代理类实现记忆功能>>、<<使用JAVA中的动态代理实现数据库连接池>>、<<通过JAVA的动态代理机制控制事务>> 、<<用Java动态代理实现AOP>>……看出动态代理的优点――动态地为软件增加功能。应用的文章很多，出于自身的好奇我们来研究JDK中动态代理的实现吧！这就是本博客所谓的“任何东西只有精通了，才能更好地使用”，有别于所谓的“很好地使用它，然后再去精通它”。下面我们开始对java语言中动态代理的源代码的研究吧！ 

一、动态代理的相关类

       JDK中和动态代理直接相关的主要有InvocationHandler接口和Proxy类。InvocationHandler接口相当于Proxy类的CallBack Interface。

 

       下图为InvocationHandler接口的类图，该接口中仅定义了Object：invoke(Object obj,Method method, Object一个方法。第一个参数proxy一般是指具体的被代理类，即代理模式中的目标对象；method是被代理的方法，args为该方法的参数数组。该接口在动态代理中由客户实现。[] args)

 

三、Proxy类

Proxy 为动态代理类，是动态代理的核心类，其作用类似于代理模式中的代理。从上面的类图可以看出 Proxy 类中包含的全是静态的方法和成员变量，这是一个纯粹的工具类，因此其源代码中含有一个私有的构造器，在某种意义上可以看作为一个单例模式的特殊情形。（原因为： 1. 不能实例化； 2. 提供统一的入口）。这个类中包含很多很有意思的实现，下面我们还是看看其源代码吧！ 

package java.lang.reflect;

import java.lang.ref.*;

import java.util.*;

import sun.misc.ProxyGenerator;            //sun将产生代理对象的类，放在sun.misc包中 

public class Proxy implements java.io.Serializable {                     //实现了Serializable接口，因此可以保存到流中

    private static final long serialVersionUID = -2222568056686623797L;   //序列化时使用的版本号 

         //以下的变量用于代理对象创建时，名称各部分的组合 

         //以下几个成员变量组合在一起，形成被创建的代理对象的名称

         //这些被ProxyGenerator创建的代理对象，以此名字，存入当前Proxy对象内部的cache中

         //被创建代理对象的名称包含3部分：

         //                          1.包名proxyPkg ；2.代理对象的名称前缀；3.代理被创建的数目num;

           //                          该数目表示当前被创建的代理对象是使用ProxyGenerator创建的第n个代理对象

         //下面是代理对象的名称前缀

          private final static String proxyClassNamePrefix = "$Proxy";

         //初始化时，代理被创建的个数为0

         private static long nextUniqueNumber = 0;

         //由于可能有多个客户同时使用ProxyGenerator创建代理对象，因此必须进行同步

         //                                   此同步过程使代理被创建的数目唯一

    private static Object nextUniqueNumberLock = new Object();

    //表示某个代理对象正在被创建

    private static Object pendingGenerationMarker = new Object(); 

    //代理对象实例化时需要的的构造参数

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

    //类转载器的cache

    private static Map loaderToCache = new WeakHashMap(); 

   //所有已经被创建的代理对象的集合，每次要创建新的代理对象，都会先到该集合查找是否存在

   //                  这其实是一个代理对象的缓存

    private static Map proxyClasses =Collections.synchronizedMap(new WeakHashMap()); 

   protected InvocationHandler h;                           //唯一的非静态的成员变量，主要用于protected构造器 

    protected Proxy(InvocationHandler h) {   //protected构造器，给继承提供了可能

                   this.h = h;

    } 

    private Proxy() { }                       //工具类，不能实例化，因此为私有构造器 

         //使用特定的类加载器，加载某个类，从而得到此代理对象的Class

         public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)throws IllegalArgumentException{

                   if (interfaces.length > 65535) {                  //构造器太多，抛出异常

                       throw new IllegalArgumentException("interface limit exceeded");

                   }

                   Class proxyClass = null;                //初始化一个Class

                   //将interface的名字 collect interface names to use as key for proxy class cache */

                   String[] interfaceNames = new String[interfaces.length];

                   Set interfaceSet = new HashSet();          //避免重复

                   for (int i = 0; i < interfaces.length; i++) {

                       String interfaceName = interfaces[i].getName();                  //得到名称

                       Class interfaceClass = null;

                       try {

                                     interfaceClass = Class.forName(interfaceName, false, loader); //使用类装载器转载类

                       } catch (ClassNotFoundException e) {   }

                       if (interfaceClass != interfaces[i]) {            //两者不等抛出异常

                                     throw new IllegalArgumentException(interfaces[i] + " is not visible from class loader");

                       }

                       if (!interfaceClass.isInterface()) {                        //不是接口抛出异常

                                     throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface");

                       }

                       if (interfaceSet.contains(interfaceClass)) {         //已经存在抛出异常

                                     throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());

                       }

                       interfaceSet.add(interfaceClass);                       //不存在则放入hashset中

                       interfaceNames[i] = interfaceName;                  //置换输入中的构造器

                   }       

                   Object key = Arrays.asList(interfaceNames);   //将上面的数组转化为List对象

                   //以上完成对构造器的处理 

                   Map cache;

                   synchronized (loaderToCache) {                               //同步化类装载器的Cache

                       cache = (Map) loaderToCache.get(loader);

                       if (cache == null) {

                                     cache = new HashMap();                       //该Cache以类装载器为key，value也为一个Cache

                                     loaderToCache.put(loader, cache);

                       }

                   }

                   synchronized (cache) {

                      do {

                            Object value = cache.get(key);                         //该Cache以Class数组为key以proxyClass为value

                            if (value instanceof Reference) {

                                proxyClass = (Class) ((Reference) value).get();   // 保存在 Cache 中的 value 为 Reference

                            }

                            if (proxyClass != null) {                                               //代理对象存在

                                return proxyClass;                                             //返回此proxyClass

                            } else if (value == pendingGenerationMarker) {

                                try {

                                               cache.wait();                                   //其它线程正在创建代理对象，则本线程等待

                                } catch (InterruptedException e) {   }

                                continue;

                            } else {

                                cache.put(key, pendingGenerationMarker);

                                break;

                            }

                       } while (true);

                   }         

                   try {

                       String proxyPkg = null;                                               // 代理对象所在的包

                       for (int i = 0; i < interfaces.length; i++) {             //遍历Class数组

                                     int flags = interfaces[i].getModifiers();                //得到Class的修饰符

                                     if (!Modifier.isPublic(flags)) {                     //public的修饰符

                                         String >

                                         int n = name.lastIndexOf('.');

                                         String pkg = ((n == -1) ? "" : name.substring(0, n + 1)); //package名称

                                         if (proxyPkg == null) {

                                                        proxyPkg = pkg;                             //

                                         } else if (!pkg.equals(proxyPkg)) {

                                                        throw new IllegalArgumentException( "non-public interfaces from different packages");

                                         }

                                     }

                       }//for

                       if (proxyPkg == null) {

                                     proxyPkg = "";             // 默认包名

                       }                    

                       {

                                     long num;

                                     synchronized (nextUniqueNumberLock) {                          //同步块

                                         num = nextUniqueNumber++;                                   //每次递增1

                                     }

                                     String proxyName = proxyPkg + proxyClassNamePrefix + num; //名称为三者的组合

                                     //以下是创建ProxyClass的过程

                                     byte[] proxyClassFile =ProxyGenerator.generateProxyClass(proxyName, interfaces);

                                     // 上面是使用 ProxyGenerator 将指定名称代理类的 .class 文件转化为 byte 数组

                                     // 在类加载器中进一步执行此 .class 文件，在 java 语言中经常称 java 为解释型语言

                                     // 字节码就是被解释的中间代码，它是独立于平台的，其执行是在虚拟机上

                                     //                                   有兴趣的朋友多研究研究编译原理、以及虚拟机的实现

                                     //                                   sun 已经将其 Compiler 和 VM 的源代码开源了，有能力可以研究研究

                                    / / 利用刚才产生的 byte 数组，使用类加载器产生此 ProxyClass 

                                     try {

                                               使用类装载器，装载指定名称的代理类

                                         proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);

                                     } catch (ClassFormatError e) {

                                         throw new IllegalArgumentException(e.toString());

                                     }

                       }

                       // 将新创建的ProxyClass放入Chche中

                       proxyClasses.put(proxyClass, null);      

                   } finally {

                       synchronized (cache) {

                                     if (proxyClass != null) {

                                         cache.put(key, new WeakReference(proxyClass));           //将此Renference放入cache中

                                     } else {

                                         cache.remove(key);

                                     }

                                     cache.notifyAll();                    //多线程的wait/notify机制

                       }

                   }

                   return proxyClass;

    }