读的JDK动态代理源码（代理类）

读的JDK动态代理源码（代理类） 

2010-05-21 11时51分07秒|分类： 设计模式 | 字号 订阅
读源码，怕过两天又忘记了，还是记录下吧......

动态代理最重要的实现就是Proxy.newInstance，那我们当前直接看这个方法扩展功能

（ClassLoader的加载，
       类<？> []接口，
       InvocationHandler的公共静态对象newProxyInstance  IllegalArgumentException     {  如果（H == NULL）{      抛出NullPointerException异常（）/ /如果InvocationHandler的为空，抛异常  }





/
  * 查找或生成指定的代理类，这个方法里最主要的地方在这里，它直接透过调用。

CL = getProxyClass（装载机，接口）;

/
  * 调用指定的调用其构造  {      构造函数的利弊= cl.getConstructor（constructorParams）;      cons.newInstance回报（对象）（新的Object [] {H}）;  }（NoSuchMethodException E）{      扔：新InternalError（e.toString（））;  }（IllegalAccessException E）{      扔新InternalError（e.toString（））;  渔获（InstantiationException E）{      扔：新InternalError（e.toString（））;  }渔获（InvocationTargetException E）{      扔：新InternalError（e.toString（））;      } }














上面的方法,除了最重要的getProxyClass,其他都很容易理解.,那么下面开始读getProxyClass方法

<> getProxyClass公共静态类（ClassLoader的装载机，
                                         <>类...接口）
抛出IllegalArgumentException
    {
如果（interfaces.length> 65535）{
     抛出新IllegalArgumentException（“接口超限”）; / / JDK的想的果然比较到位，连界面传动的太多都想到了..〜！〜
}

类proxyClass = NULL; / /这个就是最后要生成的二进制码，首先初始化一下

/ *收集接口名称作为键使用缓存代理类* /
的String [] interfaceNames =新的String [interfaces.length]; / /这个存放的是对应的接口的名字......

设置interfaceSet =新的HashSet（）/ / 这个HashSet的是为了检测接口重复记录的。

为（int i = 0;我<interfaces.length;我+）{
     /
      * 检查类加载器可以解决这个名字
      *接口的同一类对象
      * /
     字符串InterfaceName中=接口[我]的getName（）。
     类interfaceClass = NULL;
     尝试{
  interfaceClass = Class.forName的（InterfaceName中，虚假，装载机）; / /建立对应接口的二进制码，第二个参数虚假表示，不需要初始化
     }（ClassNotFoundException异常）{
     }
     （interfaceClass =接口[I]）  新IllegalArgumentException（      接口[I] +“是从类加载器中不可见”）;      }



     /
      * 验证的Class对象实际上代表
      *接口。
      * /
     如果（！interfaceClass.isInterface（））  新IllegalArgumentException（      interfaceClass.getName（）+“不是一个接口”）;      }



     /
      * 确认该接口是不是      （interfaceSet.contains（interfaceClass））{   抛出新IllegalArgumentException（       “ 反复接口：”interfaceClass.getName（））;      }      interfaceSet.add（interfaceClass）;






     interfaceNames [I] = InterfaceName中; / /这句就是把每个接口名放到interfaceNames的数组里......

/
  * 使用
  *键缓存（而不是他们的一类代理类
  *对象）作为代理接口的字符串表示形式是足够的，因为我们需要代理
  *接口是通过提供的名称解析
  *类加载器，它具有的优点是使用一个字符串
  类*表示一个隐式的弱
  *参考类。
  * /
对象的关键=

/ *
  查找或创建代理类的类加载器缓存。
  * /
地图缓存; / /放缓存的地图
同步（loaderToCache）     （地图）loaderToCache.get“（装载机）;      （缓存== NULL）{   缓存=新的HashMap（）;   loaderToCache.put（装载机，高速缓存）;      }      /       * 为这个时间      *，这种映射将继续有效方法，没有进一步的同步，因为映射      *只会被删除，如果类装载器无法访问。      * /  }











/
  * 查找接口的代理类中使用缓存列表
  *键。此查找将导致三种可能的
  *种值之一：
  *空，如果目前还没有名单
  *接口的代理类的类加载器，
  *的pendingGenerationMarker的对象，如果一个代理类
  *列表接口正在生成，
  *或弱引用类对象，如果一个代理类
  *接口名单已经产生。
  * /
同步（缓存）{
     /
      * 请注意，我们不必担心收割缓存
      *清除弱引用条目，因为如果一个代理类
      *已被垃圾收集，它的类装载器将一直
      *垃圾收集一样，所以整个高速缓存将被收割
      从loaderToCache地图*。
      * /
     {
  Object值=   （参考值的instanceof）{       proxyClass =（A类）（（参考）  （proxyClass = NULL）{       / /代理类已经产生：返回      返回proxyClass，;   }否则如果（值== pendingGenerationMarker）{ / /这里的pendingGenerationMarker是一个静态常量，表示新的对象（）JDK给出的解释。是，如果代理正在建立，那么等待他       / /代理类，正在生成：等待它      试图{    cache.wait（）;       }的catch（InterruptedException的E）{    /     * 类的一代，我们正在等待为    * 应采取1小，时间有限，所以我们可以放心地忽略    *线程中断。    * /       }       继续;   }否则{       /        *已没有这个接口列表的代理类       *产生或正在产生，所以我们会去和       *生成现在标记为挂起代       * /       中cache.put（关键，pendingGenerationMarker）; / /如果缓存里获取到：的对应于键的值是NULL，那么，就建立一个对象的对象放进去上面说了， pendingGenerationMarker =新的对象（）;       休息;        } } ，而（真）;  }





























尝试{
     弦乐proxyPkg = NULL; / /包中定义代理类，这个是代理类的包名

     / *
      记录
      *代理类将在同一个包中定义的一个非公开的代理接口的包。验证
      *所有非公开的代理接口在同一个包
      *
     / （I = 0;我<interfaces.length;我+）{
  INT标志。  （！Modifier.isPublic（标志））{ / /如果不是公共的接口......


      名=接口[I]的getName（）;
      整数n = name.lastIndexOf（'。'）;
      弦乐PKG =（（N == -1）“：name.substring（0，N + 1））; / /注意这里的N +1的，其实是包括“。”的..比如com.cjb.proxy.Proxy ..它返回的就是“com.cjb.proxy。”注意最后的那个点

      如果（proxyPkg == NULL）{
   proxyPkg = PKG;
      } {（pkg.equals（proxyPkg）！）
   抛出新IllegalArgumentException（
       “ 非公开的接口，从不同的包”）;
      }
 
     } }

     如果（proxyPkg == NULL）{/ /如果没有非公有制代理接口，这里可以看到，如果是公共的接口，对应代理类的包名就是“”，也就是没有包名
  proxyPkg =“”; / /使用未命名的包
     }

     {
  / *
   。*选择生成代理类的名称
   * /
  长民;
  同步（nextUniqueNumberLock）{
      NUM =   proxyName = proxyPkg + proxyClassNamePrefix + NUM; / / proxyPkg，什么之前产生的包名，proxyClassNamePrefix $ Proxy1美元Proxy2发出Proxy3美元一直在增长的这样的话，就避免了重复。   /    * 验证类加载器尚未   *定义类与所选择的名称。   * /






  /
   * 生成指定的代理 ，proxyClassFile = ProxyGenerator.generateProxyClass（      proxyName接口）;   尝试{       proxyClass = defineClass0（装载机proxyName，   proxyClassFile，0，proxyClassFile.length）;   }（ClassFormatError E）{       /        * 这里一个ClassFormatError指（限制在错误       *代理类生成的代码）有一些其他       *无效方面提供的代理参数       *类的创建（如虚拟机的限制       。*超过）       * /       抛出新IllegalArgumentException（e.toString（））;        } }      / /添加到设置的所有生成的代理类isProxyClass，     proxyClasses.put（proxyClass，空）;

 

















} {
     /
      * 我们必须清理“等候的一代”的代理状态
      *级高速缓存条目，不知何故。如果成功
      *生成一个代理类，存储在缓存中（弱引用）;
      *否则，删除保留项目。在所有情况下，通知
      此缓存中保留条目*所有服务员。
      * /
     同步（缓存）{
  如果（proxyClass = NULL）{
      中cache.put（关键，新的WeakReference（proxyClass））;
  } {
      cache.remove（键）;
  }
  cache.notifyAll（）;
    
} }
返回proxyClass;
    }

可以看到,我们想看的,最重要的生成二进制码的方法,是native的..读了这么多源码,都是一些前期处理.关键的地方不知道..当然,虽然没看到关键的地方,但是对于它前面的处理的学习,也是非常有用的..看看JDK是怎么处理重名问题的,怎么处理cache.等等..