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