读的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.等等..

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

猜你喜欢