1、sax、dom是两种对xml文档进行分析的方法（没有具体的实现，只有接口）
所以不是解释器，如果光有他们，你是完成不了对xml文档的处理的。
sax的包是org.xml.sax
dom的包是org.w3c.dom
包的名称很重要，它有助于你理解他们之间的关系。

2、jaxp是api，他封装了sax\dom两种接口。并在sax\dom的基础之上，作了一套比较简单的api以供开发人员使用。
jaxp的包是javax.xml.parsers
可以看看jaxp的源文件，它的文件中包含了对sax或者dom的引用（import）
jaxp也不是具体的实现，他只是一套api。如果你仅仅有jaxp那是无法工作的
（其实jaxp只是完成对sax、dom的包装，生成了DocumentBuilderFactory\DocumentBuilder
和SAXParserFactory SAXParser。也就是设计模式中的工厂模式，他的好处就是具体的对象（ 解释器）建立由子类完成）

3、xerces解释器（号称地球上最快的xml解释器）
在xerces 中对jaxp中定义的SAXParser SAXParserFactory DocumentBuilder DocumentBuilderFactory进行了继承（extends）对应SAXParserImpl SAXParserFactoryImpl DocumentBuilderImpl DocumentBuilderFactoryImpl
这就是为什么你的classpath中只要有xerces.jar（其中包含了sax dom jaxp ）和 xercesImpl.jar就可以的原因了.

4、什么时候可以用别的解释器 比如crimson呢
他也是和xerces一样 是解释器，很简单，用crimson.jar 替代xercesImpl.jar

5、jdom和dom4j
 
W3C 的DOM标准API难用的让人想撞墙，于是有一帮人开发Java专用的XML API目的是为了便于使用，这就是jdom的由来，开发到一半的时候，另一部分人又分了出来，他们有自己的想法，于是他们就去开发dom4j，形成了今天 这样两个API，至于他们之间的性能，jdom全面惨败，dom4j大获全胜。我觉得jdom和dom4j就相当于sax/dom+jaxp，具体的解释 器可以选择。

第二：再介绍一下，dom,sax,jdom,dom4j的技术特点：

1: DOM
DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何 工作。由于它是基于信息层次的，因而 DOM 被认为是基于树或基于对象的。DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下 导航，而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单得多。
　　另一方面，对于特别大的文档，解析和加载整个文档可能很慢且很耗资源，因此使用其他手段来处理这样的数据会更好。这些基于事件的模型，比如 SAX。

2:SAX
这种处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数 据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX 还比它的替代者 DOM 快许多。

3:　选择 DOM 还是选择 SAX ？
　　对于需要自己编写代码来处理 XML 文档的开发人员来说，选择 DOM 还是 SAX 解析模型是一个非常重要的设计决策。
　　DOM 采用建立树形结构的方式访问 XML 文档，而 SAX 采用的事件模型。
DOM 解析器把 XML 文档转化为一个包含其内容的树，并可以对树进行遍历。用 DOM 解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用 DOM 解析器的时候需要处理整个 XML 文档，所以对性能和内存的要求比较高，尤其是遇到很大的 XML 文件的时候。由于它的遍历能力，DOM 解析器常用于 XML 文档需要频繁的改变的服务中。
　　SAX 解析器采用了基于事件的模型，它在解析 XML 文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX 对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。但用 SAX 解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

4:jdom http://www.jdom.org
JDOM 的目的是成为 Java 特定文档模型，它简化与 XML 的交互并且比使用 DOM 实现更快。由于是第一个 Java 特定模型，JDOM 一直得到大力推广和促进。正在考虑通过“Java 规范请求 JSR-102”将它最终用作“Java 标准扩展”。从 2000 年初就已经开始了 JDOM 开发。
　　JDOM 与 DOM 主要有两方面不同。首先，JDOM 仅使用具体类而不使用接口。这在某些方面简化了 API，但是也限制了灵活性。第二，API 大量使用了 Collections 类，简化了那些已经熟悉这些类的 Java 开发者的使用。
JDOM 文档声明其目的是“使用 20%（或更少）的精力解决 80%（或更多）Java/XML 问题”（根据学习曲线假定为 20%）。JDOM 对于大多数 Java/XML 应用程序来说当然是有用的，并且大多数开发者发现 API 比 DOM 容易理解得多。JDOM 还包括对程序行为的相当广泛检查以防止用户做任何在 XML 中无意义的事。然而，它仍需要您充分理解 XML 以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。这也许是比学习 DOM 或 JDOM 接口都更有意义的工作。
　　JDOM 自身不包含解析器。它通常使用 SAX2 解析器来解析和验证输入 XML 文档（尽管它还可以将以前构造的 DOM 表示作为输入）。它包含一些转换器以将 JDOM 表示输出成 SAX2 事件流、DOM 模型或 XML 文本文档。JDOM 是在 Apache 许可证变体下发布的开放源码。

5: DOM4J   http://dom4j.sourceforge.net/
虽然 DOM4J 代表了完全独立的开发结果，但最初，它是 JDOM 的一种智能分支。它合并了许多超出基本 XML 文档表示的功能，包括集成的 XPath 支持、XML Schema 支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过 DOM4J API 和标准 DOM 接口具有并行访问功能。从 2000 下半年开始，它就一直处于开发之中。
　　为支持所有这些功能，DOM4J 使用接口和抽象基本类方法。DOM4J 大量使用了 API 中的 Collections 类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然 DOM4J 付出了更复杂的 API 的代价，但是它提供了比 JDOM 大得多的灵活性。
　　在添加灵活性、XPath 集成和对大文档处理的目标时，DOM4J 的目标与 JDOM 是一样的：针对 Java 开发者的易用性和直观操作。它还致力于成为比 JDOM 更完整的解决方案，实现在本质上处理所有 Java/XML 问题的目标。在完成该目标时，它比 JDOM 更少强调防止不正确的应用程序行为。
　　DOM4J 是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的 Java 软件都在使用 DOM4J 来读写 XML，特别值得一提的是连 Sun 的 JAXM 也在用 DOM4J。

最后：我建议用dom4j

如果只说一样最重要的事情，就是ant-contrib的<if> 和 <for>节点，使Ant 拥有了完整的编程能力。

1. 变量

Ant里的变量有个诡异的特性----一旦被赋值就不会改变，这个特性有时候帮助很大，有时候让人很苦恼，一定要注意。另一样要注意的是，Ant里的变量和其他语言的变量一样，有可效范围。

1.由命令行赋值

ant build.xml -Dtomcat.home=foo

2.与用户交互输入--Input task

<input message="请选择一个Target "
validargs="compile,jar,test"
addproperty="my.input"/>

3.从propertis文件读取并存盘 -- propertyfile task

<propertyfile file="my.properties">
<entry key="springside.home" default="."/>
</propertyfile>

如果my.properties 不存在，生成my.properties文件，springside.home=.。有一个特别有用的地方：有些properties文件的属性每个开发者都不同，不想放入svn，但又想初始化数值，可以用该命令。

<propertyfile file="my.properties">
<entry key="springside.home" value="....."/>
</propertyfile>

重新写入配置文件。

2. 流程控制

如果没有ant-contrib 贡献的<if> 和<for>节点，Ant的可编程性是极低极低的。

2.1 if task

ant原来可以在target级进行if判断(unless,if 属性)，但实在太不方便了。

2.2 Conditions

但Ant预先封装的一堆condition很是很方便的。这些condition完全从实际出发，包括文件是否存在，http://localhost:8080是否连通都可以作为条件，见Ant的参考手册。

2.3 For task

支持"a,b,c,d" 字符串数组的循环与文件目录，Fileset的循环。

2.4 Parallel task

Parallel非常有用，比如我想一边开tomcat，一边做别的，就需要使用它，否则就只有用spawn=true属性把tomcat放在后台运行。spawn有很多不好的地方，比如不能即时在console看到信息，停止ant运行不能把tomcat关掉等。

Parallel相当于一个容器，放在里面的每个task都会被并行执行。如果想把某几个task顺序执行，用相当于()的Sequential task 包起来。

2.5 Waitfor task

暂停ant执行直到条件符合，比如<waitfor><http url=http://localhost:8080/></waitfor>就会等待tomcat启动后才会继续往下执行。Macrodef task

3. 代码封装

ant 代码最基本的封装是

1. ant task：调用其他脚本的任务，可设定dir 与是否继承本脚本的变量。

2. antcall task：调用本脚本内其他task，可设置参数。

3. import task ：就像其他语言的include一样，引入其他脚本内容到本脚本里。

1. AntFetch, AntCallBack task

ant-contrib贡献，对应于Ant 与 AntCall。原版只能向被调用函数传递变量，函数执行后没办法return 值。antcallback的语法如下
<antcallback target="mytarget" return="myresult1,myresult2"/>

2. Macrodef task

作为最小的封装单位，与以<target>封装再<antcall target="xxx">调用差不太远，细微之处自行体验了。个人比较喜欢用macrodef。

3. Java task 与 Exec task 直接执行Java类或程序

注意执行目录的定义。另在Windows下如果要直接运行dos窗口中的命令，以下指令启动默认浏览器访问localhost：

<exec executable="cmd.exe">
<arg line="/c start http://localhost:8080"/>
</exec>

4. 扩展Ant的Task

扩展ant task很简单，实现execute() 方法执行task，实现setter接口让ant框架执行属性注入。继承Task 获得一些ant的能力，比如查询某个变量的值。

稍微有点麻烦的是多层嵌套属性的注入。详细请看http://ant.apache.org/manual/developlist.html

SpringSide 2.0 里很简单的实现了一个XML File Merge的task，见XmlMergeTask.java。

蛋蛋 说扩展Ant的最方便的方法还是在ANT里嵌套脚本。导入BSF库以后，你就可以用BSF支持的脚本语言了(见Script Task)。接下来有机会尝试一下。

5. 文件操作

刚好springside里进行了比较多的文件操作，随便记一下。

replace 与 copy 时加入filter, 都可以进行字符串替换.

concat 在文件末添加其他文件的内容。

好困，很多东西没写详细，明天再补充。

题外话，Ant 完整演示了如何编写XML式的代码，虽然对于开发人员来说XML编码非常麻烦，远远没有Ruby的rake以ruby代码本身来构建系统清晰，但对于IDE，特别是希望图形化编程的IDE来说，XML比普通代码要容易渲染得多，所以普元EOS的图形化编程也是序列成XML代码。再另外，Ant的task 和 普元的构件也有相似。

名词界定

Iterator Pattern 也叫做 Generator, Sequence, Stream 等。 Java 里面有 Iterator Interface ，大家应该比较熟悉，不再赘述。

完整的具有 Visitor 和 Visited (Visitable) 两个部分的 Visitor Pattern 的使用并不广泛。

简单的只有 Visitor 部分的 Simple Visitor Pattern 比较常见，比如 Callback, Interceptor, Filter ， Functor, Selector, Extractor 等，都可以看作是 Simple Visitor Pattern 。

它们都只有 Visitor 部分，而没有 Visited 部分。或者说他们的 Visitor 需要处理的 Visited Object 通常只有一种通用数据类型，所以不需要专门提出来一个 Visited Interface -- accept(visitor) 。

这种情况和 Observer Pattern 很相似。不过这也不奇怪，很多 Design Pattern 都是非常类似的，有的几乎只有名字不同。

为了避免不必要的口舌之争后，这么说吧， Visitor 和 Observer 的侧重点不同。

Visitor 一般来说是 Visit 一个集合，通常在一个遍历算法中密集完成，获取的信息（ Node Object ）之间一般都有密切关联，比如父子关系，兄弟关系。

而 Observer Patten 则是监听一个长期运行的系统，零零散散地不定期地运行，获取的信息之间不存在密切联系，或者说，没什么关系。比如订阅的报纸到了，订购的牛奶到了。

费了半天口舌，澄清各种可能的误会，我们继续 Iterator vs Visitor 之旅。

Iterator Pattern 和 Simple Visitor Pattern 处理的问题领域几乎是重合的。它们面对的共同问题模型的组成部分如下：

(1) 有一个算法 Algorithm ，通常是遍历算法（ Traversal ）。而且通常是复杂的数据结构， Tree 、 Graph 等结构的遍历算法。

(2) 算法的使用者，需要和算法的每一步遇到的 Node Object 进行交流。

所不同的是，

Iterator 是一种主动模型， Pull 模型， Ask and Get 。 Iterator 听候用户的调遣。

Vistor 是一种被动模型， Push 模型， Plugin / callback 模型， Push and Pray and Wait 。 Visitor 听候算法的调遣。

Iterator 相当于算法公司的一名业务人员，代表公司和用户打交道。用户并不需要深入到算法公司内部。

而 Visitor 相当于用户派出的代表，深入到算法公司内部，由算法公司安排访问行程。

Iterator 的典型使用方法是：

iterator = traversal.getIterator();

item = iterator.next();

do some thing with item

Vistor 的典型使用方法是

visitor = new Visitor(){

  .. visit(item) { do something with item }

};

traversal.traverse(visitor);

一个典型的例子是 StAX 和 SAX 和两种操作 XML 的方式。

（参见 http://www.xmlpull.org/ ，关于 StAX 的典型用法，网上有些经典文章，本文不再赘述。请使用 StAX XMLPull XML 等关键字进行搜索）

StAX 就是一个典型的 Pull Model, Iterator Pattern 。

而 SAX 是 Push Model, Simple Visitor Pattern (Event Listener) 。（如果较真，你当然可以把它叫做 Oberver Pattern ）。

另外一个有趣的例子是 DOM Traversal 。

W3 的 DOM Level 2 规范定义了 DOM Traversal 。

http://www.w3.org/TR/2000/REC-DOM-Level-2-Traversal-Range-20001113/traversal.html

DocumentTraversal, TreeWalker, NodeIterator, NodeFilter 。

DOM Traversal 主要是一个 Iterator Pattern ， TreeWalker, NodeIterator 都是 Iterator ；但 DOM Traversal 同时也是一个简单的 Visitor Pattern —— NodeFiter 可以作为简单的 Visitor 被注入到 Traversal 算法里面，对遇到的每个 Node 进行过滤。

不过，这个 NodeFiter 的 method name 比较有意思，叫做 accept 。而我们知道 Visitor Pattern 的 Visited Object 具有一个 accept 方法。不过，不要误会。这个 NodeFilter 仍然是一个 Visitor 。这里的 Accept 的意思就是 Intercept, Filter 。

用法是这样。

NodeIterator iterator = DocumentTraversal.createNodeIterator(…NodeFilter …)

按照我的设想，这个 API 设计，还可以有另外的思路。把 Filter 加在 Iterator 身上，而不是加在 Traversal 算法身上。因为 Iterator Pattern 很容易地做到这一点。

NodeIterator iterator = New FilteredIterator(

   DocumentTraversal().createNodeIterator() , … NodeFilter …);

这样， DOM Traversal 就是一个纯粹的 Iterater Pattern 了。

特性比较

Iterator 属于问答模式，或者说消费者 / 生产者模式。

如果消费者不问不要，生产者就不答不给。 Iterator 的使用者完全掌握了主动权，是控制舞步节奏的领舞者，随时可以中止这场问答游戏。

Iterator 的用法本身就是 Lazy 的，一问一答，遍历算法停在那里恭候 Iterator 使用者的调遣。

Visitor 则完全是被动的， Visitor 的提供者 / 使用者把 Visitor 扔到 Traversal 算法里面，然后运行算法，同时祈祷并等候算法的完成（ Push and Wait ），完全失去了控制权，只能等待算法整个完成或者中止，才能重新拿到控制权。

Vistor 的用法很难做到 Lazy ，算法必须提供一些机制，接受 Visitor 每一步调用发出的指令，进行相应的策略选择。

换句话说， Visitor Pattern 里面的算法必须做出相应的 Lazy 支持，而且 Visitor 必需积累前面步骤的状态，然后判断这次调用中发出什么样的指令。

比如，有这样一个需求：遍历一棵树，搜集到前 5 个名字是 Apple 的 Node 。然后返回这 5 个 Node 。假设树遍历算法已经有了。

这时候采用 Iterator Pattern 视线起来很容易。不再多说。

Visitor Pattern 则需要：

Vistor 使用一个集合来保存每次遇到的名字是 Apple 的 Node ，每次都判断是否已经找到了 5 个，如果已经找到，那么发出一个 Stop Signal 给算法。

如果遍历算法不接受这种指令怎么办？

只好等待算法完成。或者实在等不及，预计到后面还有上万个 Node 需要遍历，那么就干脆

throw new RuntimeException(),  throw new Throwable() 。

也许算法并没有聪明到捕获这些 Exception 。那么这个 Trick 就成功了。外面使用一个 Try Catch 捕获这个 Exception 。不过，这是 Very Very Bad Smell 。

Iterator 的应用场景是这样：

我 在商品定购目录上看到一个公司有我感兴趣的产品系列。于是我打电话给该公司，要求派一个销售代表来。销售代表上门之后，从包里拿出一个一个的产品给你看， 我看了几个，没什么满意的，于是打了个哈欠说，今天就先到这里吧，下次再说。打发了销售代表，我就转身去做自己的事情了。

我的地盘，我做主。这就是 Iterator Pattern 的理念。

Vistior 的应用场景是这样：

我 在商品定购目录上看到一个公司有我感兴趣的产品系列。于是我上门拜访该公司，公司给我安排了一场产品性能展示，我看了几个之后，没有什么满意的，于是我 说，我肚子疼，想先回去了。遇到好心的公司代表，当然说，身体要紧，慢走。遇到固执的公司代表，一定会说，对不起，我们公司有自己的工作流程，完成产品演 示之前，产品厅的门锁是打不开的。我只好勃然大怒，吵吵嚷嚷（ throw exception ），期待能够杀出重围，这时候，假设该公司的保安系统反映比较灵敏（ try catch every visitor exception ），就会有几个保安跑过来，把我按在椅子上继续听讲。

入乡随俗，客随主便。别人的地盘，别人做主。这就是 Visitor Pattern 的理念。

Iterator Pattern 的优势当然不仅如此。这只是个特殊的例子。

更常见的是， Iterator Pattern 能够支持基于 Iterator 的很多算法。

比如， Functional Programming 的 Map, Reduce, Filter 等函数都是接受一个 Iterator (Sequence, List, Stream 等 ) 。 Map, Filter 等函数还可以组合成一个新的 Iterator 。这个组合可以一直下去。

当然， Visitor 也是可以组合的。但是限制严格，缺乏扩展性。

比如这样一个需求：

有 T1 和 T2 两棵树。首先遍历 T1 的 10 个 Node ，如果发现 Apple ，那么摘下来，然后继续遍历，如果 10 步都没有发现 Apple ，那么切换到 T2 ；遍历 T2 的规则也是如此， 10 步之内发现目标，就继续，否则就切换到 T1 。

Iterator Pattern 实现起来很简单。相当于我是买方，情势是买方市场，我可以让两个公司的销售代表同时到我的公司来，我可以同时接待他们，让他们各自按顺序展示自己的产品。

Visitor Pattern 怎么做？情势是卖方市场，我巴巴地跑上门去，看 T1 公司的产品展示，看了 10 个之后说，请送我到 T2 公司的产品展示现场，我看 10 个之后，再回来。

一个用户可以同时使用多个算法的 Iterator ；但是用户的一个 Visitor 只能同时进入一个算法。

这就是两者核心理念的不同。

实现难度

读者说了， Iterator 这么方便，你就使用 Iterator 好了，说这么多干什么。

如果别人提供了 Iterator ，我当然会使用。

现在的问题是，假设你是算法公司的成员。你是提供 Visitor Pattern 的 API ，还是 Iterator Pattern 的 API ？

Visitor Pattern 的实现比较简单。自己知道自己公司的内部组织结构，一个一个的遍历，并传递给 Visitor 就行了。

Iterator Pattern 的实现难度，可以说，那是相当的大。

内部数据结构简单的数组、链表好说，做一个类似于 Closure, Context, Continuation 的保存了当前调用步骤（数组索引，或者当前指针）和调用环境（内部数据集）的结构，返回给用户就可以了。用户每次调用 iterator.next ， iterator 就把索引或指针向后移动一下。

如果是内部数据复杂的 Tree, Graph 结构，就相当复杂了。比如是遍历一棵树，而且这棵树的 Node 里面没有 Parent 引用，那么 Iterator 必须自己维护一个栈把前面的所有的 Parent Node 都保存起来。当用户调用 iterator.next 的时候， iterator 就必须检查自己当前的状态，如果所有的 Child Node 都走完了，那么就要返回到上面的 Parent ，继续检查。

而在 Visitor Pattern 里面，这个算法的实现简直是小菜一碟，只要一个简单的递归就够了。计算机会自动帮你分配和管理运行栈，保存前面的 Parent Node ，执行返回的时候，这个 Parent Node 又自动交还给你。

Coroutine

有没有简单的方法来实现 Iterator Pattern API 呢？如同实现 Visitor Pattern API 那样容易？

幸福得象花儿一样。简单得像 Visitor 一样。能不能那样？

聪明的人们把目光转向了 Coroutine 。

Coroutine 本来是一个通用的概念。表示几个协同工作的程序。

比如，消费者 / 生产者，你走几步，我走几步；下棋对弈，你一步我一步。

由于协同工作的程序通常只有 2 个，而且这两个程序交换的数据通常只有一个。于是人们就很容易想到用 Coroutine 来实现 Iterator 。

这里面 Iterator 就是 Coroutine 里面的生产者 Producer 角色，数据提供者。所以，也叫做 Generator 。

每次 Iterator 程序就是等在那里，一旦用户（消费者 Consumer 角色）调用了 iterator.next, Iterator 就继续向下执行一步，然后把当前遇到的内部数据的 Node 放到一个消费者用户能够看到的公用的缓冲区（比如，直接放到消费者线程栈里面的局部变量）里面，然后自己就停下来（ wait ）。然后消费者用户就从缓冲区里面获得了那个 Node 。

这样 Iterator 就可以自顾自地进行递归运算，不需要自己管理一个栈，而是迫使计算机帮助它分配和管理运行栈。于是就实现了幸福得像花儿一样，简单得像 Visitor 一样的梦想。

比如，这样一段代码，遍历一棵二叉树。

public class TreeWalker : Coroutine {
    private TreeNode _tree;
    public TreeWalker(TreeNode tree) { _tree = tree; }
    protected override Execute() {
        Walk(_tree);
    }
    private void Walk(TreeNode tree) {
        if (tree != null) {
            Walk(tree.Left);
            Yield(tree);
            Walk(tree.Right);
        }
    }
}

其中的 Yield 指令是关键。意思是，首先把当前 Node 甩到用户的数据空间，然后自己暂停运行（类似于 java 的 thread yield 方法或者 object.wait 方法），把自己当前运行的线程挂起来，这样虚拟机就为自己保存了当前的运行栈（ context ）。

有人说，这不就是 continuation 吗？

对。只是 Coroutine 这里多了一个产生并传递数据的动作。

实现原理如果用 Java Thread 表示大概就是这样。当然下面的代码只是一个示意。网上有具体的 Java Coroutine 实现，具体代码我也没有看过，想来实现原理大致如此。

public class TreeIterator implements Iterator{

   TreeWalker walker;

    // start the walker thread ..

   Object next(){

     walker.notify();

     // wait for a while so that walker can continue run

     return walker.currentNode;

   }

}

class TreeWalker implements Runnable{

    TreeNode currentNode;
   

TreeWarker(root){ 

    currentNode = root;

}

void run(){

  walk(curentNode);

}

private void Walk(TreeNode tree) {
        if (tree != null) {
            Walk(tree.Left);

currentNode = tree;

this.wait();

Walk(tree.Right);
        }
    }
}

我们看到， Iterator 本身是一个 Thread ，用户也是一个 Thread 。 Iterator Thread 把数据传递给 User Thread 。

说实话，我宁可自己维护一个 Stack ，也不愿意引入 Coroutine 这类 Thread Control 的方式来实现 Iterator 。

总结

千言万语一句话。

Iterator 是好的，但不是免费的。

时间：2003-11-28 作者：周海根 浏览次数： 2831 2728 本文关键字：JMS, 基础, 教程, 概念

文章工具  推荐给朋友  打印文章

一. JMS简介
1. JMS基本概念
JMS(Java Message Service)是访问企业消息系统的标准API,它便于消息系
统中的Java应用程序进行消息交换,并且通过提供标准的产生、发送、接收消息的接口简化企业应用的开发。

2. JMS基本功能
JMS 是用于和面向消息的中间件相互通信的应用程序接口。它既支持点对点(point-to-point)的域，又支持发布/订阅 (publish/subscribe)类型的域，并且提供对下列类型的支持：经认可的消息传递,事务型消息的传递，一致性消息和具有持久性的订阅者支 持。JMS还提供了另一种方式来对您的应用与旧的后台系统相集成。
3. WebLogic JMS Server介绍
WebLogic Server8.1符合JAVA规范,并通过Sun Microsystems J2EE 1.3认
证. 作为WebLogic的一部分,当然WebLogic JMS Server也完全遵从JMS规范,还支持集群,并可以应用于实际企业系统.下图是WebLogic JMS Server体系结构.图中可以看到WebLogic JMS Server主要组件有: WebLogic JMS servers(用于消息通信),Java客户端,JNDI(用于域名查找), 后备存储(用于持久消息存储,基于文件或者JDBC数据库).

二. WebLogic JMS特性
1. 消息通信模型
JMS 支持两种消息通信模型：点到点（point-to-point）（PTP）模型和发布/订阅（Pub/Sub）模型。除了下列不同之外，这两种消息通信模型非常地相似：
PTP 模型规定了一个消息只能有一个接收者;Pub/Sub 模型允许一个消息可以有多个接收者。
2. 消息组成
消息传递系统的中心就是消息。
一条 Message 分为三个组成部分：
· 头（header）是个标准字段集，客户机和供应商都用它来标识和路由消息。
· 属性（property）支持把可选头字段添加到消息。如果您的应用程序需要不使用标准头字段对消息编目和分类，您就可以添加一个属性到消息以实现这个编 目和分类。提供 set<Type>Property(...) 和 get<Type>Property(...) 方法以设置和获取各种 Java 类型的属性，包括 Object。JMS 定义了一个供应商选择提供的标准属性集。
· 消息的主体（body）包含要发送给接收应用程序的内容。每个消息接口特定于它所支持的内容类型。
JMS 为不同类型的内容提供了它们各自的消息类型，但是所有消息都派生自 Message 接口。
· StreamMessage：包含 Java 基本数值流，用标准流操作来顺序的填充和读取。
· MapMessage：包含一组名/值对；名称为 string 类型，而值为 Java 的基本类型。
· TextMessage：包含一个 String。
· ObjectMessage：包含一个 Serializable Java 对象；能使用 JDK 的集合类。
· BytesMessage：包含未解释字节流: 编码主体以匹配现存的消息格式。
· XMLMessage: 包含XML内容。扩展TextMessage,XMLMessage 类型的使用，使得消息过滤非常便利。
3. 消息确认模式
非事务性会话中，应用程序创建的会话有5 种确认模式,而在事务性会话中，确认模式被忽略。
五种确认模式说明:
· AUTO_ACKNOWLEDGE：自动确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收。
· CLIENT_ACKNOWLEDGE：客户端确认模式。会话对象依赖于应用程序对被接收的消息调用一个acknowledge()方法。一旦这个方法被 调用，会话会确认最后一次确认之后所有接收到的消息。这种模式允许应用程序以一个调用来接收，处理并确认一批消息。注意：在管理控制台中，如果连接工厂的 Acknowledge Policy（确认方针）属性被设置为"Previous"（提前），但是你希望为一个给定的会话确认所有接收到的消息，那么就用最后一条消息来调用 acknowledge()方法。
· DUPS_OK_ACKNOWLEDGE：允许副本的确认模式。一旦接收方应用程序的方法调用从处理消息处返回，会话对象就会确认消息的接收；而且允许重 复确认。在需要考虑资源使用时，这种模式非常有效。注意：如果你的应用程序无法处理重复的消息的话，你应该避免使用这种模式。如果发送消息的初始化尝试失 败，那么重复的消息可以被重新发送。
· NO_ACKNOWLEDGE：不确认模式。不确认收到的消息是需要的。消息发送给一个NO_ACKNOWLEDGE 会话后，它们会被WebLogic 服务器立即删除。在这种模式下，将无法重新获得已接收的消息，而且可能导致下面的结果：1. 消息可能丢失；和（或者）另一种情况：2. 如果发送消息的初始化尝试失败，会出现重复消息被发送的情况。
· MULTICAST_NO_ACKNOWLEDGE：IP组播下的不确认模式，同样无需确认。发送给一个 MULTICAST_NO_ACKNOWLEDGE会话的消息， 会共享之前所述的NO_ACKNOWLEDGE 确认模式一样的特征。这种模式支持希望通过IP 组播方式进行消息通信的应用程序，而且无需依赖会话确认提供的服务质量。注意：如果你的应用程序无法处理消息的丢失或者重复，那么你应该避免使用这种模 式。如果发送消息的初始化尝试失败的话，重复的消息可能会被再次发送。
注：在上表的5 种确认模式中，AUTO_ACKNOWLEDGE ，DUPS_OK_ACKNOWLEDGE 和
CLIENT_ACKNOWLEDGE 是JMS 规范定义的，NO_ACKNOWLEDGE 和MULTICAST_NO_ACKNOWLEDGE是WebLogic JMS 提供的。
三. 配置JMS
1. 创建连接工厂
(1) 启动WebLogic Server8.1,登录控制台,选中JMS Connection Factories节点,点击右边的" Configure a new JMS Connection Factory...";

(2) 填写连接工厂的名称SendJMSFactory和JNDI名称SendJMSFactory,点击"Create";

(3) 勾上"myserver",将SendJMSFactory应用到myserver;

2. 定义后备存储
(1) 选中JMS Stores节点,点击右边的" Configure a new JMS Connection Factory...";

(2) 填写文件后备存储的名称SendFileStore和目录Directionary E:\BEA\user_projects\domains\mydomain\sendfilestore,点击"Create".

3. 创建JMS服务器
(1) 选中JMS Servers节点,点击右边的" Configure a new JMSServer...";

(2) 填写JMS服务器的名称SendJMSServer和Paging Store设为" SendFileStore",点击"Create";

(3) Target选中"myserver",将SendJMSServer应用到myserver.

4. 创建消息队列
(1) 展开"SendJMSServer"节点,点击" Configure a new JMS Queue...";

(2) 填写消息队列的名称SendJMSQueue和JNDI名称SendJMSQueue,点击"Create";

四. JMS应用程序
一个 JMS 应用程序由下列元素组成：
· JMS 客户机。 用 JMS API 发送和接收消息的 Java 程序。
· 非 JMS（Non-JMS）客户机。 认识到这一点很重要 - 旧的程序经常成为整个 JMS 应用程序的一部分，而且它们的包含应该在设计时预先考虑。
· 消息。 在 JMS 和非 JMS 客户机之间交换的消息的格式和内容是 JMS 应用程序设计所必须考虑的部分。
· JMS 供应商。供应商必须提供特定于其 MOM 产品的具体的实现。
· 受管对象。 消息传递系统供应商的管理员创建了一个对象，它独立于供应商专有的技术。包括连接工厂ConnectionFactory和目的Destination。
一种典型的 JMS 程序需要经过下列步骤才能开始消息产生和使用:
· 通过 JNDI 查找 ConnectionFactory。
· 通过 JNDI 查找一个或多个 Destination。
· 用 ConnectionFactory 创建一个 Connection。
· 用 Connection 创建一个或多个 Session。
· 用 Session 和 Destination 创建所需的 MessageProducer 和 MessageConsumer。
· 启动 Connection。
下面利用上面配置的JMS资源演示点对点消息发送和接收的过程。
五. 设计消息发送端
1. 使用的JMS资源
服务器URL: t3://localhost:80
连接工厂: SendJMSFactory
队列: SendJMSQueue
2. 设计步骤
· 初始化JNDI Tree
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, PROVIDER_URL);
return new InitialContext(env);
· lookup ConnectionFactory
qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
· lookup Destination
queue = (Queue) ctx.lookup(queueName);
· 用 ConnectionFactory 创建Connection
qcon = qconFactory.createQueueConnection();
· 用 Connection 创建一个Session
qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
· 用 Session 和 Destination 创建MessageProducer
qsender = qsession.createSender(queue);
· 启动 Connection。
qcon.start();
· 发送消息
msg = qsession.createTextMessage();
msg.setText(message);
qsender.send(msg);
3. 源代码
package jmssample;

import java.util.Hashtable;
import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/** This example shows how to establish a connection
* and send messages to the JMS queue. The classes in this
* package operate on the same JMS queue. Run the classes together to
* witness messages being sent and received, and to browse the queue
* for messages. The class is used to send messages to the queue.
*
* @author Copyright (c) 1999-2003 by BEA Systems, Inc. All Rights Reserved.
*/
public class QueueSend
{
// Defines the JNDI context factory.
public final static String JNDI_FACTORY="weblogic.jndi.WLInitialContextFactory";

// Defines the JNDI provider url.
public final static String PROVIDER_URL=" t3://localhost:80";

// Defines the JMS connection factory for the queue.
public final static String JMS_FACTORY="SendJMSFactory";

// Defines the queue.
public final static String QUEUE="SendJMSQueue";

private QueueConnectionFactory qconFactory;
private QueueConnection qcon;
private QueueSession qsession;
private QueueSender qsender;
private Queue queue;
private TextMessage msg;

/**
* Creates all the necessary objects for sending
* messages to a JMS queue.
*
* @param ctx JNDI initial context
* @param queueName name of queue
* @exception NamingException if operation cannot be performed
* @exception JMSException if JMS fails to initialize due to internal error
*/
public void init(Context ctx, String queueName)
throws NamingException, JMSException
{
qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
qcon = qconFactory.createQueueConnection();
qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
queue = (Queue) ctx.lookup(queueName);
qsender = qsession.createSender(queue);
msg = qsession.createTextMessage();
qcon.start();
}

/**
* Sends a message to a JMS queue.
*
* @param message message to be sent
* @exception JMSException if JMS fails to send message due to internal error
*/
public void send(String message) throws JMSException {
msg.setText(message);
qsender.send(msg);
}

/**
* Closes JMS objects.
* @exception JMSException if JMS fails to close objects due to internal error
*/
public void close() throws JMSException {
qsender.close();
qsession.close();
qcon.close();
}
/** main() method.
*
* @param args WebLogic Server URL
* @exception Exception if operation fails
*/
public static void main(String[] args) throws Exception {
InitialContext ic = getInitialContext();
QueueSend qs = new QueueSend();
qs.init(ic, QUEUE);
readAndSend(qs);
qs.close();
}

private static void readAndSend(QueueSend qs)
throws IOException, JMSException
{
BufferedReader msgStream = new BufferedReader(new InputStreamReader(System.in));
String line=null;
boolean quitNow = false;
do {
System.out.print("Enter message (\"quit\" to quit): ");
line = msgStream.readLine();
if (line != null && line.trim().length() != 0) {
qs.send(line);
System.out.println("JMS Message Sent: "+line+"\n");
quitNow = line.equalsIgnoreCase("quit");
}
} while (! quitNow);

}

private static InitialContext getInitialContext()
throws NamingException
{
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, PROVIDER_URL);
return new InitialContext(env);
}

}

六. 设计消息接收端
1. 使用的JMS资源
服务器URL: t3://localhost:80
连接工厂: SendJMSFactory
队列: SendJMSQueue
2. 设计步骤
· 初始化JNDI Tree
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, PROVIDER_URL);
return new InitialContext(env);
· lookup ConnectionFactory
qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
· lookup Destination
queue = (Queue) ctx.lookup(queueName);
· 用 ConnectionFactory 创建Connection
qcon = qconFactory.createQueueConnection();
· 用 Connection 创建一个Session
qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
· 用 Session 和 Destination 创建MessageConsumer
qreceiver = qsession.createReceiver(queue);
· 设置监听
qreceiver.setMessageListener(this);
· 启动 Connection
qcon.start();
3. 源代码
package jmssample;

import java.util.Hashtable;
import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.util.Hashtable;
import javax.jms.*;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

/**
* This example shows how to establish a connection to
* and receive messages from a JMS queue. The classes in this
* package operate on the same JMS queue. Run the classes together to
* witness messages being sent and received, and to browse the queue
* for messages. This class is used to receive and remove messages
* from the queue.
*
* @author Copyright (c) 1999-2003 by BEA Systems, Inc. All Rights Reserved.
*/
public class QueueReceive implements MessageListener
{
// Defines the JNDI context factory.
public final static String JNDI_FACTORY="weblogic.jndi.WLInitialContextFactory";

// Defines the JNDI provider url.
public final static String PROVIDER_URL=" t3://localhost:80";

// Defines the JMS connection factory for the queue.
public final static String JMS_FACTORY="SendJMSFactory";

// Defines the queue.
public final static String QUEUE="SendJMSQueue";

private QueueConnectionFactory qconFactory;
private QueueConnection qcon;
private QueueSession qsession;
private QueueReceiver qreceiver;
private Queue queue;
private boolean quit = false;

/**
* Message listener interface.
* @param msg message
*/
public void onMessage(Message msg)
{
try {
String msgText;
if (msg instanceof TextMessage) {
msgText = ((TextMessage)msg).getText();
} else {
msgText = msg.toString();
}

System.out.println("Message Received: "+ msgText );

if (msgText.equalsIgnoreCase("quit")) {
synchronized(this) {
quit = true;
this.notifyAll(); // Notify main thread to quit
}
}
} catch (JMSException jmse) {
jmse.printStackTrace();
}
}

/**
* Creates all the necessary objects for receiving
* messages from a JMS queue.
*
* @param ctx JNDI initial context
* @param queueName name of queue
* @exception NamingException if operation cannot be performed
* @exception JMSException if JMS fails to initialize due to internal error
*/
public void init(Context ctx, String queueName)
throws NamingException, JMSException
{
qconFactory = (QueueConnectionFactory) ctx.lookup(JMS_FACTORY);
qcon = qconFactory.createQueueConnection();
qsession = qcon.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
queue = (Queue) ctx.lookup(queueName);
qreceiver = qsession.createReceiver(queue);
qreceiver.setMessageListener(this);
qcon.start();
}

/**
* Closes JMS objects.
* @exception JMSException if JMS fails to close objects due to internal error
*/
public void close()throws JMSException
{
qreceiver.close();
qsession.close();
qcon.close();
}
/**
* main() method.
*
* @param args WebLogic Server URL
* @exception Exception if execution fails
*/

public static void main(String[] args) throws Exception {

InitialContext ic = getInitialContext();
QueueReceive qr = new QueueReceive();
qr.init(ic, QUEUE);

System.out.println("JMS Ready To Receive Messages (To quit, send a \"quit\" message).");

// Wait until a "quit" message has been received.
synchronized(qr) {
while (! qr.quit) {
try {
qr.wait();
} catch (InterruptedException ie) {}
}
}
qr.close();
}

private static InitialContext getInitialContext()
throws NamingException
{
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, PROVIDER_URL);
return new InitialContext(env);
}

}
七. 测试消息发送和接收
1. 设置WebLogic Classpath;

5. 输入发送消息"quit",接收程序结束.


总结
本 文先简要介绍了JMS的一些基本概念,继而引入了WebLogic JMS Server的体系结构和相关特性。在此基础之上,图文并茂地讲述了JMS在WebLogic Server 8.1上的配置。最后在解剖JMS应用程序框架的同时,以点对点为例演示了JMS的发送接收消息流程。

图形界面开发对于Java来说并非它的长项，开发者经常会碰到各种各样的限制，比如，如何打造一款任意形状的窗口？如何可以透过窗口显示它覆盖下的内容？

考虑到Java并没有被设计成支持以上的功能，所以，你能得到的永远是方方正正的窗口，毫无新意，当然，我们可以通过JNI调用本地代码来完成，但是这就失去了java可移植性的意义，那么，用纯粹的java代码如何实现以上两种功能呢？

下文提供了一个实现的参考

预备知识：
1.java.awt.Robot，这个类是一个功能非常强大的类，通过它我们可以控制鼠标和键盘的响应，不过这里，我们只需要用到它的一个功能－－截屏，也就是得到当前屏幕的快照（screenshot）
2.我们可以通过调用一个swing组件的paintComponent(Graphics g)方法用特定的Graphics为其定制特殊的外观

首 先声明的一点是，本文中的实现方法只是一个欺骗的手法，因为要想实现前文中的功能，我们几乎的重写一套Swing出来，这里，简便的做法是，我们通过 robot类来获得当前屏幕的快照，然后贴在我们需要的窗口上，这样，不就实现了透明的功能了吗？顺便提一下，几年前日本发明的隐形衣也是依靠这种机制， 这种衣服在身后附带一套摄像机，然后即时的将拍下的内容显示在衣服的正面，因此，当别人看过来时，仿佛就通过人和衣服看到了身后的场景^_^

另外，还要感谢Joshua Chris leniz的Swing Hack一书，以上充满创新的方法正来自他的书中

好咯，让我们具体看一下细节的处理：
第一，我们要得到当前屏幕的快照，保存到一个Image对象[color=Red]background[/color]中：
  public void updateBackground() {
  try {
   Robot rbt = new Robot();
   Toolkit tk = Toolkit.getDefaultToolkit();
   Dimension dim = tk.getScreenSize();
   [color=Red]background [/color]= rbt.createScreenCapture(new Rectangle(0, 0, (int) dim
     .getWidth(), (int) dim.getHeight()));
  } catch (Exception ex) {
   }
 }

第二，我们需要让窗口显示这个图像，也就是说，让窗口的背景图像是这副图像，以达到透明的欺骗效果：

public void paintComponent(Graphics g) {
  Point pos = this.getLocationOnScreen();
  Point offset = new Point(-pos.x, -pos.y);
  g.drawImage([color=Red]background[/color], offset.x, offset.y, null);
 }

在swing hack一书中，作者也给出了他的实现，然而，运行结果表明该实现存在很大的问题：窗口经常无法即时更新，往往背景变了，窗口里显示的却还是以前的背景。 仔细研究了他的代码，我发现了问题的根结，同时也是这种实现技术的关键要素－－如何让窗口在正确的时机里更新显示，下面，我们会讨论这一点

第三，更新窗口外观
前两步的操作，只能得到一副当前屏幕的快照，一旦背景变化了，或者窗口移动了，变化大小了，那么我们制作的窗口将永远无法和和屏幕背景联合成整体，也就失去了透明的效果；同时，我们也不可能每时每刻都调用
updateBackground() 方法获得最新的背景，可行的方法是，通过对事件的监听来选择适当的时间来更新外观

我们应该可以达到这三点共识：
1。窗口移动或改变大小时，背景图像一般是不会发生变化的，我们不需要得到新的屏幕快照，只用将以前得到的背景中适当的部分贴到窗口上，调用repaint（）方法就足已
2。要获得最新的屏幕快照，必须先将窗口隐藏起来，调用updateBackground() 得到图像后再把窗口显示，我们可以用refresh方法来表示
 refresh（）{
    frame.hide();
    updateBackground() ;
   frame.show();
}
3。如果背景改变了，那么一定是别的windows程序获得了或失去了事件焦点，也就是说我们关注的窗口将触发焦点得失事件，这个时候需要调用refresh() 得到最新的屏幕快照

看到这里，你或许认为已经没有技术难点了，然而，此时才是我们[color=Red]最需要关注的地方[/color]：
参 看第三点，我们需要在窗口得失焦点时调用refresh() 方法；参看第一点，我们调用refresh() 方法时需要先将窗口隐藏，然后再显示。于是问题来了，在隐藏和显示窗口时，同样会触发得失焦点事件，得失焦点事件又将触发新的隐藏和显示窗口事件（为了得 到新的屏幕快照），这就使程序陷入了死循环中，我们必须加以控制，使得第二次触发焦点得失事件时不调用refresh（）方法

作者的办法是加一个线程来控制，通过判断时间间隔长短来决定是否调用refresh（）方法，可是，这个条件是程序非常的不稳定，因为往往调用时间会根据系统繁忙度而改变，使得需要更新时不能更新，不需要更新的时候反而更新了
因此，我决定采取新的解决方案，能不能隐藏/显示窗口时不触发得失焦点事件呢？
解 决方法很简单，我抛开了传统的setVisible（）或者show（），hide（）方法，而是使用setLocation（）方法，因为调用 setLocation（）方法时窗口不会失去焦点，同时，只要用类似setLocation（－2000，－2000）方法也同样可以轻松的让窗口在屏 幕中消失
下面是我的全部代码：

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowFocusListener;

import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.UIManager;

import org.jvnet.substance.SubstanceLookAndFeel;
import org.jvnet.substance.theme.SubstanceLightAquaTheme;

import ch.randelshofer.quaqua.QuaquaLookAndFeel;

public class TestEvent extends JComponent implements ComponentListener,
  WindowFocusListener {
 private JFrame frame;

 private Boolean isHiding = false, isShowing = false, start = false;

 private Image background;

 private Point p;
                    
                    [color=Red]//获得当前屏幕快照[/color]
 public void updateBackground() {
  try {
   Robot rbt = new Robot();
   Toolkit tk = Toolkit.getDefaultToolkit();
   Dimension dim = tk.getScreenSize();
   background = rbt.createScreenCapture(new Rectangle(0, 0, (int) dim
     .getWidth(), (int) dim.getHeight()));
  } catch (Exception ex) {
   // p(ex.toString());
   // 此方法没有申明过 ，因为无法得知上下文 。因为不影响执行效果 ，先注释掉它 ex.printStackTrace();
  }

 }

                   [color=Red]  //将窗口掉离出屏幕以获得纯粹的背景图象[/color]
 public void refresh() {
  if (start == true) {
   this.updateBackground();
   frame.setLocation(p);
   if (p.x < 0 || p.y < 0)
    frame.setLocation(0, 0);
   this.repaint();
  }
 }

 public void componentHidden(ComponentEvent e) {
  // TODO Auto-generated method stub
  System.out.println("Hidden");
 }

                     [color=Red] //窗口移动时[/color]
 public void componentMoved(ComponentEvent e) {
  // TODO Auto-generated method stub
  System.out.println("moved");
  this.repaint();
 }

                    [color=Red] //窗口改变大小时[/color]
 public void componentResized(ComponentEvent e) {
  // TODO Auto-generated method stub
  System.out.println("resized");
  this.repaint();
 }

 public void componentShown(ComponentEvent e) {
  // TODO Auto-generated method stub
  System.out.println("shown");
 }

                    [color=Red] //窗口得到焦点后,用refresh()方法更新界面[/color]
 public void windowGainedFocus(WindowEvent e) {
  // TODO Auto-generated method stub
  System.out.println("gainedFocus");
  refresh();
  start = false;
 }

                    [color=Red] //窗口失去焦点后,将其移出屏幕[/color]
 public void windowLostFocus(WindowEvent e) {
  // TODO Auto-generated method stub
  System.out.println("lostFocus");
  if (frame.isShowing() == true) {
   System.out.println("visible");
  } else {
   System.out.println("invisible");
  }
  start = true;
  p = frame.getLocation();
  frame.setLocation(-2000, -2000);
 }

 public TestEvent(JFrame frame) {
  super();
  this.frame = frame;
  updateBackground();
  this.setSize(200, 120);
  this.setVisible(true);
  frame.addComponentListener(this);
  frame.addWindowFocusListener(this);

  // TODO Auto-generated constructor stub
 }

                    //绘制外观,注意,其中 pos,offset 是为了将特定部分的图象贴到窗口上
 public void paintComponent(Graphics g) {
  Point pos = this.getLocationOnScreen();
  Point offset = new Point(-pos.x, -pos.y);
  g.drawImage(background, offset.x, offset.y, null);
 }

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  try {
   // UIManager.setLookAndFeel("org.fife.plaf.Office2003.Office2003LookAndFeel");
   // UIManager.setLookAndFeel("org.fife.plaf.OfficeXP.OfficeXPLookAndFeel");
   // UIManager.setLookAndFeel("org.fife.plaf.OfficeXP.OfficeXPLookAndFeel");
   UIManager.setLookAndFeel(new SubstanceLookAndFeel());
   //UIManager.setLookAndFeel(new SmoothLookAndFeel());
   //UIManager.setLookAndFeel(new QuaquaLookAndFeel());
   UIManager.put("swing.boldMetal", false);
   if (System.getProperty("substancelaf.useDecorations") == null) {
    JFrame.setDefaultLookAndFeelDecorated(true);
    //JDialog.setDefaultLookAndFeelDecorated(true);
   }
   System.setProperty("sun.awt.noerasebackground", "true");
   SubstanceLookAndFeel.setCurrentTheme(new SubstanceLightAquaTheme());

   // UIManager.setLookAndFeel("org.fife.plaf.VisualStudio2005.VisualStudio2005LookAndFeel");
  } catch (Exception e) {
   System.err.println("Oops!  Something went wrong!");
  }

  JFrame frame = new JFrame("Transparent Window");
  TestEvent t = new TestEvent(frame);
  t.setLayout(new BorderLayout());
  JButton button = new JButton("This is a button");
  t.add("North", button);
  JLabel label = new JLabel("This is a label");
  t.add("South", label);
  frame.getContentPane().add("Center", t);
  frame.pack();
  frame.setSize(150, 100);
  frame.show();
  frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  // t.start=true;
 }

}

当然，以上代码还存在许多不足，比如在移动窗口时性能会有影响，应该可以通过线程来控制其更新的频率来提升效率，希望大家能一起研究一下，改好了记得通知我哦

ps：你也许还会说，e？怎么没讲任意形状窗口如何打造？
       呵呵，其实只要把窗口按上述方法设置成透明，再去掉边框，再换上自己的边框，不就完成了马？
     相信聪明的各位一定很容易就办到咯

另外，我还在下面附带了作者的大论，想了解更多的同学也可以去看看

http://www.matrix.org.cn/resource/article/44/44186_Swing.html

所謂 BeanUtils 為何要開發呢, 每個工程師或許在寫 JavaBean 的時候, 都會乖乖地去寫 getters 和 setters, 就是 getXXX() 及 setXXX() methods, 但是當你的 object 是動態產生的, 也許是用檔案, 也許是其他原因, 那你該如何去存取資料呢 !!

幾個例子你可能會用到 BeanUtils, 當然, 這是已經存在的專案了

• BSF : Script Language 和 Java Object Model 之間
• Velocity / JSP: 使用 template 建立相似的網頁
• jakarta taglibs / Struts/ Cocoon: 建立自己特殊的 Tag Libraries for JSP 或 XSP
• ant build.xml / tomcat server.xml: XML-based 的 設定檔案 ( configuration resources )

你大可以使用 java api 中的 java.lang.reflect 及 java.beans 來達到這些資料交換 ~~ 不過呢, 難度有點高 ,但是, BeanUtils 將會減低你開發的時間 !!

目前最新的 stable 版本為 1.7.0 (2003/2/18 released),
下載位置為 Binary & Source

　BeanUtils API 介紹

BeanUtils 的 Java API 主要的 package 總共四項

1. org.apache.commons.beanutils
2. org.apache.commons.beanutils.converters
3. org.apache.commons.beanutils.locale
4. org.apache.commons.beanutils.locale.converters

其實除了第一項之外, 其他的都是後來版本才加上去的, converters 就是專門處理不同傳入的 object 該如何轉換, locale 呢, 就是為了國際化的處理, 所以重點我都會擺在第一項!!

而其中最常用到的 class 是 PropertyUtils 及 ConvertUtils 還有 DynaBeans( 有用 struts dynaform 的應該不陌生 )

　BeanUtils.PropertyUtils 介紹

基本上, 我假設大家對 JavaBean 的開發都沒有問題, 就是 對 getters 及 setters 都了解是什麼. 先假設,

								public class Employee {
public Address getAddress(String type);
public void setAddress(String type, Address address);
public Employee getSubordinate(int index);
public void setSubordinate(int index, Employee subordinate);
publicString getFirstName();
public void setFirstName(String firstName);
publicString getLastName();
public void setLastName(String lastName);
}

在 PropertyUtils 中會區分為三種 method 狀態

• Simple - 如果你是用到 primitive 語法, 如 int, String 或其他自行開發的 objects 等等, 只需要單一的物件就可以取得資料

  PropertyUtils.getSimpleProperty(Object bean, String name) 
  PropertyUtils.setSimpleProperty(Object bean, String name, Object value)

  Employee employee = ...;
  String firstName = (String)
      PropertyUtils.getSimpleProperty(employee, "firstName");
  String lastName = (String)
      PropertyUtils.getSimpleProperty(employee, "lastName");
  .............
  PropertyUtils.setSimpleProperty(employee, "firstName", firstName);
  PropertyUtils.setSimpleProperty(employee, "lastName", lastName);

• Indexed - 如果你是用到 Collection 或 List 實作出來的 objects , 只需要使用一個 index 數值就可以取得資料的型態

  PropertyUtils.getIndexedProperty(Object bean, String name) 
  PropertyUtils.getIndexedProperty(Object bean, String name, int index) 
  PropertyUtils.setIndexedProperty(Object bean, String name, Object value) 
  PropertyUtils.setIndexedProperty(Object bean, String name, int index, Object value)

  Employee employee = ...;
  int index = ...;
  String name = "subordinate[" + index + "]";
  Employee subordinate = (Employee)
      PropertyUtils.getIndexedProperty(employee, name);
  Employee employee = ...;
  int index = ...;
  Employee subordinate = (Employee)
      PropertyUtils.getIndexedProperty(employee, "subordinate", index);

• Mapped - 如果你是用到 Map 延伸出來的 objects , 只需要使用一個 key 值就可以取得資料

  PropertyUtils.getMappedProperty(Object bean, String name) 
  PropertyUtils.getMappedProperty(Object bean, String name, String key) 
  PropertyUtils.setMappedProperty(Object bean, String name, Object value) 
  PropertyUtils.setMappedProperty(Object bean, String name, String key, Object value)

  Employee employee = ...;
  Address address = ...;
  PropertyUtils.setMappedProperty(employee, "address(home)", address);
  Employee employee = ...;
  Address address = ...;
  PropertyUtils.setMappedProperty(employee, "address", "home", address);

但是如果你是巢狀(nested)的資料結構, 你該如何取得你要的資料呢

PropertyUtils.getNestedProperty(Object bean, String name) 
PropertyUtils.setNestedProperty(Object bean, String name, Object value)

你只需要簡單地使用 ".", 就可以得到你要的資料了

								String city = (String)
    PropertyUtils.getNestedProperty(employee, "address(home).city");

千萬要記住, BeanUtils 是要讓你隨心所欲使用, 所以呢 index , mapped 當然都可以這樣使用

Employee employee = ...;
String city = (String) 
    PropertyUtils.getProperty(employee, "subordinate[3].address(home).city");

　BeanUtils.DynaBean and BeanUtils.DynaClass 介紹

所有的 Dynamic JavaBean 都是實作 DynaBean 或 DynaClass 這兩個 interface, 也可能會用到 DynaProperty class 來存取 properties . 我們為何要用到 Dynamic JavaBean 呢, 例如, 你從資料庫撈出來的資料, 有時候可能是三個欄位, 有時候是四個欄位, 如果我們對於每個 Bean 都要去寫一個 class, 就會很累, 所以對於每一種 javabean 我們就設定他的屬性有哪些, 接著就可以使用 PropertyUtils 來將他的數值取出, 如此, 可以減少很多開發工時. 在 Struts 的課程中, 很多人問到我, 請問每一個 ActionForm 都必須寫成 java 檔嗎, 當然, 不需要的, 否則一個網頁一個 ActionForm ( 假設都不一樣 ), 那麼, 這麼浪費時間的工作, 為何還要使用 Struts 來作為 Framework 呢, 所以我們都是使用 org.apache.struts.action.DynaActionForm!!
MutableDynaClass 這是一個 DynaClass, 是為了動態可以調整 properties !

• BasicDynaBean and BasicDynaClass - 基本的 Dynamic 型態

  BasicDynaClass(java.lang.String name, java.lang.Class dynaBeanClass, DynaProperty[] properties)
  BasicDynaBean(DynaClass dynaClass)

  DynaProperty[] props = new DynaProperty[]{
  new DynaProperty("address", java.util.Map.class),
  new DynaProperty("subordinate", mypackage.Employee[].class),
  new DynaProperty("firstName", String.class),
  new DynaProperty("lastName",  String.class)
  };
  BasicDynaClass dynaClass = new BasicDynaClass("employee", null, props);
  
  DynaBean employee = dynaClass.newInstance();
  employee.set("address", new HashMap());
  employee.set("subordinate", new mypackage.Employee[0]);
  employee.set("firstName", "Fred");
  employee.set("lastName", "Flintstone");

• ResultSetDynaClass (Wraps ResultSet in DynaBeans) - 使用 ResultSet 的 Dynamic JavaBean

  ResultSetDynaClass(java.sql.ResultSet resultSet)
  ResultSetDynaClass(java.sql.ResultSet resultSet, boolean lowerCase)

  如果 lowerCase 設為 false , 回傳的資料欄位名將根據 JDBC 回傳的為準. default 為 true.

  Connection conn = ...;
  Statement stmt = conn.createStatement();
  ResultSet rs = stmt.executeQuery
      ("select account_id, name from customers");
  Iterator rows = (new ResultSetDynaClass(rs)).iterator();
  while (rows.hasNext()) {
      DynaBean row = (DynaBean) rows.next();
  System.out.println("Account number is " +
                      row.get("account_id") +
  " and name is " + row.get("name"));
  }
  rs.close();
  stmt.close();

• RowSetDynaClass (Disconnected ResultSet as DynaBeans) - 使用 RowSet 的 Dynamic JavaBean

  RowSetDynaClass(java.sql.ResultSet resultSet)
  RowSetDynaClass(java.sql.ResultSet resultSet, boolean lowerCase)

  如果 lowerCase 設為 false , 回傳的資料欄位名將根據 JDBC 回傳的為準. default 為 true.

  Connection conn = ...;  // Acquire connection from pool
  Statement stmt = conn.createStatement();
  ResultSet rs = stmt.executeQuery("SELECT ...");
  RowSetDynaClass rsdc = new RowSetDynaClass(rs);
  rs.close();
  stmt.close();
  ...;                    // Return connection to pool
  List rows = rsdc.getRows();
  ...;                   // Process the rows as desired

• WrapDynaBean and WrapDynaClass - 包裝過的 Dynamic JavaBean
  如果你對於 DynaBean 的功能強大, 非常佩服的同時, 手邊的 JavaBean 又不能隨隨便便就不用 那你就把他包裝起來 ....

  WrapDynaClass(java.lang.Class beanClass) 
  WrapDynaBean(java.lang.Object instance) 
  ConvertingWrapDynaBean(java.lang.Object instance)

  MyBean bean = ...;
  DynaBean wrapper = new WrapDynaBean(bean);
  String firstName = wrapper.get("firstName");

  　BeanUtils.ConvertUtils 介紹

  在很多情況, 例如 struts framework 中, 就常常用到 request.getParameter 的參數, 需要轉換成 正確的資料型態, 所以 ConvertUtils 就是來處理這些動作.

  ConvertUtils().convert(java.lang.Object value) 
  ConvertUtils().convert(java.lang.String[] values, java.lang.Class clazz) 
  ConvertUtils().convert(java.lang.String value, java.lang.Class clazz)

  HttpServletRequest request = ...;
  MyBean bean = ...;
  HashMap map = new HashMap();
  Enumeration names = request.getParameterNames();
  while (names.hasMoreElements()) {
  String name = (String) names.nextElement();
      map.put(name, request.getParameterValues(name));
  }
  BeanUtils.populate(bean, map);// it will use ConvertUtils for convertings

目前支援的型態有

• java.lang.BigDecimal
• java.lang.BigInteger
• boolean and java.lang.Boolean
• byte and java.lang.Byte
• char and java.lang.Character
• java.lang.Class
• double and java.lang.Double
• float and java.lang.Float
• int and java.lang.Integer
• long and java.lang.Long
• short and java.lang.Short
• java.lang.String
• java.sql.Date
• java.sql.Time
• java.sql.Timestamp

也可以建立自己的 converter

Converter myConverter =
new org.apache.commons.beanutils.converter.IntegerConverter(); 
ConvertUtils.register(myConverter, Integer.TYPE);    // Native type 
ConvertUtils.register(myConverter, Integer.class);   // Wrapper class

　ps :部分內容屬於直接翻譯自 jakarta commons beanutils

　有時後我們在分散式的系統下,希望要產生唯一的一個ID.如果我們不希望用centralize的方式產生的話,我們可以用UUID來產生Unique ID,這個演算法讓我們幾乎不會產生重複的ID.使用方法也很簡單:

UUID uuid = UUID.randomUUID();        
System.out.printf("UUID : %s", uuid).println();
使用瀏覽器進行檔案上傳時，是使用multipart/form-data編碼，然而
Servlet容器並不會自動幫我們處理編碼，而必須由程式設計人員自行處理，Jakarta Commons
FileUpload可以讓您輕易的處理檔案上傳事務，您可以在這個網頁中找到下載檔案，撰寫本文時最新的版本是1.0，檔名是commons-
fileupload-1.0.zip：

http://jakarta.apache.org/site/binindex.cgi

<html>
<head>
<title>檔案上傳</title>
<meta http-equiv="Content-Type" content="text/html; charset=big5">
</head>
<body>
<b>檔案上傳</b></font></p>

<form name="UploadForm" enctype="multipart/form-data" method="post" action="upload.jsp">
    <input type="file" name="File1" size="20" maxlength="20"> <br>
    <input type="file" name="File2" size="20" maxlength="20"> <br>
    <input type="submit"value="上傳">
</form>

</body>
</html>

DiskFileUpload fu = new DiskFileUpload();
// 使用的記憶體容量，超過先寫入暫存檔
    fu.setSizeThreshold(4096);
// 最大上傳檔案容量
    fu.setSizeMax(1000000);
// 暫存目錄
    fu.setRepositoryPath(application.getRealPath("/"));
    List fileItems = fu.parseRequest(request);

DiskFileUpload upload = new DiskFileUpload();
List items = upload.parseRequest(request,
        yourMaxMemorySize, yourMaxRequestSize, yourTempDirectory);

Iterator itr = fileItems.iterator();
while(itr.hasNext()) {
        FileItem fi = (FileItem)itr.next();

        out.println("\nNAME: "+fi.getName());
        out.println("SIZE: "+fi.getSize());
        File fNew= new File(application.getRealPath("/"), fi.getName());
        fi.write(fNew);
    }

<%@ page import="org.apache.commons.fileupload.DiskFileUpload"%>
<%@ page import="org.apache.commons.fileupload.FileItem"%>
<%@ page import="java.util.List"%>
<%@ page import="java.util.Iterator"%>
<%@ page import="java.io.File"%>
<%@page contentType="text/html;charset=Big5"%>
<%
    DiskFileUpload fu = new DiskFileUpload();
// 使用的記憶體容量，超過先寫入暫存檔
    fu.setSizeThreshold(4096);
// 最大上傳檔案容量
    fu.setSizeMax(1000000);
// 儲存的目錄
    fu.setRepositoryPath(application.getRealPath("/") + "temp/");
    List fileItems = fu.parseRequest(request);                                           

    Iterator itr = fileItems.iterator();
while(itr.hasNext()) {
        FileItem fi = (FileItem)itr.next();

        out.println("\nNAME: "+fi.getName());
        out.println("SIZE: "+fi.getSize());
        File fNew= new File(application.getRealPath("/"), fi.getName());
        fi.write(fNew);
    }
%>

<form name="UploadForm" enctype="multipart/form-data" method="post" action="upload.jsp">
    上傳檔案 1 <input type="file" name="File1" size="20" maxlength="20"> <br>
    檔案描述 1 <input type="text" name="File1" size="30" maxlength="50"> <br>
    上傳檔案 2<input type="file" name="File2" size="20" maxlength="20"> <br>
    檔案描述 2 <input type="text" name="File1" size="30" maxlength="50"> <br>
    <input type="submit"value="上傳">
</form>

Iterator iter = items.iterator();
while (iter.hasNext()) {
    FileItem item = (FileItem) iter.next();

if (item.isFormField()) {
// 處理檔案描述欄位
        processFormField(item);
    } else {
// 處理上傳的檔案
        processUploadedFile(item);
    }
}

String fileName = item.getName();
try {
// unix-like 系統
    fileName = FileName.substring(FileName.lastIndexOf("/")+1);
// Windows 系統
// fileName = FileName.substring(FileName.lastIndexOf("\\")+1);

} catch (Exception e) {
        .....
}

SnapshotIF snapshot = ProxoolFacade.getSnapshot("example", true);
System.out.println(snapshot.getActiveConnectionCount());
System.out.println(snapshot.getMaximumConnectionCount());
....

　true 表示取得詳細的連線池訊息；您也可以對連線池的資料進行定時統計，這必須在XML或屬性檔中設定統計的時間，例如在XML中增加以下內容：

<proxool>
     ....
    <statistics>1m,15m,1d</statistics>
</proxool>

　統計的時隔可以分為s(econds),、m(inutes)、h(ours)與d(ays)，就上面的設定來說，就是依分鐘、五分鐘、一天分別作統計，如果是在屬性檔案中設定，則增加：

jdbc-0.proxool.statistics=1m,15m,1d

　如果要取得統計資訊，可以從org.logicalcobwebs.proxool.admin.StatisticsIF取得，例如取得所有的統計資料：

StatisticsIF[] statisticsArray = ProxoolFacade.getStatistics("example");

　接下來就可以使用StatisticsIF的getXXX()方法來取得相關的訊息，您也可以指定取回某個時間的統計資訊，例如每15分鐘的統計資料：

StatisticsIF statistics = ProxoolFacade.getStatistics("example", "15m");

　如果您使用Web應用程式，則可以直接利用org.logicalcobwebs.proxool.admin.servlet.AdminServlet來取得相關的統計資料，在web.xml中這麼設定：

<servlet>
  <servlet-name>Admin</servlet-name>
  <servlet-class>org.logicalcobwebs.proxool.admin.servlet.AdminServlet</servlet-class>
</servlet>

<servlet-mapping>
  <servlet-name>Admin</servlet-name>
  <url-pattern>/admin</url-pattern>
</servlet-mapping>

　啟動Container，在測試資料庫後，您就可以連接Servlet取得連線統計訊息，例如：

http://網址/Web程式名稱/admin

Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
Properties info = new Properties();
info.setProperty("proxool.maximum-connection-count", "20");
info.setProperty("proxool.house-keeping-test-sql", "select CURRENT_DATE");
info.setProperty("user", "caterpillar");
info.setProperty("password", "123456");
Connection conn = DriverManager.getConnection(
"proxool.example:com.mysql.jdbc.Driver:jdbc:mysql://localhost:3306/GUESTBOOK", info);

　當然這種方式是硬編碼（hard code）在程式中，要改變參數時必須修改原始檔案並重新編譯，我們也可以使用XML檔案或屬性檔來進行設定，使用XML檔案的方式如下：

<?xml version="1.0" encoding="ISO-8859-1"?>
<something-else-entirely>
  <proxool>
    <alias>example</alias>
    <driver-url>jdbc:mysql://localhost:3306/GUESTBOOK</driver-url>
    <driver-class>com.mysql.jdbc.Driver</driver-class>
    <driver-properties>
      <property name="user" value="caterpillar"/>
      <property name="password" value="123456"/>
    </driver-properties>
    <maximum-connection-count>10</maximum-connection-count>
    <house-keeping-test-sql>select CURRENT_DATE</house-keeping-test-sql>
  </proxool>
</something-else-entirely>

　其中example是連接池的別名（Alias），我們使用org.logicalcobwebs.proxool.configuration.JAXPConfigurator來讀取XML，以下的示範如何取得連線：

Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
JAXPConfigurator.configure("proxool.xml", false); // false 表示不驗證 XML
Connection conn = DriverManager.getConnection("proxool.example");

　我們也可以使用屬性檔來配置Proxool，屬性檔的內容如下：

jdbc-0.proxool.alias=example
jdbc-0.proxool.driver-url=jdbc:mysql://localhost:3306/GUESTBOOK
jdbc-0.proxool.driver-class=com.mysql.jdbc.Driver
jdbc-0.user=caterpillar
jdbc-0.password=123456
jdbc-0.proxool.maximum-connection-count=10
jdbc-0.proxool.house-keeping-test-sql=select CURRENT_DATE

　我們使用org.logicalcobwebs.proxool.configuration.PropertyConfigurator來讀取屬性檔，下面示範如何取得連線：

Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
org.logicalcobwebs.proxool.configuration.PropertyConfigurator.configure("proxool.properties");
Connection conn = DriverManager.getConnection("proxool.example");

　首先是透過XML檔案，XML檔案的設定請參考前一個主題，在web.xml中，您可以這麼設定：

<servlet-name>ServletConfigurator</servlet-name>
  <servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class>
  <init-param>
    <param-name>xmlFile</param-name>
    <param-value>WEB-INF/proxool.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>

　再來是透過屬性檔，屬性檔的設定請參考前一個主題，在web.xml中，您可以這麼設定：

<servlet>
  <servlet-name>ServletConfigurator</servlet-name>
  <servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class>
  <init-param>
    <param-name>propertyFile</param-name>
    <param-value>WEB-INF/proxool.properties</param-value>
  </init-param>
</servlet>

　上面兩種作法，其實ServletConfigurator也各是委託JAXPConfigurator或 PropertyConfigurator來讀取組態設定；您也可以不透過檔案設定組態，而直接在web.xml中透過Servlet初始參數的設定來指 定相關參數：

<servlet>
  <servlet-name>ServletConfigurator</servlet-name>
  <servlet-class>org.logicalcobwebs.proxool.configuration.ServletConfigurator</servlet-class>
  <init-param>
    <param-name>jdbc-0.proxool.alias</param-name>
    <param-value>example</param-value>
  </init-param>
  <init-param>
    <param-name>jdbc-0.proxool.driver-url</param-name>
    <param-value>jdbc:mysql://localhost:3306/GUESTBOOK</param-value>
  </init-param>
  <init-param>
    <param-name>jdbc-0.proxool.driver-class</param-name>
    <param-value>com.mysql.jdbc.Driver</param-value>
  </init-param>
  <init-param>
    <param-name>jdbc-0.user</param-name>
    <param-value>caterpillar</param-value>
  </init-param>
  <init-param>
    <param-name>jdbc-0.password</param-name>
    <param-value>123456</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>

　取得連線的方式只要下面這句就行了：

Connection conn = DriverManager.getConnection("proxool.example");

　下面這個JSP簡單的測試一下是否可以取得連線：

<%@page import="java.sql.*"%>
<%@page contentType="text/html;charset=Big5"%>
<%
try {
        Connection conn = DriverManager.getConnection("proxool.example");
if(!conn.isClosed())
            out.println("資料庫連線測試成功！");

        conn.close();
    }
catch(SQLException e) {
        out.println(e.toString());
    }
%>

http://proxool.sourceforge.net/index.html

　網站上的User Guide提供相當簡明的入門文件，您可以直接先從這些文件開始下手，而這篇文件則先提供您一個快速入門的範例，讓您知道如何透過Proxool取得資料庫連線，這邊所使用的是MySQL資料庫。

　為了要使用Java來進行連線，首先您所需要的是當然是JDBC驅動程式，如果您不知道如何使用JDBC，請先參考這邊有關於JDBC的介紹：
http://www.caterpillar.onlyfun.net/phpBB2/viewforum.php?f=21

　接下來請在Proxool網址上取得proxool-0.8.3.zip這個檔案，解開後，將lib下的proxool-0.8.3.jar放至 您的 CLASSPATH可以存取的位置，如果是Web應用程式的話，您可以放置在WEB/lib目錄下，如果是桌面應用程式，您可以將之加入環境變數 CLASSPATH中。

　要使用Proxool，首先是載入Proxool驅動程式：

Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");

　接著我們在透過DriverManager取得連線時，必須告知連接池別名、JDBC驅動程式、JDBC URL等相關訊息：

Connection conn =
DriverManager.getConnection("proxool.example:com.mysql.jdbc.Driver:jdbc:mysql://localhost:3306/GUESTBOOK",
"caterpillar",
"123456");

　其中example是連接池的別名（alias），是一個用來參考至連接池的名稱，取得連接，接下來就按照JDBC的操作來使用即可，在不使用連線的時候，可以關閉它將連線放回連接池。

　下面這個程式是個簡單測試Proxool連線取得的範例：

import java.sql.*;

public class DBTest {
static {
try {
Class.forName("org.logicalcobwebs.proxool.ProxoolDriver");
        }
catch(ClassNotFoundException e) {
System.out.println("找不到驅動程式類別");
            e.printStackTrace();
        }
    }

publicstatic void main(String[] args) {
try {
            Connection conn = DriverManager.getConnection(
"proxool.example:com.mysql.jdbc.Driver:jdbc:mysql://localhost:3306/GUESTBOOK",
"caterpillar", "123456");
if(!conn.isClosed())
System.out.println("資料庫連線測試成功！");
            conn.close();
        }
catch(SQLException e) {
            e.printStackTrace();
        }
    }
}

假如說，某種狀況下，我們必須自行建置 Connection pooling 的機制時，該如何進行呢？自己寫當然是非常不划算的，況且也不一定寫的好，在這裡，我們使用 jakata project 裡的一個子專案 DBCP，來快速的建置一個隨處可用的 Connection pooling 機制。

在 Tomcat 裡，DBCP 是內建的，用來管理 DB Connection pooling。這個機制是可移植且可獨立出來使用的，要在你的運用程式中加上 DBCP 的功能，你必須至 http://jakarta.apache.org/commons/index.html 這個網址，找到該網頁內的 Components，共有三個必須下載：Collections 、 DBCP 、 Pool 。DBCP 是運用 Collections 及 Pool 這二個基礎的 Components 所設計出來的。當然，如果你有安裝 Tomcat server，最佳的方式是至 $TOMCAT_HOME/common/lib/ 目錄下去取得，保證版本的配合度不會出現問題。在 Tomcat server 裡，以 Tomcat 5.0.19 版內附的最新版本，這三個 Components 的檔名分別是 commons-collections.jar 、 commons-pool-1.1.jar 及 commons-dbcp-1.1.jar。

取得使用 DBCP 必備的 jar 檔後，請記得將這些 jar 檔，放置到 CLASSPATH 中，或直接放至 $JAVA_HOME/jre/lib/ext/ 目錄內。不過，由於 DBCP 有運用到 DataSource 的功能，而這功能是 J2EE 才有的，所以你還必須去下載 J2EE 的一個 javax.jar 檔。

環境建置好之後，接下來就可以開始設計 Connection Pooling 的機制，在這兒，我們介紹最簡單的作法，只要幾行指令就可以完成了，請看範例區裡的程式及其說明。

範例：

01 package util;
02 
03 import java.sql.*;
04 import javax.naming.*;
05 import javax.sql.*;
06 
07 import org.apache.commons.dbcp.BasicDataSource;
08 
09 public class DBConnect {
10   static DataSource dataSource = null;
11 
12   publicstatic DataSource setupDataSource( String sDrvName, String sUserName,
13       String sPwd, String connectURI ) {
14       BasicDataSource ds = new BasicDataSource();
15       ds.setDriverClassName( sDrvName );
16       ds.setUsername( sUserName );
17       ds.setPassword( sPwd );
18       ds.setUrl( connectURI );
19       ds.setMaxActive( 50 );
20       ds.setMaxIdle( 10 );
21       ds.setMaxWait( 10000 ); // 10 seconds
22       return ds;
23   }
24 
25 
26   // static init of the class
27   static {
28     try {
29       System.setProperty( "jdbc.drivers", "oracle.jdbc.driver.OracleDriver" );
30       Class.forName( "oracle.jdbc.driver.OracleDriver" );
31 
32       dataSource = setupDataSource( "oracle.jdbc.driver.OracleDriver", "username",
33         "password", "jdbc:oracle:thin:@192.168.0.1:1521:SID" );
34     }
35     catch (Exception e) {
36       System.out.println( "DBConnect.java => Unable to load driver."  + e.getMessage() );
37     }
38   }
39 
40   /**
41    * 空的建構元，不作任何處理動作。
42    */
43   public DBConnect() {}
44 
45   /**
46    * 取得 DB Connection.
47    */
48   publicstatic Connection getConnection() throws SQLException,ClassNotFoundException {
49     BasicDataSource bds = (BasicDataSource) dataSource;
50     System.out.println("NumActive: " + bds.getNumActive() + ","
51       + "NumIdle: " + bds.getNumIdle() );
52     return dataSource.getConnection();
53   }
54 }

完成這個程式後，接下來在你的應用程式裡，用 DBConnect.getConnection() 來取得 DB Connection，就能享受到 Connection Pooling 的功能了。

在實際的運作中，這個範例有加上偵錯指令，會顯示出目前 Connection Pool 裡，有多少個 Idle 的 Connection 及多少個 Active 的 Connection，可供作為系統運作的參數調整依據。

看完上篇（請參考九月十二日的Java週報）筆者所講解的物件的比較之後，
既然講到了字串，筆者就再來跟大家討論一下，如何有效率地使用字串。
你也許會有疑問說，字串就這樣用啊，什麼叫有效率的使用字串呢？我們
先來確定一件事情，Java API說明文件上有這麼一行字：

“Strings are constant; their values cannot be changed after they are created.
String buffers support mutable strings. Because String objects
are immutable they can be shared.”。

意思是字串是個常數，是不可
更改的，也就是說你對一個字串物件做任何的修改，像是加上另一個串、
把字母變大寫等等，都會產生一個新的字串物件。我們做個小小的測試，
來証明這件事情。

								String str1 = newString(“hello”);
String str2 = str2;
boolean b1 = str1 == str2;

還記得上週筆者講解的字串之間比較嗎？b1得到的結果是true，代表str1
和str2參考到同一個字串物件，忘記或是不清楚的讀者，再回去翻翻週報
的內容。如果現在我們把str2加上“java”這個字串：

str2 = str2 + “java”;
boolean b2 = str1 == str2;

你會發現b2的結果是false，代表str1和str2所參考的字串物件已經不是同
一個了！現在在系統中就有三個字串物件，一個是“hello”，第二個是“
java”，第三個是“hellojava”。因為在Java中，字串有這樣一個不可修
改的特性，所以才會引發出如何有效地使用字串這個問題出來。

字串是每個應用程式都會用到的物件，常常有些程式中會對字串做大量的
運算，尤其是兩個字串的相加，例如我們寫了一個從網路上讀取網頁資料
的程式，跑個迴圈，用BufferedReader物件一次讀一行進來，然後把每一
行再加在一起。像這種很直覺、很簡單的程式，兩行就搞定了，可是JVM中
所做的事情可多了。 假設我們寫個一程式，要把一個字串一直加上“a”
一百次，很直覺得我們會這樣寫：

								String str = “”;
for (int i=0; i<100; i++)
str += “a”;

可是你知道在記憶體中會產生多少的垃圾出來嗎？總共會有a、aa、aaa、
aaa….，無疑的，上述的程式雖然簡單，但浪費了不少的記憶體，而且產
生物件和物件的存取也會花掉不少的時間，我們加上幾行程式碼來測試所
花的時間和記憶體：

								long startTime = System.currentTimeMillis();
long startMem = Runtime.getRuntime().freeMemory();

for (int i=0; i<1000; i++)
str += "a";

long endMem = Runtime.getRuntime().freeMemory();
System.out.println("Use memory: "+ (startMem - endMem));
long endTime = System.currentTimeMillis();
System.out.println("Use Time: "+ (endTime – startTime));

上面的程式在筆者的PIII-800的電腦上跑，平均花了50 ms和151256 bytes
的記憶體，時間還好，但記憶體使用量算蠻大的了。那我們要如何來改進
讓程式更有效率呢？因為String物件是不可修改的，可是程式中又常需要
這樣的一個動作，所以Java提供了另外一個類別，專門來處理字串運算用
的，這個類別就叫作StringBuffer。StringBuffer類別提供了很多方法來
做字串的運算，但如附加、刪除、插入、反轉、替換等等…。我們就用
StringBuffer類別所提供的附加(append)方法來做到跟上面那個例子同樣
的結果：

								StringBuffer sb = newStringBuffer();
long startTime = System.currentTimeMillis();
long startMem = Runtime.getRuntime().freeMemory();

for (int i=0; i<1000; i++)
sb.append(“a”);

long endMem = Runtime.getRuntime().freeMemory();
System.out.println("Use memory: "+ (startMem - endMem));
long endTime = System.currentTimeMillis();

修改過的程式在筆者電腦上跑，平均花了0 ms和4854 bytes的記憶體。
0 ms？！多跑幾次有時會到10 ms，要看你電腦CPU目前的負載如何，不
過跟前面的例子比較起來，已經算是快了，而且記憶體也使用的非常少
。這只是個小小的例子，如果字串量再大一點，兩者的差異會更明顯。

所以結論就是，如果你的程式中會對字串做大量的修改時，請改用
StringBuffer類別，它會明顯示改進你程式的效率。至於StringBuffer
類別所提供的方法詳細的使用說明，就請自行參閱Java API。

JDK 5.0 加入了 StringBuilder
和 StringBuffer 主要不同的時, 它不是 synconized 的, 省回了一點 overhead

javac -target 1.4
String b=a+"a";

會被 compile 為

								String b=newStringBuffer(a).append("a").toString();

javac -target 1.5
String b=a+"a";

會被 compile 為

								String b=new StringBuilder(a).append("a").toString();

因為 1.4 沒有 StringBuilder, 所以 javac -target 1.5 是不可以在 jvm 1.4 上運行的

另外....

								static
								final
								int x=10000;

StringBuffer sb = newStringBuffer();
for (int i=0; i<x; i++)
sb.append(“a”);

StringBuffer sb = newStringBuffer(x);
for (int i=0; i<x; i++)
sb.append(“a”);

也是相差很遠的...
好像大約 20%

想想 String b=new StringBuilder(a).append("a").toString(); 吧
在大型的 loop 中, 這是突破 preformenace 的一個關口....

StringBuilder 內部是用 char[] 實作, 而 default 只是用 char[16],
似類似 ArrayList, 當 char[] 長度不足就會用 System.arraycopy 移到另一個新的使用

								StringBuffer sb = newStringBuffer();
for (int i=0; i<x; i++)
sb.append("a");

而這段 code, 會出現大當 arraycopy, new char[] 等等浪費時間的動作
連 GC 做的份也少省了下來

								StringBuffer sb = newStringBuffer(x);

而這個, 一開始就準備了一個剛好足夠大小的 char[]

也就是, 和 ArrayList, HashMap 之類的, 利用 init 一個比較大/剛好的 array 來減少 rehash / overhead的原理一樣, 不過 StringBuffer 沒法字去更改 resize factor 就是了....

void expandCapacity(int minimumCapacity) {
int newCapacity = (value.length + 1) * 2;
if (newCapacity < 0) {
            newCapacity = Integer.MAX_VALUE;
        } elseif (minimumCapacity > newCapacity) {
      newCapacity = minimumCapacity;
  }  
char newValue[] = newchar[newCapacity];
System.arraycopy(value, 0, newValue, 0, count);
  value = newValue;
    }
publicStringBuffer append(String str) {
if (str == null) str = "null";
int len = str.length();
if (len == 0) returnthis;
int newCount = count + len;
if (newCount > value.length)
      expandCapacity(newCount);
  str.getChars(0, len, value, count);
  count = newCount;
returnthis;
    }

另外再提供一個技巧,就是比對空字串的時候,一般人會這樣比

a.equals("")

但如果改用下列的方式效率會更好

a.length() == 0

雖然""是直接去String pool裡面拿的,不用再去create一個新的String Object,但是Object的比對總是要比原生型態的效率差一點

以上提供給大家參考. 歡迎大大指較

Adrian Colyer, 首席科学家, Interface21

2006 年 1 月 23 日

依赖项插入和面向方面编程是互补的技术，所以想把它们结合在一起使用是很自然的。请跟随 Adrian Colyer 一起探索两者之间的关系，并了解怎样才能把它们组合在一起，来促进高级的依赖项插入场景。

依赖项插入和面向方面编程 （AOP）是两个关键的技术，有助于在企业应用程序中简化和纯化域模型和应用程序分层。依赖项插入封装了资源和协调器发现的细节，而方面可以（在其他事情 中）封装中间件服务调用的细节 —— 例如，提供事务和安全性管理。因为依赖项插入和 AOP 都会形成更简单、更容易测试的基于对象的应用程序，所以想把它们结合在一起使用是很自然的。方面可以帮助把依赖项插入的能力带到更广的对象和服务中，而依 赖项插入可以用来对方面本身进行配置。

在这篇文章中，我将介绍如何把 Spring 框架的依赖项插入与用 AspectJ 5 编写的方面有效地结合在一起。我假设您拥有基本的 AOP 知识（如果没有这方面知识 ，可以在 参考资料 中找到一些良好的起点），所以我的讨论将从对基于依赖项插入的解决方案中包含的关键角色和职责的分析开始。从这里，我将介绍如何通过依赖项插入配置单体 （singleton）方面。因为配置非单体方面与配置域对象共享许多公共内容，所以后面我会研究一个应用于这两者的简单解决方案。总结这篇文章时，我会 介绍如何为多个高级依赖项插入场景使用方面，其中包括基于接口的插入和重复插入。

关于这个系列 AOP@Work 系列面对的是在面向方面编程上有些基础，想扩展或加深了解的开发人员。同 developerWorks 的大多数文章一样，这个系列高度实用：读完每篇介绍新技术的文章，都可以立即投入实用。 这个系列每个作者的选择，都是因为他们在面向方面编程领域具有领袖地位或专家水平。许多作者都是系列中介绍的项目和工具的参与者。每篇文章都力图提供一个中立的评述，以确保这里表达的观点的公正与正确。 如果有对每个作者文章的评论或问题，请分别与他们联系。要对这个系列整体进行评论，可以与系列的负责人 Nicholas Lesiecki 联系。请参阅 参考资料 获取关于 AOP 的更多背景资料。

请参阅 下载 获得文章的源代码，参阅 参考资料 下载 AspectJ 或 Spring 框架，运行示例需要它们。

什么是依赖项插入？

在 Domain-Driven Design 一书中，Eric Evans 讨论了如何把对象与建立对象的配置和关联的细节隐藏起来：

对象的大部分威力在于对象内部复杂的配置和关联。应当对对象进行提炼，直到与对象的意义或者在交互中支持对象的作用无关的东西都不存在为止。这个中间循环的责任很多。如果让复杂对象负责自己的创建，就会出现问题。

Evans 接着提供了一个汽车引擎的示例：它的众多部件一起协作，执行引擎的职责。虽然可以把引擎块想像成把一组活塞插入气缸，但是这样的设计会把引擎明显地弄复杂。相反，技工或机器人装配引擎，引擎本身只考虑自己的操作。

虽然这个示例是我从书中介绍用于复杂对象创建的工厂 概念一节中取出的，但是我们也可以用这个概念解释依赖项插入技术的动机。

从协作到合约

参考读物 关于依赖项插入的经典介绍，请参阅 Martin Fowler 的 “Inversion of Control Containers and the Dependency Injection Pattern”。关于使用 Spring 的依赖项插入的更多内容，请参阅 Professional Java Development with the Spring Framework。这两者的链接都在 参考资料 中。

针对这篇文章的目的，可以把依赖项插入想像成对象和对象的执行环境之间的合约。对象（执行 ResourceConsumer、 Collaborator 和 ServiceClient 的其中一个角色或全部角色）同意不出去搜索自己需要的资源、它与之协作的合作伙伴或它使用的服务。相反，对象提供一种机制，让这些依赖项可以提供给它。接下来，执行环境同意在对象需要它的依赖项之前，向对象提供所有的依赖项。

解析依赖项的方法在不同的场景中各有不同。例如，在单元测试用例中，对象的执行环境是测试用例本身，所以测试设置代码有责任直接满足依赖项。在集成测试或应用程序在生产环境时，代理 负责寻找满足对象依赖项的资源，并把它们传递给对象。代理的角色通常是由轻量级容器扮演的，例如 Spring 框架。不管依赖项是如何解析的，被配置的对象通常不知道这类细节。在第二个示例中，它可能还不知道代理的存在。

代理（例如 Spring 框架）有四个关键职责，在整篇文章中我将不断提到这些职责，它们是：

• 确定对象需要配置（通常因为对象刚刚创建）
• 确定对象的依赖项
• 发现满足这些依赖项的对象
• 用对象的依赖项对它进行配置

从下面的各种依赖项插入解决方案可以看出，解决这些职责有多种策略。

回页首

使用 Spring 进行依赖项插入

在标准的 Spring 部署中，Spring 容器同时负责创建和配置核心应用程序对象（称为 bean）。因为容器既创建对象，又扮演代理的角色，所以对 Spring 容器来说，确定 bean 已经创建而且需要配置是件轻而易举的小事。通过查询应用程序的元模型，可以确定 bean 的依赖项，元模型通常是在 Spring 的配置文件中用 XML 表示的。

满 足 bean 的依赖项的对象是容器管理的其他 bean。容器充当这些 bean 的仓库，所以可以用名称查询它们（或者在需要的时候创建）。最后，容器用新 bean 的依赖项对其进行配置。这通常是通过 setter 插入完成的（调用新 bean 的 setter 方法，把依赖项作为参数传递进去），虽然 Spring 支持其他形式的插入，例如构造函数插入和查询方法插入（请参阅 参考资料 学习关于使用 Spring 进行依赖项插入的更多内容。）

回页首

方面的依赖项插入

像其他对象一样，方面可以从通过依赖项插入进行的配置中受益。在许多情况下，把方面实现为轻量级控制器 是良好的实践。在这种情况下，方面确定什么时候应当执行某些行为，但是会委托给协作器去执行实际的工作。例如，可以用异常处理策略对象配置异常处理方面。方面会探测出什么时候抛出了异常，并委托处理器对异常进行处理。清单 1 显示了基本的 RemoteException 处理方面：

												
														

														
public aspect RemoteExceptionHandling {
      private RemoteExceptionHandler exceptionHandler;

      public void setExceptionHandler(RemoteExceptionHandler aHandler) {
        this.exceptionHandler = aHandler;
      }

      pointcut remoteCall() : call(* *(..) throws RemoteException+);

      /**
       * Route exception to handler. RemoteException will still 
       * propagate to caller unless handler throws an alternate 
       * exception.
       */
      after() throwing(RemoteException ex) : remoteCall() {
        if (exceptionHandler != null)  
          exceptionHandler.onRemoteException(ex);
      }  
    }

										

研究源代码 如果想查看 RemoteExceptionHandling 方面配置的实际效果，请下载 文章源代码 并运行 testsrc 文件夹中的 RemoteExceptionHandlingTest 测试用例。

现 在我要用依赖项插入，用一个特殊的异常处理策略来配置我的方面。对于这个方面，我可以用标准的 Spring 方式，但是有一个警告。一般来说，Spring 既负责创建 bean，也负责配置 bean。但是，AspectJ 方面是由 AspectJ 运行时创建的。我需要 Spring 来配置 AspectJ 创建的方面。对于单体方面最常见的形式，例如上面的 RemoteExceptionHandling 方面，AspectJ 定义了一个 aspectOf() 方法，它返回方面的实例。我可以告诉 Spring 使用 aspectOf() 方法作为工厂方法，获得方面的实例。清单 2 显示了方面的 Spring 配置：

												
														

														

														
  <beans>      
      <bean name="RemoteExceptionHandlingAspect"
        class="org.aspectprogrammer.dw.RemoteExceptionHandling"
        factory-method="aspectOf">
        <property name="exceptionHandler">
          <ref bean="RemoteExceptionHandler"/>
        </property>
      </bean>

      <bean name="RemoteExceptionHandler" 
        class="org.aspectprogrammer.dw.DefaultRemoteExceptionHandler">
      </bean>
  </beans>


										

我想确保我的方面在远程异常抛出之前得到配置。在示例代码中，我用 Spring 的 ApplicationContext 确保了这种情况，因为它会自动地预先实例化所有单体 bean。如果我使用普通的 BeanFactory，然后再调用 preInstantiateSingletons，也会实现同样的效果。

回页首

域对象的依赖项插入

配置单体方面就像在 Spring 容器中配置其他 bean 一样简单，但是对于拥有其他生命周期的方面来说，该怎么办呢？例如 perthis、pertarget 甚至 percflow 方面？生命周期与单体不同的方面实例，不能由 Spring 容器预先实例化；相反，它们是由 AspectJ 运行时根据方面声明创建的。迄今为止，代理 （Spring）已经知道了对象需要配置，因为它创建了对象。如果我想执行非单体方面的依赖项插入，就需要用不同的策略来确定需要配置的对象已经创建。

非单体方面不是能够从外部配置受益的、在 Spring 容器的控制之外创建的惟一对象类型。例如，需要访问仓库、服务和工厂的域实体（请参阅 参考资料）也会从依赖项插入得到与容器管理的 bean 能得到的同样好处。回忆一下代理的四项职责：

• 确定对象需要配置（通常因为对象刚刚创建）
• 确定对象的依赖项
• 发现满足这些依赖项的对象
• 用对象的依赖项对它进行配置

我 仍然想用 Spring 来确定对象的依赖项，去发现满足这些依赖项的对象，并用对象的依赖项来配置对象。但是，需要另一种方法来确定对象需要配置。具体来说，我需要一个解决方 案，针对那些在 Spring 的容器控制之外，在应用程序执行过程中的任意一点上创建的对象。

SpringConfiguredObjectBroker

我把 Spring 配置的对象叫作 SpringConfigured 对象。创建新的 SpringConfigured 对象之后的需求就是，应当请求 Spring 来配置它。Spring ApplicationContext 支持的 SpringConfiguredObjectBroker 应当做这项工作，如清单 3 所示：

												
														

														
public aspect SpringConfiguredObjectBroker 
    implements ApplicationContextAware {

      private ConfigurableListableBeanFactory beanFactory;

      /**
       * This broker is itself configured by Spring DI, which will
       * pass it a reference to the ApplicationContext
       */
      public void setApplicationContext(ApplicationContext aContext) {
        if (!(aContext instanceof ConfigurableApplicationContext)) {
          throw new SpringConfiguredObjectBrokerException(
            "ApplicationContext [" + aContext +
            "] does not implement ConfigurableApplicationContext"
          );
        }
        this.beanFactory = 
          ((ConfigurableApplicationContext)aContext).getBeanFactory();
      }

      /**
       * creation of any object that we want to be configured by Spring
       */
      pointcut springConfiguredObjectCreation(
                  Object newInstance,
                  SpringConfigured scAnnotation
                  ) 
        : initialization((@SpringConfigured *).new(..)) &&
          this(newInstance) &&
          @this(scAnnotation);

      /**
       * ask Spring to configure the newly created instance
       */
      after(Object newInstance, SpringConfigured scAnn) returning 
       : springConfiguredObjectCreation(newInstance,scAnn)
      {
        String beanName = getBeanName(newInstance, scAnn);
        beanFactory.applyBeanPropertyValues(newInstance,beanName);
      }

      /**
       * Determine the bean name to use - if one was provided in
       * the annotation then use that, otherwise use the class name.
       */
      private String getBeanName(Object obj, SpringConfigured ann) {
        String beanName = ann.value();
        if (beanName.equals(“”)) {
          beanName = obj.getClass().getName();
        }
        return beanName;
      }
    }

										

SpringConfiguredObjectBroker 内部

我将依次分析 SpringConfiguredObjectBroker 方面的各个部分。首先，这个方面实现了 Spring 的 ApplicationContextAware 接口。代理方面本身是由 Spring 配置的（这是它得到对应用程序上下文的引用的方式）。让方面实现 ApplicationContextAware 接口，确保了 Spring 知道在配置期间向它传递一个到当前 ApplicationContext 的引用。

切点 springConfiguredObjectCreation() 用 @SpringConfigured 标注与任何对象的初始化连接点匹配。标注和新创建的实例，都在连接点上作为上下文被捕捉到。最后，返回的 after 建议要求 Spring 配置新创建的实例。bean 名称被用来查询实例的配置信息。我可以以 @SpringConfigured 标注的值的形式提供名称，或者也可以默认使用类的名称。

方面的实现本身可以是标准库的一部分（实际上 Spring 的未来发行版会提供这样的方面），在这种情况下，我需要做的全部工作只是对 Spring 要配置的实例的类型进行标注，如下所示：

												
														
    @SpringConfigured("AccountBean")
    public class Account {
      ...
    }

										

可以在程序的控制下，创建这一类类型的实例（例如，作为数据库查询的结果），而且它们会把 Spring 为它们配置的全部依赖项自动管理起来。请参阅 下载 得到这里使用的 @SpringConfigured 标注的示例。请注意，当我选择为这个示例使用的标注时（因为提供 bean 名称是非常自然的方式），标记器接口使得在 Java™ 1.4 及以下版本上可以使用这种方法。

就像我在这一节开始时讨论的，SpringConfigured 技术不仅仅适用于域实例，而且适用于在 Spring 容器的控制之外创建的任何对象（对于 Spring 本身创建的对象，不需要添加任何复杂性）。通过这种方式，可以配置任何方面，而不用管它的生命周期。例如，如果定义 percflow 方面，那么每次进入相关的控制流程时，AspectJ 都会创建新的方面实例，而 Spring 会在每个方面创建的时候对其进行配置。

回页首

基于接口的插入

迄今为止，我使用了 Spring 容器读取的 bean 定义来确定对象的依赖项。这个方案的一个变体采用合约接口，由客户端声明它的要求。假设前一节的 Account 实体要求访问 AccountOperationValidationService。我可以声明一个接口，如清单 4 所示：

												
														

														
public interface AccountOperationValidationClient {

   public void setAccountOperationValidationService(
      AccountOperationValidationService aValidationService);

}  

										

现在，需要访问 AccountOperationValidationService 的对象必须实现这个接口，并把自己声明为客户。使用与前一节开发的方面类似的方面，我可以匹配实现这个接口的客户对象的所有初始化连接点。由它负责第一个 代理职责：确定什么时候需要配置对象。第二个职责在接口中被明确表达：必须满足的依赖项是验证服务依赖项。我将用一个方面插入所有客户验证服务的依赖项。 方面得到合适服务的最简单方法就是把服务插入到方面自身！清单 5 显示了一个示例：

												
														

														
   /** 
     * ensure that all clients of the account validation service
     * have access to it 
     */
    public aspect AccountOperationValidationServiceInjector {

      private AccountOperationValidationService service;

      /**
       * the aspect itself is configured via Spring DI
       */
      public void setService(AccountOperationValidationService aService){
        this.service = aService;
      }

      /**
       * the creation of any object that is a client of the 
       * validation service
       */
      pointcut clientCreation(AccountOperationValidationClient aClient) :
        initialization(AccountOperationValidationClient+.new(..)) &&
        this(aClient);

      /**
       * inject clients when they are created
       */
      after(AccountOperationValidationClient aClient) returning :
        clientCreation(aClient) {
        aClient.setAccountOperationValidationService(this.service);
      }

    }

										

这个解决方案提供了两级控制。服务本身实际的定义是在 Spring 的配置文件中提供的，就像清单 6 中的 XML 片段示例一样：

												
														

														

														
    <beans>  
      <bean name="AccountOperationValidationServiceInjector"
        class="org.aspectprogrammer.dw.
                  AccountOperationValidationServiceInjector"
        factory-method="aspectOf">
        <property name="service">
        <ref bean="AccountOperationValidationService"/>
          </property>
      </bean>

      <bean name="AccountOperationValidationService" 
        class="org.aspectprogrammer.dw.
                 DefaultAccountOperationValidationService">
      </bean>
    </beans> 

										

服务的客户只需要实现 AccountOperationValidationClient 接口，那么就会自动用 Spring 定义的服务的当前实例对它们进行配置。

回页首

重复插入

在 Spring 中的查询方法插入 查 询方法插入是 Spring 容器支持的一种高级特性：由容器覆盖被管理 bean 的抽象或具体方法，返回在容器中查询另一个命名 bean 的结果。查询通常是非单体 bean。查询依赖项的 bean ，用被查询 bean 类型所声明的返回类型，定义查询方法。Spring 配置文件在 bean 的内部使用 <lookup-method> 元素告诉 Spring 在调用查询方法时应当返回什么 bean 实例。请参阅 参考资料 学习关于这项技术的更多内容。带有 HotSwappable 目标源的 Spring AOP 代理提供了另一种方法。

迄 今为止，我介绍的解决方案都是在对象初始化之后立即配置对象。但是，在某些情况下，客户需要与之协调的对象在运行的时候变化。例如，通过与系统进行交互， 销售团队可以动态地为在线预订应用程序修改报价策略和座位分配策略。与报价策略和座位分配策略交互的预订服务需要的策略实现，应当是预订时的实现，而不是 预订服务第一次初始化的时候实现的版本。在这种情况下，可以把依赖项的插入延迟到客户第一次需要它的时候，并在每次引用依赖项的时候，将依赖项的最新版本 重新插入客户。

这个场景的基本技术包括字段级插入或 getter 方法覆盖。在进入示例之前，我要再次强调：我要介绍的插入技术所面向的对象，是在 Spring 容器的控制之外 创建的。对于 Spring 创建的对象，Spring 容器已经提供了解决这些需求的简单机制。

字段级插入

在下面的示例中，可以看出如何为延迟插入或重复插入应用字段级插入。字段的 get 连接点让我可以确定什么时候进行插入，而字段类型可以确定要插入的依赖项。所以，如果客户声明了这样的一个字段：

												
														
private PricingStrategy pricingStrategy;

										

而在客户的方法中，发现了下面的代码

												
														
this.pricingStrategy.price(.....);

										

那么代码在运行时的执行会形成 pricingStrategy 字段的 get() 连接点，我可以用它插入当前报价策略实现，如清单 7 所示：

												
														

														
    public aspect PricingStrategyInjector {

      private PricingStrategy currentPricingStrategy;

      public void setCurrentPricingStrategy(PricingStrategy aStrategy) {
        this.currentPricingStrategy = aStrategy;
      }

      /**
       * a client is trying to access the current pricing strategy
       */
      pointcut pricingStrategyAccess() : 
        get(PricingStrategy *) &&
        !within(PricingStrategyInjector);  // don’t advise ourselves!

      /**
       * whenever a client accesses a pricing strategy field, ensure they
       * get the latest...
       */
      PricingStrategy around() : pricingStrategyAccess() {
        return this.currentPricingStrategy;
      }
    }

										

请参阅 下载 获得这个技术的实际效果。

服务定位策略

重复插入的一个替代就是用更常规的技术，用服务定位策略技术实现插入客户。例如：

												
														
public interface PricingStrategyLocator {
      PricingStrategy getCurrentPricingStrategy();
}    

										

虽然代价是定义一个额外接口，还会使客户代码更长一些，但是这项技术对于代码清晰性来说具有优势。

回页首

结束语

在这篇文章中，我把依赖项插入看作对象和对象执行的环境之间的合约。对象不愿意外出寻找自己需要的资源、要协作的合作伙伴或者使用的服务。相反，对象提供了一种机制，允许把这些依赖项提供给它。然后，在对象需要依赖项之前，执行环境负责把对象需要的所有依赖项提供给它。

我讨论了依赖项插入解决方案的四个关键职责，这些是代理代表对象获取依赖项时必须解决的问题。最后，我介绍了满足这些需求的许多不同的技术。显然，如果能够 用 Spring 容器初始化并配置对象，那么就应当这么做。对于在 Spring 容器的控制之外创建的对象，例如一些使用非单体实例化模型的域对象或方面，我推荐使用 @SpringConfigured 标注或类似的东西。这项技术让您可以把全部配置信息完全转移到外部的 Spring 配置文件中。

在编写这篇文章的示例时，我采用了 AspectJ 5 的最新里程碑版（到 2005 年 10 月）和 Spring 1.2.4。请 下载 完整的工作示例，开始体验我讨论的想法。testsrc 目录下的测试用例是良好的起点。

回页首

下载

	关于下载方法的信息			Get Adobe® Reader®

回页首

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文。
  
  
• “AOP@Work: 介绍 AspectJ 5” （Adrian Colyer，developerWorks，2005 年 7 月）：AspectJ 5 简介。
  
  
• “轻量级开发的成功秘诀，第 3 部分: Spring 露出水面” （Bruce Tate，developerWorks，2005 年 6 月）：Spring 框架概述。
  
  
• “AOP@Work: 对方面进行单元测试”（Nicholas Lesiecki， developerWorks，2005 年 11 月）：用依赖项插入技术对方面进行单元测试。
  
  
• “Inversion of Control Containers and the Dependency Injection Pattern” （Martin Fowler，2004 年 1 月）：对依赖项插入的经典介绍。
  
  
• Domain-Driven Design: Tackling Complexity in the Heart of Software （Eric Evans；Addison-Wesley，2003 年 8 月）：理解依赖性插入技术动机的良好起点。
  
  
• Professional Java Development with the Spring Framework （Rod Johnson、Juergen Hoeller、Alef Arendsen、Thomas Risberg、Colin Sampaleanu；Wiley，2005 年 7 月）：学习关于用 Spring 进行依赖项插入的更多内容。
  
  
• The Spring Reference Guide：请参阅第 3 章获得关于 Spring 中的查询方法插入的更多内容。
  
  
• AOP@Work 系列：请阅读关于 AOP 实际应用的完整系列。
  
  
• Java 技术专区：数百篇关于 Java 编程各方面的文章。

• Spring 主页：请下载 Spring 框架。
  
  
• AspectJ 主页：请下载最新的 AspectJ 编译器和工具。
  
  
• AJDT 主页：请下载 AspectJ Development Tools for Eclipse。
  
  

• developerWorks blogs：加入 developerWorks 社区。
  
  

回页首

关于作者

		Adrian Colyer 是 Eclipse.org 的 AspectJ 项目的负责人，也是 AJDT 项目的创始人，AJDT 项目在 Eclipse 中为 AspectJ 提供 IDE 支持。在 2005 年 10 月接受 Interface21 的首席科学家一职之前，Adrian 在位于英国 Hursley 的 IBM 软件实验室领导面向方面的软件开发团队。他是 Eclipse AspectJ 图书 Aspect-Oriented Programming with AspectJ and the Eclipse AspectJ Development Tools 的合作者，还经常针对面向方面编程主题进行演讲。

Elliotte Harold, 副教授, Polytechnic University

2005 年 10 月 13 日

JUnit 是 Java™ 语言事实上的 标准单元测试库。JUnit 4 是该库三年以来最具里程碑意义的一次发布。它的新特性主要是通过采用 Java 5 中的标记（annotation）而不是利用子类、反射或命名机制来识别测试，从而简化测试。在本文中，执着的代码测试人员 Elliotte Harold 以 JUnit 4 为例，详细介绍了如何在自己的工作中使用这个新框架。注意，本文假设读者具有 JUnit 的使用经验。

JUnit 由 Kent Beck 和 Erich Gamma 开发，几乎毫无疑问是迄今所开发的最重要的第三方 Java 库。正如 Martin Fowler 所说，“在软件开发领域，从来就没有如此少的代码起到了如此重要的作用”。JUnit 引导并促进了测试的盛行。由于 JUnit，Java 代码变得更健壮，更可靠，bug 也比以前更少。JUnit（它本身的灵感来自 Smalltalk 的 SUnit）衍生了许多 xUnit 工具，将单元测试的优势应用于各种语言。nUnit (.NET)、pyUnit (Python)、CppUnit (C++)、dUnit (Delphi) 以及其他工具，影响了各种平台和语言上的程序员的测试工作。

然而，JUnit 仅仅是一个工具而已。真正的优势来自于 JUnit 所采用的思想和技术，而不是框架本身。单元测试、测试先行的编程和测试驱动的开发并非都要在 JUnit 中实现，任何比较 GUI 的编程都必须用 Swing 来完成。JUnit 本身的最后一次更新差不多是三年以前了。尽管它被证明比大多数框架更健壮、更持久，但是也发现了 bug；而更重要的是，Java 不断在发展。Java 语言现在支持泛型、枚举、可变长度参数列表和注释，这些特性为可重用的框架设计带来了新的可能。

JUnit 的停滞不前并没有被那些想要废弃它的程序员所打败。挑战者包括 Bill Venners 的 Artima SuiteRunner 以及 Cedric Beust 的 TestNG 等。这些库有一些可圈可点的特性，但是都没有达到 JUnit 的知名度和市场占有份额。它们都没有在诸如 Ant、Maven 或 Eclipse 之类的产品中具有广泛的开箱即用支持。所以 Beck 和 Gamma 着手开发了一个新版本的 JUnit，它利用 Java 5 的新特性（尤其是注释）的优势，使得单元测试比起用最初的 JUnit 来说更加简单。用 Beck 的话来说，“JUnit 4 的主题是通过进一步简化 JUnit，鼓励更多的开发人员编写更多的测试。”JUnit 4 尽管保持了与现有 JUnit 3.8 测试套件的向后兼容，但是它仍然承诺是自 JUnit 1.0 以来 Java 单元测试方面最重大的改进。

注意：该框架的改进是相当前沿的。尽管 JUnit 4 的大轮廓很清晰，但是其细节仍然可以改变。这意味着本文是对 JUnit 4 抢先看，而不是它的最终效果。

测试方法

以前所有版本的 JUnit 都使用命名约定和反射来定位测试。例如，下面的代码测试 1+1 等于 2：

												
														
import junit.framework.TestCase;

public class AdditionTest extends TestCase {

  private int x = 1;
  private int y = 1;

  public void testAddition() {
    int z = x + y;
    assertEquals(2, z);
  }

}
										

而在 JUnit 4 中，测试是由 @Test 注释来识别的，如下所示：

												import org.junit.Test;
import junit.framework.TestCase;

public class AdditionTest extends TestCase {

  private int x = 1;
  private int y = 1;

  @Test public void testAddition() {
    int z = x + y;
    assertEquals(2, z);
  }

}
										

使用注释的优点是不再需要将所有的方法命名为 testFoo()、testBar()，等等。例如，下面的方法也可以工作：

												import org.junit.Test;
import junit.framework.TestCase;

public class AdditionTest extends TestCase {

  private int x = 1;
  private int y = 1;

  @Test public void additionTest() {
    int z = x + y;
    assertEquals(2, z);
  }

}
										

下面这个方法也同样能够工作：

												import org.junit.Test;
import junit.framework.TestCase;

public class AdditionTest extends TestCase {

  private int x = 1;
  private int y = 1;

  @Test public void addition() {
    int z = x + y;
    assertEquals(2, z);
  }

}
										

这允许您遵循最适合您的应用程序的命名约定。例如，我介绍的一些例子采用的约定是，测试类对其测试方法使用与被测试的类相同的名称。例如，List.contains() 由 ListTest.contains() 测试，List.add() 由 ListTest.addAll() 测试，等等。

TestCase 类仍然可以工作，但是您不再需要扩展它了。只要您用 @Test 来注释测试方法，就可以将测试方法放到任何类中。但是您需要导入 junit.Assert 类以访问各种 assert 方法，如下所示：

												import org.junit.Assert;

public class AdditionTest {

  private int x = 1;
  private int y = 1;

  @Test public void addition() {
    int z = x + y;
    Assert.assertEquals(2, z);
  }

}
										

您也可以使用 JDK 5 中新特性（static import），使得与以前版本一样简单：

												
														
import static org.junit.Assert.assertEquals;

public class AdditionTest {

  private int x = 1;
  private int y = 1;

  @Test public void addition() {
    int z = x + y;
    assertEquals(2, z);
  }

}
										

这种方法使得测试受保护的方法非常容易，因为测试案例类现在可以扩展包含受保护方法的类了。

回页首

SetUp 和 TearDown

JUnit 3 测试运行程序（test runner）会在运行每个测试之前自动调用 setUp() 方法。该方法一般会初始化字段，打开日志记录，重置环境变量，等等。例如，下面是摘自 XOM 的 XSLTransformTest 中的 setUp() 方法：

												protected void setUp() {

    System.setErr(new PrintStream(new ByteArrayOutputStream()));

    inputDir = new File("data");
    inputDir = new File(inputDir, "xslt");
    inputDir = new File(inputDir, "input");

}
										

在 JUnit 4 中，您仍然可以在每个测试方法运行之前初始化字段和配置环境。然而，完成这些操作的方法不再需要叫做 setUp()，只要用 @Before 注释来指示即可，如下所示：

												
														
@Before protected void initialize() {

    System.setErr(new PrintStream(new ByteArrayOutputStream()));

    inputDir = new File("data");
    inputDir = new File(inputDir, "xslt");
    inputDir = new File(inputDir, "input");

}
										

甚至可以用 @Before 来注释多个方法，这些方法都在每个测试之前运行：

												
														
@Before protected void findTestDataDirectory() {
    inputDir = new File("data");
    inputDir = new File(inputDir, "xslt");
    inputDir = new File(inputDir, "input");
}

 @Before protected void redirectStderr() {
    System.setErr(new PrintStream(new ByteArrayOutputStream()));
}
										

清除方法与此类似。在 JUnit 3 中，您使用 tearDown() 方法，该方法类似于我在 XOM 中为消耗大量内存的测试所使用的方法：

												protected void tearDown() {
  doc = null;
  System.gc();   
} 
										

对于 JUnit 4，我可以给它取一个更自然的名称，并用 @After 注释它：

												
														
@After protected void disposeDocument() {
  doc = null;
  System.gc();   
} 
										

与 @Before 一样，也可以用 @After 来注释多个清除方法，这些方法都在每个测试之后运行。

最后，您不再需要在超类中显式调用初始化和清除方法，只要它们不被覆盖即可，测试运行程序将根据需要自动为您调用这些方法。超类中的 @Before 方法在子类中的 @Before 方法之前被调用（这反映了构造函数调用的顺序）。@After 方法以反方向运行：子类中的方法在超类中的方法之前被调用。否则，多个 @Before 或 @After 方法的相对顺序就得不到保证。

套件范围的初始化

JUnit 4 也引入了一个 JUnit 3 中没有的新特性：类范围的 setUp() 和 tearDown() 方法。任何用 @BeforeClass 注释的方法都将在该类中的测试方法运行之前刚好运行一次，而任何用 @AfterClass 注释的方法都将在该类中的所有测试都运行之后刚好运行一次。

例 如，假设类中的每个测试都使用一个数据库连接、一个网络连接、一个非常大的数据结构，或者还有一些对于初始化和事情安排来说比较昂贵的其他资源。不要在每 个测试之前都重新创建它，您可以创建它一次，并还原它一次。该方法将使得有些测试案例运行起来快得多。例如，当我测试调用第三方库的代码中的错误处理时， 我通常喜欢在测试开始之前重定向 System.err，以便输出不被预期的错误消息打乱。然后我在测试结束后还原它，如下所示：

												
														
// This class tests a lot of error conditions, which
// Xalan annoyingly logs to System.err. This hides System.err 
// before each test and restores it after each test.
private PrintStream systemErr;

@BeforeClass protected void redirectStderr() {
    systemErr = System.err; // Hold on to the original value
    System.setErr(new PrintStream(new ByteArrayOutputStream()));
}

@AfterClass protected void tearDown() {
    // restore the original value
    System.setErr(systemErr);
}
										

没有必要在每个测试之前和之后都这样做。但是一定要小心对待这个特性。它有可能会违反测试的独立性，并引入非预期的混乱。如果一个测试在某种程度上改变了 @BeforeClass 所初始化的一个对象，那么它有可能会影响其他测试的结果。它有可能在测试套件中引入顺序依赖，并隐藏 bug。与任何优化一样，只在剖析和基准测试证明您具有实际的问题之后才实现这一点。这就是说，我看到了不止一个测试套件运行时间如此之长，以至不能像它 所需要的那样经常运行，尤其是那些需要建立很多网络和数据库连接的测试。（例如，LimeWire 测试套件运行时间超过两小时。）要加快这些测试套件，以便程序员可以更加经常地运行它们，您可以做的就是减少 bug。

回页首

测试异常

异常测试是 JUnit 4 中的最大改进。旧式的异常测试是在抛出异常的代码中放入 try 块，然后在 try 块的末尾加入一个 fail() 语句。例如，该方法测试被零除抛出一个 ArithmeticException：

												
														
public void testDivisionByZero() {

    try {
        int n = 2 / 0;
        fail("Divided by zero!");
    }
    catch (ArithmeticException success) {
        assertNotNull(success.getMessage());
    }

}
										

该方法不仅难看，而且试图挑战代码覆盖工具，因为不管测试是通过还是失败，总有一些代码不被执行。在 JUnit 4 中，您现在可以编写抛出异常的代码，并使用注释来声明该异常是预期的：

												
														
@Test(expected=ArithmeticException.class) 
  public void divideByZero() {
    int n = 2 / 0;
}
										

如果该异常没有抛出（或者抛出了一个不同的异常），那么测试就将失败。但是如果您想要测试异常的详细消息或其他属性，则仍然需要使用旧式的 try-catch 样式。

回页首

被忽略的测试

也 许您有一个测试运行的时间非常地长。不是说这个测试应该运行得更快，而是说它所做的工作从根本上比较复杂或缓慢。需要访问远程网络服务器的测试通常都属于 这一类。如果您不在做可能会中断该类测试的事情，那么您可能想要跳过运行时间长的测试方法，以缩短编译-测试-调试周期。或者也许是一个因为超出您的控制 范围的原因而失败的测试。例如，W3C XInclude 测试套件测试 Java 还不支持的一些 Unicode 编码的自动识别。不必老是被迫盯住那些红色波浪线，这类测试可以被注释为 @Ignore，如下所示：

												
														
// Java doesn't yet support 
// the UTF-32BE and UTF32LE encodings
    @Ignore public void testUTF32BE() 
      throws ParsingException, IOException, XIncludeException {

        File input = new File(
          "data/xinclude/input/UTF32BE.xml"
        );
        Document doc = builder.build(input);
        Document result = XIncluder.resolve(doc);
        Document expectedResult = builder.build(
          new File(outputDir, "UTF32BE.xml")
        );
        assertEquals(expectedResult, result);

    }
										

测试运行程序将不运行这些测试，但是它会指出这些测试被跳过了。例如，当使用文本界面时，会输出一个“I”（代表 ignore），而不是为通过的测试输出所经历的时间，也不是为失败的测试输出“E”：

												
														
$ java -classpath .:junit.jar org.junit.runner.JUnitCore 
  nu.xom.tests.XIncludeTest
JUnit version 4.0rc1
.....I..
Time: 1.149

OK (7 tests)
										

但是一定要小心。最初编写这些测试可能有一定的原因。如果永远忽略这些测试，那么它们期望测试的代码可能会中断，并且这样的中断可能不能被检测到。忽略测试只是一个权宜之计，不是任何问题的真正解决方案。

回页首

时间测试

测 试性能是单元测试最为痛苦的方面之一。JUnit 4 没有完全解决这个问题，但是它对这个问题有所帮助。测试可以用一个超时参数来注释。如果测试运行的时间超过指定的毫秒数，则测试失败。例如，如果测试花费 超过半秒时间去查找以前设置的一个文档中的所有元素，那么该测试失败：

												
														
@Test(timeout=500) public void retrieveAllElementsInDocument() {
    doc.query("//*");
} 
										

除 了简单的基准测试之外，时间测试也对网络测试很有用。在一个测试试图连接到的远程主机或数据库宕机或变慢时，您可以忽略该测试，以便不阻塞所有其他的测 试。好的测试套件执行得足够快，以至程序员可以在每个测试发生重大变化之后运行这些测试，有可能一天运行几十次。设置一个超时使得这一点更加可行。例如， 如果解析 http://www.ibiblio.org/xml 花费了超过 2 秒，那么下面的测试就会超时：

												
														
@Test(timeout=2000) 
  public void remoteBaseRelativeResolutionWithDirectory()
   throws IOException, ParsingException {
      builder.build("http://www.ibiblio.org/xml");
  } 
										

回页首

新的断言

JUnit 4 为比较数组添加了两个 assert() 方法：

												
														
public static void assertEquals(Object[] expected, Object[] actual)
public static void assertEquals(String message, Object[] expected, 
Object[] actual)

										

这两个方法以最直接的方式比较数组：如果数组长度相同，且每个对应的元素相同，则两个数组相等，否则不相等。数组为空的情况也作了考虑。

回页首

需要补充的地方

JUnit 4 基本上是一个新框架，而不是旧框架的升级版本。JUnit 3 开发人员可能会找到一些原来没有的特性。

最明显的删节就是 GUI 测试运行程序。如果您想在测试通过时看到赏心悦目的绿色波浪线，或者在测试失败时看到令人焦虑的红色波浪线，那么您需要一个具有集成 JUnit 支持的 IDE，比如 Eclipse。不管是 Swing 还是 AWT 测试运行程序都不会被升级或捆绑到 JUnit 4 中。

下一个惊喜是，失败（assert 方法检测到的预期的错误）与错误（异常指出的非预期的错误）之间不再有任何差别。尽管 JUnit 3 测试运行程序仍然可以区别这些情况，而 JUnit 4 运行程序将不再能够区分。

最后，JUnit 4 没有 suite() 方法，这些方法用于从多个测试类构建一个测试套件。相反，可变长参数列表用于允许将不确定数量的测试传递给测试运行程序。

我对消除了 GUI 测试运行程序并不感到太高兴，但是其他更改似乎有可能增加 JUnit 的简单性。只要考虑有多少文档和 FAQ 当前专门用于解释这几点，然后考虑对于 JUnit 4，您不再需要解释这几点了。

回页首

编译和运行 JUnit 4

当前，还没有 JUnit 4 的库版本。如果您想要体验新的版本，那么您需要从 SourceForge 上的 CVS 知识库获取它。分支（branch）是“Version4”（参见 参考资料）。注意，很多的文档没有升级，仍然是指以旧式的 3.x 方式做事。Java 5 对于编译 JUnit 4 是必需的，因为 JUnit 4 大量用到注释、泛型以及 Java 5 语言级的其他特性。

自 JUnit 3 以来，从命令行运行测试的语法发生了一点变化。您现在使用 org.junit.runner.JUnitCore 类：

												
														
$ java -classpath .:junit.jar org.junit.runner.JUnitCore 
  TestA TestB TestC...
JUnit version 4.0rc1

Time: 0.003

OK (0 tests)
										

兼容性

Beck 和 Gamma 努力维持向前和向后兼容。JUnit 4 测试运行程序可以运行 JUnit 3 测试，不用做任何更改。只要将您想要运行的每个测试的全限定类名传递给测试运行程序，就像针对 JUnit 4 测试一样。运行程序足够智能，可以分辨出哪个测试类依赖于哪个版本的 JUnit，并适当地调用它。

向后兼容要困难一些，但是也可以在 JUnit 3 测试运行程序中运行 JUnit 4 测试。这一点很重要，所以诸如 Eclipse 之类具有集成 JUnit 支持的工具可以处理 JUnit 4，而不需要更新。为了使 JUnit 4 测试可以运行在 JUnit 3 环境中，可以将它们包装在 JUnit4TestAdapter 中。将下面的方法添加到您的 JUnit 4 测试类中应该就足够了：

												
														
public static junit.framework.Test suite() {
  return new JUnit4TestAdapter(AssertionTest.class);    
}
										

但是由于 Java 比较多变，所以 JUnit 4 一点都不向后兼容。JUnit 4 完全依赖于 Java 5 特性。对于 Java 1.4 或更早版本，它将不会编译或运行。

回页首

前景

JUnit 4 远没有结束。很多重要的方面没有提及，包括大部分的文档。我不推荐现在就将您的测试套件转换成注释和 JUnit 4。即使如此，开发仍在快速进行，并且 JUnit 4 前景非常看好。尽管 Java 2 程序员在可预见的未来仍然需要使用 JUnit 3.8，但是那些已经转移到 Java 5 的程序员则应该很快考虑使他们的测试套件适合于这个新的框架，以便匹配。

回页首

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文。
  
  
• Pragmatic Unit Testing in Java with JUnit （Andy Hunt 和 Dave Thomas，Pragmatic Programmers，2003 年）：非常好地介绍了单元测试。
  
  
• JUnit Recipes: Practical Methods for Programmer Testing （J. B. Rainsberger，Manning，2004 年）：一本最广泛地引用和参考了 JUnit 的书籍。
  
  
• TestNG：Cedric Beust 的框架，基于现在用于 JUnit 4 中的测试样式，最先使用了注释。
  
  
• “TestNG 使 Java 单元测试轻而易举”（Filippo Diotalevi，developerWorks，2005 年 1 月）：介绍了 TestNG。
  
  
• “利用 Ant 和 JUnit 进行增量开发”（Malcolm Davis，developerWorks，2000 年 11 月）：探讨了单元测试的优势，具体使用了 Ant 和 JUnit，并有示例代码。
  
  
• “揭开极端编程的神秘面纱: 测试驱动的编程”（Roy Miller，developerWorks，2003 年 4 月）：找出测试驱动的编程可以如何提高程序员的生产效率和质量，并学习编写测试的机制。
  
  
• “Keeping critters out of your code”（David Carew 等人，developerWorks，2003 年 6 月）：学习可以如何将 JUnit 与 WebSphere Application Developer 结合起来使用。
  
  
• “用 Cobertura 测量测试覆盖率”（Elliotte Rusty Harold，developerWorks，2005 年 5 月）：学习用这个方便的开放源码工具来识别未测试的代码和查找 bug。
  
  

• JUnit 4：下载最新版本的 JUnit，即 SourceForge CVS 知识库。确保使用分支“Version4”。
  
  

• developerWorks blogs：加入 developerWorks 社区。

回页首

关于作者

		Elliotte Rusty Harold 出生在新奥尔良，现在，他还定期回老家喝一碗美味的秋葵汤。不过目前他与妻子 Beth 定居在纽约临近布鲁克林的 Prospect Heights，与他们住在一起的还有猫咪 Charm（取自夸克）和 Marjorie（按照他岳母的名字）。他是 Polytechnic 大学计算机科学的副教授，讲授 Java 技术和面向对象编程。他的 Cafe au Lait 网站是 Internet 上最受欢迎的独立 Java 站点之一，姊妹站点 Cafe con Leche 是最受欢迎的 XML 站点之一。他的著作包括 Effective XML、Processing XML with Java、Java Network Programming 和 The XML 1.1 Bible。他目前在研究处理 XML 的 XOM API、Jaxen XPath 引擎和 Jester 测试覆盖工具。

如果使用过用于横切关系的代码，您就会知道缺乏模块性所带来的问题。因为横切行为的实现是分散的，开发人员发现这种行为难以作逻辑思维、实现和更 改。例如，用于日志记录的代码和主要用于其它职责的代码缠绕在一起。根据所解决的问题的复杂程度和作用域的不同，所引起的混乱可大可小。更改一个应用程序 的日志记录策略可能涉及数百次编辑 — 即使可行，这也是个令人头疼的任务。与之形成对比的是面向 Aspect 的编程的基本案例之一。在标题为“Aspect-Oriented Programming”的文章中，一些 AspectJ 作者谈到了性能优化，传统技术可以将程序从 768 行扩充到 35,213 行。用面向 Aspect 技术重写后，代码缩回到 1,039 行，并保持了大多数性能优点。 

AOP 通过促进另一种模块性补充了面向对象的编程，该模块性将横切关系广泛分布的实现聚拢到一个单元。这种单元称为 Aspect，这就是名称面 向 Aspect 的编程的来历。通过划分 Aspect 代码，横切关系变得容易处理。可以在编译时更改、插入或除去系统的 Aspect，甚至重用系 统的 Aspect。

通过示例学习
为了获得对面向 Aspect 的编程更好的感性认识，让我们看一看来自 Xerox PARC 的面向 Aspect 的  Java 编程语言扩展 — AspectJ。在示例中，将使用 AspectJ 来做日志记录。示例是从开放源码 Cactus 框架中抽取出来的， 它简化了服务器端 Java 组件的测试。框架的贡献者决定通过对框架内的所有方法调用进行跟踪来辅助调试。Cactus 的 1.2 版本没有使用  AspectJ 编写，典型方法如下列清单 1 中所示：

清单 1. 日志调用手工插入到每个方法中 
public void doGet(JspImplicitObjects theObjects) throws ServletException
{
  logger.entry("doGet(...)");

  JspTestController controller = new JspTestController();
  controller.handleRequest(theObjects);

  logger.exit("doGet");
}

作为该项目代码约定的一部分，要求每个开发人员将这几行代码插入到他或她所编写的任何方法中。还要求开发人员记录每个方法的参数。如果没有对部分项 目监督进行详尽的代码复查，就很难履行这种约定。在 1.2 版本中，大约有 80 个单独的记录日志调用分布在 15 个类中。在框架的 1.3 版本 中，用单一 Aspect 代替了这 80 多个调用，该 Aspect 自动记录参数和返回值以及方法入口和出口。清单 2 包含了这个  Aspect 的一个作了很大简化的版本（例如，我省略了参数和返回值日志记录）。 

清单 2. 自动应用于每个方法的记录日志调用 
public aspect AutoLog{
  
  pointcut publicMethods() : execution(public * org.apache.cactus..*(..));

  pointcut logObjectCalls() :
    execution(* Logger.*(..));
    
  pointcut loggableCalls() : publicMethods() && ! logObjectCalls();
    
  before() : loggableCalls(){
    Logger.entry(thisJoinPoint.getSignature().toString());
  }
    
  after() : loggableCalls(){
    Logger.exit(thisJoinPoint.getSignature().toString());
  }
}

让我们分解示例并研究 Aspect 做了什么。您将注意到的第一件事是 Aspect 的声明。Aspect 声明类似于类声明，它们都定义 Java 类型，就象类所做的那样。除了其声明以外，该 Aspect 还包含 Pointcut 和 Advice。 

Pointcut 和 join point
要理解 Pointcut，必需知道 join point 是什么。join point  表示在程序执行中明确定义的点。AspectJ 中典型的 join point 包括方法调用、对类成员的访问以及异常处理程序块的执行。 join point 可以包含其它 join point。例如，一个方法调用可能在它返回之前引起其它方法调用。那么，Pointcut 就是一种语 言构造，这种构造根据已定义的标准挑选一组 join point。示例中的第一个 Pointcut 称为 publicMethods，选择  org.apache.cactus 包中的所有公用（public）方法的执行。execution 是一个原始的 Pointcut（就象  int 是一种原始的 Java 类型）。它选择与其括号中定义的方法说明匹配的任何方法的执行。方法说明允许包含通配符；示例中的一个方法说明包含了 几个通配符。第二个名为 logObjectCalls 的 Pointcut 选择了 Logger 类中的所有方法的执行。第三个  Pointcut loggableCalls，通过使用 && ! 合并了前两个 Pointcut，这意味着它选择了除  Logger 类中的公用方法以外，org.apache.cactus 中所有的公用方法。（记录 log 方法将导致无限递归。） 

Advice
既然 Aspect 已经定义了它应该记录的点，它使用 Advice 来完成实际的日志记录。Advice 是在  join point 之前、之后或周围执行的代码。相对于 Pointcut 来定义 Advice，说类似于“在想要记录的每个方法调用之后运行这 些代码”这样的话。因此 Advice 如下：

before() : loggableCalls(){
    Logger.entry(thisJoinPoint.getSignature().toString());
}

Advice 使用 Logger 类，其入口和出口方法类似于下列代码：

public static void entry(String message){
   System.out.println("entering method " + message);
}

在示例中，传递到记录器的 String 是从 thisJoinPoint 派生的，这是一个特殊的反射对象，它允许访问  join point 执行所处的运行时上下文。在 Cactus 实际使用的 Aspect 中，Advice 使用这种对象来检索传递到每个记录的 方法调用中的方法参数。当日志记录 Aspect 应用于代码时，方法调用的结果如下： 

清单 3. AutoLog Aspect 的输出 
entering method: void test.Logging.main(String[])
entering method: void test.Logging.foo()
exiting method: void test.Logging.foo()
exiting method: void test.Logging.main(String[])

Around Advice

Cactus 示例定义了 before() 和 after() Advice。第三种 Advice 名称是 around()，给予  Aspect 的编写者一个机会来影响是否以及何时使用特殊 proceed() 语法执行 join point。下列（有点一般）Advice 是 否执行 Hello 类中的 say 方法是随机的：

void around(): call(public void Hello.say()){
  if(Math.random() > .5){
      proceed();//go ahead with the method call
  }
  else{
      System.out.println("Fate is not on your side.");
  }
}

使用 AspectJ 进行开发
既然您已经对 Aspect 代码的形式特征有了更好的感性认识，让我们暂时把注意力转移到编写 Aspect 的工作上来吧。也就是说，让我们回答这个问题：“如何使上述代码起作用？” 

要让 Aspect 影响正常的基于类的代码，必须将 Aspect 加入到它们要修改的代码中去。要使用 AspectJ 完成这个操作，必须使 用 ajc 编译器来编译类和 Aspect 代码。ajc 既可以作为编译器也可以作为预编译器操作，生成有效的 .class 或 .java 文 件，可以在任何标准 Java 环境（添加一个小的运行时 JAR）中编译和运行这些文件。 

要使用 AspectJ 进行编译，将需要显式地指定希望在给定编译中包含的源文件（Aspect 和类）— ajc 不象 javac 那样简单 地为相关导入模块搜索类路径。之所以这样做，是因为标准 Java 应用程序中的每个类都是相对分离的组件。为了正确操作，一个类只要求其直接引用的类的 存在。Aspect 表示跨越多个类的行为的聚集。因此，需要将 AOP 程序作为一个单元来编译，而不能每次编译一个类。 

通过指定包含在给定编译中的文件，您还可以在编译时插入或抽出系统的各种 Aspect。例如，通过在编译中包含或排除先前描述的日志记录 Aspect，应用程序构建器可以在 Cactus 框架中添加或除去方法跟踪。 

AspectJ 是开放源码的

Xerox 使用“Mozilla 公共许可证”（Mozilla Public License）发布了 AspectJ。对于开放源码爱好者来 说，这是个好消息。对于近期将要采用 AspectJ 的人来说，这也是个好消息：产品免费，如果您觉得发现了严重错误，您有权检查源代码。开放的代码库 还意味着在上市之前，AspectJ 的源代码将得到有效的社会评审。 
 
AspectJ 当前版本的一个重要限制是其编译器只能将  Aspect 加入到它拥有源代码的代码中。也就是说，不能使用 ajc 将 Advice 添加到预编译类中。AspectJ 团队认为这个限制只是 暂时的，AspectJ 网站承诺未来的版本（正式版 2.0）将允许字节码的修改。 

工具支持
AspectJ 发行版包含了几种开发工具。这预示着 AspectJ 将有美好的前景，因为它表明了那部分作者的一个重要承诺， 使 AspectJ 对于开发人员将是友好的。对于面向 Aspect 的系统工具支持尤其重要，因为程序模块可能受到它们所未知的模块所影响。 

随 AspectJ 一起发布的一个最重要的工具是图形结构浏览器，它展示了 Aspect 如何与其它系统组件交互。这个结构浏览器既可以作为流行的 IDE 的插件，也可以作为独立的工具。图 1 显示了先前讨论的日志记录示例的视图。 

图 1.随 AspectJ 一起提供的图形结构浏览器展示了（在其它事物中）AutoLog 建议了哪些方法

除了结构浏览器和核心编译器之外，您还可以从 AspectJ 网站下载一个 Aspect 支持的调试器、一个 javadoc 工具、一个 Ant 任务以及一个 Emacs 插件。

让我们返回到语言特性。 

影响类结构：引入（Introduction）
Pointcut 和 Advice 允许影响程序的动态执行；引入 （Introduction）允许修改程序的静态结构。使用引入（Introduction），Aspect 可以向类中添加新的方法和变量、声明一个类 实现一个接口或将检查异常转换为未检查异常（unchecked exception）。 

引入（Introduction）示例
假设您有一个表示持久存储的数据缓存的对象。要测量数据的“更新程度”，您可能决定向该对象添加时间 戳记字段，以便容易地检测对象是否与后备存储器同步。然而，因为对象表示业务数据，就应该将这种机制性细节从对象中隔离。使用 AspectJ，可以用清 单 4 中所显示的语法来向现有的类添加时间戳记： 

清单 4. 向现有的类中添加变量和方法 
public aspect Timestamp {

  private long valueObject.timestamp;

  public long valueObject.getTimestamp(){
      return timestamp;
  }

  public void valueObject.timestamp(){
      //"this" refers to valueObject class not Timestamp aspect
      this.timestamp = System.currentTimeMillis();
  }
}
 

除了必须限定在哪个类上声明引入的方法和成员变量以外（因此是 valueObject.timestamp），声明引入的方法和成员变量几乎与声明常规类成员相同。 

混合样式继承
AspectJ 允许向接口和类添加成员，允许按 C++ 方式中混合样式继承。如果您希望使清单 4 中的 Aspect  通用化（generalize）以便能够对各种对象重用时间戳记代码，可以定义一个称为 TimestampedObject 的接口，并使用引入 （Introduction）来将相同成员和变量添加到接口而不是添加到具体类中，如清单 5 所示。 

清单 5. 将行为添加到接口 
public interface TimestampedObject {
    long getTimestamp();
 
    void timestamp();
}
//and
public aspect Timestamp {

    private long TimestampedObject.timestamp;

    public long TimestampedObject.getTimestamp(){
        return timestamp;
    }
 
    public void TimestampedObject.timestamp(){
        this.timestamp = System.currentTimeMillis();
    }
}

现在可以使用 declare parents 语法来促使 valueObject 实现您的新接口了。declare parents 和其它 AspectJ 类型表达一样，可以同时应用于多个类型：

declare parents: valueObject || BigvalueObject implements TimestampedObject;

既然已经定义了 TimestampedObject 支持的操作，当出现适当环境时，您可以使用 Pointcut 和 Advice 来自动更新时间戳记。我们将在下一节中涉及它，因为它说明了如何在 Advice 中访问上下文。 

其它 AspectJ 特性
使用 Pointcut，您可以方便地定义环境，加上时间戳记的对象将在其中更新戳记。清单 6 中显示了 Timestamp 的补充，在对写方法的任何调用之后给对象加时间戳记： 

清单 6. 在 Advice 中访问上下文 
pointcut objectChanged(TimestampedObject object) : 
             execution(public void TimestampedObject+.set*(..)) && 
             this(object);
/*TimestampedObject+ means any subclass of TimestampedObject*/

after(TimestampedObject object) :  objectChanged(object){
        object.timestamp();
}

请注意，Pointcut 定义了 after() Advice 使用的参数 — 在本例中，是 TimestampedObject — 在其 上有一个写方法调用。this() Pointcut 标识了所有 join point，其中所有当前执行的对象都属于括号中定义的类型。其它几种类型 的值可以捆绑到 Advice 的参数中，包括方法参数、方法抛出的异常以及方法调用的目标。 

定制编译错误
我发现定制编译错误是 AspectJ 最酷的特性之一。假如您希望隔离一个子系统，以使客户机代码必须通过中间媒介来访问工 作程序对象（这种情况在 Facade 设计模式中出现）。使用 declare error 或 declare warning 语法，您可以定制  ajc 编译器对潜在 join point 的响应，如清单 7 所示。 

清单 7. 定义定制错误 
public aspect FacadeEnforcement {

  pointcut notThruFacade() : within(Client) && call(public * Worker.*(..));
    
  declare error : notThruFacade(): 
    "Clients may not use Worker objects directly.";
}
 

除了 ajc 在编译时彻底检测 within Pointcut 以外（大多数 Pointcut 可以根据运行时信息区别开来），within Pointcut 类似于 this()。 

错误处理
我承认 Java 语言中检查异常（checked exception）的价值。然而，我经常希望有一个变通方法，类似于“将该 异常转换为运行时异常”这样简单的命令。有很多次，我正在编写的方法不对异常作出有意义的响应 — 并且有时该方法的潜在使用程序也不响应。我不希望废弃 异常，但是我也不希望为了找到它而一直跟踪到它的所有调用者。有一些巧妙的方法使用 try/catch 块来完成这个任务，但是没有一种象  AspectJ 中的 declare soft 这样棒。清单 8 中所显示的类试图完成一些 SQL 任务。 

清单 8. 一个具有检查异常的类 
public class SqlAccess {
    
    private Connection conn;
    private Statement stmt;
    

    public void doUpdate(){
        conn = DriverManager.getConnection("url for testing purposes");
        stmt = conn.createStatement();
        stmt.execute("UPDATE ACCOUNTS SET BALANCE = 0");
    }
    
    public static void main(String[] args)throws Exception{
        new SqlAccess().doUpdate();
    }
}

如果我不使用 AspectJ 或在每个方法说明中声明异常，那么我将不得不插入 try/catch 块来处理已检出的  SQLException（几乎从 JDBC API 中的每个方法中抛出这个异常）。使用 AspectJ，我可以使用下列内部 Aspect 来将 它作为 org.aspectj.lang.SoftException 自动重新抛出： 

清单 9. soft 化异常 
private static aspect exceptionHandling{
  declare soft : SQLException : within(SqlAccess);
  
  pointcut methodCall(SqlAccess accessor) : this(accessor) 
    && call(* * SqlAccess.*(..));
    
  after(SqlAccess accessor) : methodCall  (accessor){
    System.out.println("Closing connections.");
    if(accessor.stmt != null){
        accessor.stmt.close();
    }
    if(accessor.conn != null){
        accessor.conn.close();
    }
  }
}

无论 SQLAccess 类中的每个方法是抛出异常还是正常返回，Pointcut 和 Advice 都关闭其后的连接和语句。为每个方法都使 用一个错误处理 Aspect 也许有点矫枉过正，但是如果将要添加使用该连接和语句的任何其它方法，错误处理策略也将应用于它们。这种对新代码自动应用  Aspect 的特性是 AOP 关键的主要优势之一：新代码的作者不必为加入横切行为而了解它们。 

结束语
AspectJ 是否值得使用？Grady Booch 将面向 Aspect 的编程看作是标志软件设计和编写方法基础性转变的三大运动之一。（请在参考资料节 中参阅他的“Through the Looking Glass”。）我赞同他的观点。AOP 解决了面向对象和其它过程性语言未能处理的一块问题空 间。在最近几周我对 AspectJ 的介绍中，我发现它为那些我原以为是编程的基本极限的问题提供了一流的、可重用的解决方案。可以说 AOP 是从我 开始使用对象以来的功能最强大的抽象。 

当然，AspectJ 确实有一条学习曲线。和所有语言或语言扩展一样，在能够充分利用它的所有强大功能之前，您必需领会它的一些微妙之处。但是， 学习曲线并不太陡峭 — 在通读开发人员指南以及完成一些示例以后，我发现自己已经能够编写有用的 Aspect。AspectJ 给人的感觉是很自然， 就好象它填补了您的编程知识缺陷而不是在一个新方向上的扩展。某些 AspectJ 工具还有些粗糙，但是我还没有遇到任何严重问题。 

因为 AspectJ 具有对不可模块化的程序进行模块化的强大功能，我认为它值得立即使用。如果您的项目或公司还没有准备好在生产中使用  AspectJ，可以方便地将 AspectJ 应用于诸如调试和合同履行之类的开发事项。请注意一下这种语言扩展，这将对您有所帮助。 

参考资料 

请单击本文顶部或底部的讨论参与本文的论坛。

可以从 www.aspectj.org 下载 AspectJ 及其相关的工具。 该网站还有 FAQ、邮件列表、精选文章以及到其它 AOP 资源的链接。这是个开始深入研究的好地方。

Grady Booch 的“Through the Looking Glass”（Software Development，2001 年 7 月）讨论了软件工程的未来并预言了多面软件的出现，这种软件同时用多种方法迅速写成。文章将 AOP 引用为编程领域内首批多面运动之一。

另一种多面方法是来自于 IBM Research 团队的 Hyperspaces。Hyperspaces 超越了对横切关系的封装，并尝试管理关系的多维分离。Hyper/J— Hyperspaces 的 Java 支持 — 提供了系统的按需重新模块化。这真是激动人心的功能。

IBM Research 还致力于面向主题（subject）的编程，它提供主题 — 具有唯一系统“视图”的类或类片段的集合。主题按组合规则组成应用程序。

asod.net  通常担当 AOP 信息的中央源。该网站提供到其它 AOP 倡导者的链接、用其它语言的 Aspect 实现、类 Aspect 源代码修改以及关于 Aspect 理论的文章。

AOP 的创始文章之一，“Aspect Oriented Programming”（PDF），提供了这一新编程方法的早期观点。本文开始部分引用的示例就是从这本书上抽取出来的，在这个关于性能优化的示例中，不用 Aspect 需要 35,000 行代码而用它只要 1,000 行。

JavaWorld 提供介绍 AOP 的系列短文，“I want my AOP”。

Eric Allen 的 Diagnosing Java Code 专栏讲述了许多由对横切关系的不一致处理而导致的“错误模式”。Allen 讨论了用 OO 技术使这些错误最小化的方法。“Bug patterns：An introduction”讲述了由重复代码引起的常见类型错误 — 在 OOP 中经常无法避免。他在与异常有关的“The Null Flag bug pattern”中特别提到了 AspectJ。

本文中的日志记录示例是从 Jakarta 的 Cactus 项目中抽取出来的。

请到 developerWorks Java 技术专区查找其它 Java 参考资料。

关于作者
Nicholas Lesiecki 在 .com 的繁荣时期进入了 Java 编程世界，并且随着 Java Tools for Extreme Programming （一份关于如何在诸如 XP 之类灵活过程中利用开放源码构建和测试工具的手册）的出版，他在 XP 和 Java 社区中的地位逐渐变得重要。他目前领导着 eBlox，Inc. 的旗舰在线目录系统 storeBlox 的开发。除了经常在 Tucson JUG 演讲之外，他还积极参与 Jakarta 的 Cactus 项目（一个服务器端单元测试框架）。请通过 ndlesiecki@apache.org 与 Nick 联系。

《Java Threads》的第5章"Minimal Synchronization Techniques"，是这本书中到现在我认为最差的一章了，当然主要是我不喜欢JDK 1.5新推出的Atomic Class，而这一章却花了不少篇章来介绍，且牵强地改造打字程序，又语焉不详地指出这种改造的困难之处和可能带来的副作用，但却又不能从代码的实际运行 中看到这种副作用，很有误导初学者的嫌疑。不过，我想，没有哪个初学者会冒风险为了用Atomic Class而将原本简单明了的算法改造得如此晦涩难懂，并且还有潜在的出错风险。所以，对于Atomic Class，我建议跳过不读，绝对没有什么损失。不过对于其中"5.1.3 Double-Checked Locking"和"5.3 Thread Local Variables"这两节倒要着重读一读，尤其是Thread Local，应该说是Java中一个比较重要的多线程工具。

读到这里，我突然发觉，作为偏参考书的技术书籍，实在不适宜从头到尾采用一个例子，然后结合章节的推广来不断改进这个例子。因为，各章节相对独立， 而读者可能挑任何章节来阅读，那么就会被例子搞到不知所云。所以，如果是我，则会为每个概念或类编写一些小的有针对性的例子，来清除明白地演示其作用。

好了，废话少说。既然看了，还是留下些笔记吧。

Chapter 5. Minimal Synchronization Techniques

由于同步以及锁的获取、释放和等待都是比较费时的操作，因此这一章将介绍JDK 1.5新引进的Atomic Classes来避免显示的同步。在这一章的开头简单介绍了Java的内存模型，可以帮助开发者更好地体会Java线程同步的机制。

5.1 Can You Avoid Synchrnoziation?
1. 多线程开发人员常患有同步狂想症。有太多的关于过度或者错误的同步导致程序运行低下的悲惨故事。由于获取锁需要更多额外的操作，以及必须等待当前拥有锁的线程释放锁，导致同步变成了一个十分昂贵的操作。
2. 是否能够避免使用同步呢？在极少数情况下，可以通过使用volatile变量来避免显示同步的使用；但大多数多线程环境中显然无法避免。
3. 计算机一般通过尽量将数据保存在寄存器以及调整语句的执行顺序来优化程序。

5.1.1 The Effect of Registers
当虚拟机进入一个同步方法或同步块时，它会重新装载缓冲在本地寄存器中的数据；当离开时，则将寄存器中的内容重新写入主存中。

5.1.2 The Effect of Reordering Statements
同步块同样会组织语句的重新排列。虚拟机不能将语句从同步块的内部移到同步块的外面。

5.1.3 Double-Checked Locking
当需要在多线程环境下使用单件模式(Singleton Patter)时，为了避免多个对象的创建，就需要使用同步，但如果每次获取对象都同步则会相当影响性能，因此，就推出了Double-Checked Locking模式。但在早期的JVM中可能会导致错误，在http://www.cs.umd.edu/~pugh/java/memeoryModel 有详细的说明，值得一读。倒不是去验证可能的错误，那篇文章毕竟是98年写的，在现在的JVM中基本上不可能重现这个错误，而是可以很好地了解一下这个设计模式的来历和作用。

5.2 Atomic Variables
(略)

5.3 Thread Local Variables
1. 通过Thread Local可以自动为每个线程保留一份私有拷贝，并且这个过程对调用者来说是透明的。
2. JDK 1.5将ThreadLocal转化成了泛类（Generic Class），可以加强类型检测，并在每次获取时不再需要类型转换。
3. 常见的使用方法：

5.3.1 Inheritable Thread Local Variables

IBM DW上的这篇文章轻松使用线程: 不共享有时是最好的不错，如果要学习ThreadLocal，一定要看看这篇文章:)。

LoopingIterator

ArrayListIterator

FilterIterator

UniqueFilterIterator

IteratorUtils

java.util.Iterator接口定义了标准的Collection遍历方法，但是如果不做改变的使用它，我们得到的是从头到尾一次性的遍历。假如我们需要循环遍历，假如我们需要遍历某一段，假如我们需要遍历满足某些条件的元素，等等等等，我们就不能完全依赖于这个Iterator的标准实现了。除非我们宁可在此基础上在调用的代码中多加一些判断，不过这样的话代码就会显得混乱，时间长了就容易变得难以维护。Commons Collections的这一组Iterator为我们带来了便利。

这些Iterator使用都很一目了然，直接看例子吧：

package sean.study.commons.collections;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.collections.Predicate;

import org.apache.commons.collections.iterators.ArrayListIterator;

import org.apache.commons.collections.iterators.FilterIterator;

import org.apache.commons.collections.iterators.LoopingIterator;

import org.apache.commons.lang.StringUtils;

public class IteratorUsage {

    public static void main(String[] args) {

        demoIteratorUsage();

    }

    public static void demoIteratorUsage() {

        System.out.println(StringUtils.center(" demoClosureUsage ", 40, "="));

        // data setup

        String[] weekDays = {

            "Monday", "Tuesday", "Wednesday",

            "Thursday", "Friday", "Saturday", "Sunday"

        };

        List weekDayList = Arrays.asList(weekDays);

        // workdays

        Iterator iter1 = new ArrayListIterator(weekDays, 0, 5);

        printColl("Partial:", iter1, 5);

        // loop

        Iterator iter2 = new LoopingIterator(weekDayList);

        printColl("Loop:", iter2, 10);

        // looping workdays

        Predicate notWeekendPredicate = new Predicate() {

            public boolean evaluate(Object obj) {

                String str = (String) obj;

                if ("Saturday".equalsIgnoreCase(str)) {

                    return false;

                }

                if ("Sunday".equalsIgnoreCase(str)) {

                    return false;

                }

                return true;

            }

        };

        Iterator iter3 = new FilterIterator(

            new LoopingIterator(weekDayList),

            notWeekendPredicate

        );

        printColl("No Weekends loop:", iter3, 12);

        System.out.println(StringUtils.repeat("=", 40));

    }

    public static void printColl(String label, Iterator iter, int maxCount) {

        if (StringUtils.isNotBlank(label)) {

            System.out.println(label);

        }

        int i = 0;

        while (iter.hasNext() && i < maxCount) {

            System.out.println("# " + iter.next() + " #");

            i++;

        }

    }

}

运行结果如下：

=========== demoClosureUsage ===========

Partial:

# Monday #

# Tuesday #

# Wednesday #

# Thursday #

# Friday #

Loop:

# Monday #

# Tuesday #

# Wednesday #

# Thursday #

# Friday #

# Saturday #

# Sunday #

# Monday #

# Tuesday #

# Wednesday #

No Weekends loop:

# Monday #

# Tuesday #

# Wednesday #

# Thursday #

# Friday #

# Monday #

# Tuesday #

# Wednesday #

# Thursday #

# Friday #

# Monday #

# Tuesday #

========================================

有了这些实用的Iterator类，我们就可以轻松的实现可配置的遍历行为了。

当然，Jakarta Commons提供的API远不止我们提到的这些，除了上述三个核心项目之外，还有读取和映射XML文档的Digester/Betwixt、处理命令行参数的CLI、提供常用编码算法的Codec、用于读取多种格式的配置文件的Configuration、发送电子邮件的Email、上传文件的FileUpload、模拟HTTP客户端的HttpClient、处理日志的Logging等等等等，实在是相当的丰富。

Jakarta Commons官网上可以找到完整的组件列表：

http://jakarta.apache.org/commons/

今后如果发现特别有价值需要跟大家分享的，我还会贴出来，只是不会像这样有条理和规律了。希望我的这一组笔记对大家了解和认识Jakarta Commons有所帮助，也希望这些优秀的类库及其源码能够给大家带来工作效率和编程功底上的提升。

我整理了一份清单，列出了所有这一系列随笔的链接，方便大家查找和阅读：

http://www.blogjava.net/sean/articles/Jakarta_Commons_Notes.html

Closure

ChainedClosure

IfClosure

WhileClosure

ClosureUtils

Closure这一组接口和类提供一个操作对象的execute方法，为我们在处理一系列对象时可以将处理逻辑分离出来。理论上讲，使用Transformer也可以达到类似的效果，只要输出对象和输入对象是同一个对象就好，但是Closure接口定义的execute方法返回void，并且从效果和功能区分上，Closure可以更好的诠释对象处理或执行的意思。而事实上，ClosureUtils中也提供了一个asClosure方法包装一个现成的Transformer。

沿用前面的Emploee类，我们来给一组员工涨工资：

package sean.study.commons.collections;

import java.util.Arrays;

import java.util.Collection;

import java.util.Date;

import java.util.Iterator;

import org.apache.commons.collections.Closure;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang.StringUtils;

public class ClosureUsage {

    public static void main(String[] args) {

        demoClosureUsage();

    }

    public static void demoClosureUsage() {

        System.out.println(StringUtils.center(" demoClosureUsage ", 40, "="));

        // data setup

        Employee[] employees = new Employee[] {

            new Employee("Tony", 26, new Date(), "E4", 2000),

            new Employee("Michelle", 24, new Date(), "E4", 2000),

            new Employee("Jack", 28, new Date(), "E5", 3000)

        };

        Collection empColl = Arrays.asList(employees);

        printColl("Before salary increase:", empColl);

        // closure setup

        Closure salaryIncreaseClosure = new Closure() {

            public void execute(Object obj) {

                Employee emp = (Employee) obj;

                emp.setSalary(emp.getSalary() * 1.20);

            }

        };

        // salary increase

        CollectionUtils.forAllDo(empColl, salaryIncreaseClosure);

        printColl("After salary increase:", empColl);

        System.out.println(StringUtils.repeat("=", 40));

    }

    public static void printColl(String label, Collection c) {

        if (StringUtils.isNotBlank(label)) {

            System.out.println(label);

        }

        Iterator iter = c.iterator();

        while (iter.hasNext()) {

            System.out.println(iter.next());

        }

    }

}

以下是运行结果：

=========== demoClosureUsage ===========

Before salary increase:

Employee[name=Tony,age=26,dateJoined=2005-08-05,grade=E4,salary=2000.0]

Employee[name=Michelle,age=24,dateJoined=2005-08-05,grade=E4,salary=2000.0]

Employee[name=Jack,age=28,dateJoined=2005-08-05,grade=E5,salary=3000.0]

After salary increase:

Employee[name=Tony,age=26,dateJoined=2005-08-05,grade=E4,salary=2400.0]

Employee[name=Michelle,age=24,dateJoined=2005-08-05,grade=E4,salary=2400.0]

Employee[name=Jack,age=28,dateJoined=2005-08-05,grade=E5,salary=3600.0]

========================================

我这里举的是一个相对简单的例子，在Closure这一组还有一些很方便的类，如ChainedClosure可以包装一组Closure作为整体执行；IfClosure在创建时需要提供给它一个Predicate和两个Closure，执行时先做Predicate判定再决定执行哪一个Closure；SwitchClosure跟SwitchTransformer类似，根据创建时传入的Predicate组和Closure组对应执行；WhileClosure则根据创建时传入的Predicate做判断，如果为true则执行Closure，直到Predicate返回false；等等。

Predicate

AndPredicate

OrPredicate

AllPredicate

OnePredicate

NonePredicate

PredicateUtils

Predicate是Commons Collections中定义的一个接口，可以在org.apache.commons.collections包中找到。其中定义的方法签名如下：

public boolean evaluate(Object object)

它以一个Object对象为参数，处理后返回一个boolean值，检验某个对象是否满足某个条件。其实这个Predicate以及上一篇笔记提到的Comparator还有我们即将看到的Transformer和Closure等都有些类似C/C++中的函数指针，它们都只是提供简单而明确定义的函数功能而已。

跟其他组类似，Commons Collections也提供了一组定义好的Predicate类供我们使用，这些类都放在org.apache.commons.collections.functors包中。当然，我们也可以自定义Predicate，只要实现这个Predicate接口即可。在Commons Collections中我们也可以很方便使用的一组预定义复合Predicate，我们提供2个或不定数量个Predicate，然后交给它，它可以帮我们处理额外的逻辑，如AndPredicate处理两个Predicate，只有当两者都返回true它才返回true；AnyPredicate处理多个Predicate，当其中一个满足就返回true，等等。

看看具体的代码中如何使用这些Predicate吧：

package sean.study.commons.collections;

import org.apache.commons.collections.Predicate;

import org.apache.commons.collections.PredicateUtils;

import org.apache.commons.collections.functors.InstanceofPredicate;

import org.apache.commons.collections.functors.NotNullPredicate;

import org.apache.commons.lang.BooleanUtils;

import org.apache.commons.lang.StringUtils;

public class PredicateUsage {

    public static void main(String[] args) {

        demoPredicates();

    }

    public static void demoPredicates() {

        System.out.println(StringUtils.center(" demoPredicates ", 40, "="));

        Predicate p1 = new InstanceofPredicate(String.class);

        Predicate p2 = NotNullPredicate.getInstance();

        Predicate p3 = new Predicate() {

            public boolean evaluate(Object obj) {

                String str = (String) obj;

                return StringUtils.isAlphanumeric(str)

                    && str.length() >= 6

                    && str.length() <= 10;

            }

        };

        Predicate p4 = PredicateUtils.allPredicate(new Predicate[]{p1, p2, p3});                String input = "ABCD1234";

        Object[] raw = new Object[] {

            "Is '",

            input,

            "' a valid input? ",

            BooleanUtils.toStringYesNo(p4.evaluate(input)),

            "."

        };

        System.out.println(StringUtils.join(raw));

        System.out.println(StringUtils.repeat("=", 40));

    }

}

输出结果如下：

============ demoPredicates ============

Is 'ABCD1234' a valid input? yes.

========================================

TypedCollection

CollectionUtils

首先就是这个TypedCollection，它实际上的作用就是提供一个decorate方法，我们传进去一个Collection和需要的类型甄别信息java.lang.Class，它给我们创建一个全新的强类型的Collection。我们其实在bag、buffer、list、map、set这些子包中都可以找到分别对应Bag、Buffer、List、Map、Set接口的TypedXxxx版本。

方法签名：

public static Collection decorate(Collection coll, Class type)

当它执行时，它会判断coll是否为null，同时如果coll包含数据，它会对数据进行验证，看是否满足指定的type条件。最后它返回一个强类型的Collection，当我们对这个强类型的Collection进行add操作时，它会帮我们确保添加的是正确的类型。

而这个CollectionUtils可能大家都已经想到了，就是提供一组针对Collection操作的工具/静态方法。比较有意思的是对Collection的转型、合并、减等操作。

由于这两个类的功能和作用都比较清晰，我就不举例说明了，需要进一步了解的请看Javadoc。

Buffer

BlockingBuffer

BoundedFifoBuffer

PriorityBuffer

UnboundedFifoBuffer

BufferUtils

Buffer是定义在org.apache.commons.collections包下面的接口，用于表示按一定顺序除去成员对象的collection如队列等。具体的实现类在org.apache.commons.collections.buffer包下可以找到。

BufferUtils提供很多静态/工具方法装饰现有的Buffer实例，如将其装饰成BlockingBuffer、执行类型检查的TypedBuffer、或者不可改变的UnmodifiableBuffer等等。

最简单直接的Buffer实现类是UnboundedFifoBuffer，提供先进先出的大小可变的队列。而BoundedFifoBuffer则是对其大小进行了限制，是固定大小的先进先出队列。BlockingBuffer要在多线程的环境中才能体现出它的价值，尤其是当我们需要实现某种流水线时这个BlockingBuffer很有用：每个流水线上的组件从上游的BlockingBuffer获取数据，处理后放到下一个BlockingBuffer中依次传递。BlockingBuffer的核心特色通俗点说就是如果你向它要东西，而它暂时还没有的话，你可以一直等待直至拿到为止。PriorityBuffer则提供比一般的先进先出Buffer更强的控制力：我们可以自定义Comparator给它，告诉它怎么判定它的成员的先后顺序，优先级最高的最先走。

为了方便和清晰的需要，我在这里只举一个BoundedFifoBuffer，包装成TypedBuffer，看看在具体的代码中通常如何使用Buffer：（还是沿用上次的Book类）

package sean.study.commons.collections;

import java.util.Iterator;

import org.apache.commons.collections.Buffer;

import org.apache.commons.collections.BufferUtils;

import org.apache.commons.collections.buffer.BoundedFifoBuffer;

import org.apache.commons.lang.StringUtils;

public class BufferUsage {

    public static void main(String[] args) {

        demoBufferUsage();

    }

    public static void demoBufferUsage() {

        System.out.println(StringUtils.center(" demoBagUsage ", 40, "="));

        // data setup

        Book book1 = new Book("Refactoring Workbook", "7-5083-2208-8", 29.8);

        Book book2 = new Book("J2EE Design Patterns", "7-5083-3099-4", 45);

        Book book3 = new Book("Agile Software Development", "7-5083-1503-0", 59);

        Book book4 = new Book("Professional JSP", "7-5053-8005-2", 100);

        // create a Buffer

        Buffer buffer =

            BufferUtils.typedBuffer(new BoundedFifoBuffer(3), Book.class);

        buffer.add(book1);

        buffer.add(book2);

        buffer.add(book3);

        Book removed = (Book) buffer.remove();

        System.out.println("Removed:");

        System.out.println(removed);

        buffer.add(book4);

        // get items in buffer

        for (int i = 0; i < 3; i++) {

            System.out.println(buffer.get());

            buffer.remove();

        }

        System.out.println(StringUtils.repeat("=", 40));

    }

}

以下是运行结果：

============= demoBagUsage =============

Removed:

sean.study.commons.collections.Book@e09713[

  name=Refactoring Workbook

  ISBN=7-5083-2208-8

  retailPrice=29.8

]

Remaining:

sean.study.commons.collections.Book@e09713[

  name=J2EE Design Patterns

  ISBN=7-5083-3099-4

  retailPrice=45.0

]

sean.study.commons.collections.Book@47b480[

  name=Agile Software Development

  ISBN=7-5083-1503-0

  retailPrice=59.0

]

sean.study.commons.collections.Book@19b49e6[

  name=Professional JSP

  ISBN=7-5053-8005-2

  retailPrice=100.0

]

========================================

我们可以看到，Buffer的add和remove方法分别添加新成员和删除最先加入的成员。由于我们的Buffer定义为只能装3个Book类的实例，所以不论我们试图加入其他类型的对象，或者加入超过3个，操作都将失败。如果我们在遍历时使用get()而不调用remove()，那么我们将得到3个相同的拷贝，而这正是我们期望的FIFO队列的行为。假如你需要遍历并保留数据，可以使用标准的Iterator机制。

BidiMap

MultiMap

LazyMap

MapUtils

Commons Collections在java.util.Map的基础上扩展了很多接口和类，比较有代表性的是BidiMap、MultiMap和LazyMap。跟Bag和Buffer类似，Commons Collections也提供了一个MapUtils。

所谓BidiMap，直译就是双向Map，可以通过key找到value，也可以通过value找到key，这在我们日常的代码-名称匹配的时候很方便：因为我们除了需要通过代码找到名称之外，往往也需要处理用户输入的名称，然后获取其代码。需要注意的是BidiMap当中不光key不能重复，value也不可以。

所谓MultiMap，就是说一个key不在是简单的指向一个对象，而是一组对象，add()和remove()的时候跟普通的Map无异，只是在get()时返回一个Collection，利用MultiMap，我们就可以很方便的往一个key上放数量不定的对象，也就实现了一对多。

所谓LazyMap，意思就是这个Map中的键/值对一开始并不存在，当被调用到时才创建，这样的解释初听上去是不是有点不可思议？这样的LazyMap有用吗？我们这样来理解：我们需要一个Map，但是由于创建成员的方法很“重”（比如数据库访问），或者我们只有在调用get()时才知道如何创建，或者Map中出现的可能性很多很多，我们无法在get()之前添加所有可能出现的键/值对，或者任何其它解释得通的原因，我们觉得没有必要去初始化一个Map而又希望它可以在必要时自动处理数据生成的话，LazyMap就变得很有用了。