Jakarta Commons是Jakarta的子项目，它创建和维护着许多独立软件包，这些包一般与其他框架或产品无关，其中收集了大量小型、实用的组件，大部分面向服务器端编程。 

　　Commons的包分成两部分：Sandbox，Commons代码库。Sandbox是一个测试平台，用来检验各种设想、计划。本文介绍的组件属于Commons代码库，文章将展示各个组件的功能、适用场合，并通过简单的例子介绍其用法。 

　　一、概述

　　可重用性是Jakarta Commons项目的灵魂所在。这些包在设计阶段就已经考虑了可重用性问题。其中一些包，例如Commons里面用来记录日志的Logging包，最初是 为其他项目设计的，例如Jakarta Struts项目，当人们发现这些包对于其他项目也非常有用，能够极大地帮助其他项目的开发，他们决定为这些包构造一个"公共"的存放位置，这就是 Jakarta Commons项目。 

　　为了真正提高可重用性，每一个包都必须不依赖于其他大型的框架或项目。因此，Commons项目的包基本上都是独立的，不仅是相对于其他项目的独立， 而且相对于Commons内部的大部分其他包独立。虽然存在一些例外的情况，例如Betwixt包要用到XML API，但绝大部分只使用最基本的API，其主要目的就是要能够通过简单的接口方便地调用。 

　　不过由于崇尚简洁，许多包的文档变得过于简陋，缺乏维护和支持，甚至有一部分还有错误的链接，文档也少得可怜。大部分的包需要我们自己去找出其用法， 甚至有时还需要我们自己去分析其适用场合。本文将逐一介绍这些包，希望能够帮助你迅速掌握这一积累了许多人心血的免费代码库。 

　　说明：Jakarta Commons和Apache Commons是不同的，后者是Apache Software Foundation的一个顶层项目，前者则是Jakarta项目的一个子项目，同是也是本文要讨论的主角。本文后面凡是提到Commons的地方都是指Jakarta的Commons。 

　　为了便于说明，本文把Commons项目十八个成品级的组件（排除了EL、Latka和Jexl）分成5类，如下表所示。 

　　必须指出的是，这种分类只是为了方便文章说明，Commons项目里面实际上并不存在这种分类，同时这些分类的边界有时也存在一定的重叠。 

　　本文首先介绍Web相关类和其他类里面的组件，下一篇文章将涉及XML相关、包装这两类，最后一篇文章专门介绍属于工具类的包。 

　　二、其他类

　　CLI、Discovery、Lang和Collections包归入其他类，这是因为它们都各自针对某个明确、实用的小目标，可谓专而精。 

　　2.1 CLI

　　■ 概况：CLI即Command Line Interface，也就是"命令行接口"，它为Java程序访问和解析命令行参数提供了一种统一的接口。 

　　■ 官方资源：主页，二进制，源代码

　　■ 何时适用：当你需要以一种一致的、统一的方式访问命令行参数之时。 

　　■ 示例应用：CLIDemo.java。CLASSPATH中必须包含commons-cli-1.0.jar。 

　　■ 说明： 

　　有多少次你不得不为一个新的应用程序重新设计新的命令行参数处理方式？如果能够只用某个单一的接口，统一完成诸如定义输入参数（是否为强制参数，数值还是字符串，等等）、根据一系列规则分析参数、确定应用要采用的路径等任务，那该多好！答案就在CLI。 

　 　在CLI中，每一个想要在命令中指定的参数都是一个Option对象。首先创建一个Options对象，将各个Option对象加入Options对 象，然后利用CLI提供的方法来解析用户的输入参数。Option对象可以要求用户必须输入某个参数，例如必须在命令行提供文件名字。如果某个参数是必须 的，创建Option对象的时候就要显式地指定。 

　　下面是使用CLI的步骤。 

// … // ① 创建一个Options： Options options = new Options(); options.addOption("t", false, "current time"); // … // ② 创建一个解析器，分析输入： CommandLineParser parser = new BasicParser(); CommandLine cmd; try { cmd = parser.parse(options, args); } catch (ParseException pe) { usage(options); return; } // … // ③ 最后就可以根据用户的输入，采取相应的操作： if (cmd.hasOption("n")) { System.err.println("Nice to meet you: " + cmd.getOptionValue('n')); }

　　这就是使用CLI的完整过程了。当然，CLI还提供了其他高级选项，例如控制格式和解析过程等，但基本的使用思路仍是一致的。请参见本文最后提供的示例程序。

　　2.2 Discovery

　　■ 概况：Discovery组件是发现模式（Discovery Pattern）的一个实现，它的目标是按照一种统一的方式定位和实例化类以及其他资源。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：当你想用最佳的算法在Java程序中查找Java接口的各种实现之时。 

　 　■ 应用实 例：DiscoveryDemo.java，MyInterface.java，MyImpl1.java，MyImpl2.java，MyInterface。 要求CLASSPATH中必须包含commons-discovery.jar和commons-logging.jar。 

　　■ 说明： 

　　Discovery的意思就是"发现"，它试图用最佳的算法查找某个接口的所有已知的实现。在使用服务的场合，当我们想要查找某个服务的所有已知的提供者时，Discovery组件尤其有用。 

　 　考虑一下这种情形：我们为某个特别复杂的任务编写了一个接口，所有该接口的实现都用各不相同的方式来完成这个复杂任务，最终用户可以根据需要来选择完成 任务的具体方式。那么，在这种情形下，最终用户应该用什么办法来找出接口的所有可用实现（即可能的完成任务的方式）呢？ 

　 　上面描述的情形就是所谓的服务-服务提供者体系。服务的功能由接口描述，服务提供者则提供具体的实现。现在的问题是最终用户要用某种办法来寻找系统中已 经安装了哪些服务提供者。在这种情形下，Discovery组件就很有用了，它不仅可以用来查找那些实现了特定接口的类，而且还可以用来查找资源，例如图 片或其他文件等。在执行这些操作时，Discovery遵从Sun的服务提供者体系所定义的规则。 

　 　由于这个原因，使用Discovery组件确实带来许多方便。请读者参阅本文后面示例程序中的接口MyInterface.java和两个实现类 MyImpl1.java、MyImple2.java，了解下面例子的细节。在使用Discovery的时候要提供MyInterface文件，把它放 入META-INF/services目录，注意该文件的名字对应接口的完整限定名称（Fully Qualified Name），如果接口属于某个包，该文件的名字也必须相应地改变。 

// … // ① 创建一个类装入器的实例。 ClassLoaders loaders = ClassLoaders.getAppLoaders(MyInterface.class, getClass(), false); // … // ② 用DiscoverClass的实例来查找实现类。 DiscoverClass discover = new DiscoverClass(loaders); // … // ③ 查找实现了指定接口的类： Class implClass = discover.find(MyInterface.class); System.err.println("Implementing Provider: " + implClass.getName());

　 　运行上面的代码，就可以得到在MyInterface文件中注册的类。再次提醒，如果你的实现是封装在包里面的，在这里注册的名字也应该作相应地修改， 如果该文件没有放在正确的位置，或者指定名字的实现类不能找到或实例化，程序将抛出DiscoverException，表示找不到符合条件的实现。下面 是MyInterface文件内容的一个例子：MyImpl2 # Implementation 2。 

　 　当然，实现类的注册办法并非只有这么一种，否则的话Discovery的实用性就要大打折扣了！实际上，按照Discovery内部的类查找机制，按照 这种方法注册的类将是Discovery最后找到的类。另一种常用的注册方法是通过系统属性或用户定义的属性来传递实现类的名字，例如，放弃META- INF/services目录下的文件，改为执行java -DMyInterface=MyImpl1 DiscoveryDemo命令来运行示例程序，这里的系统属性是接口的名字，值是该接口的提供者，运行的结果是完全一样的。 

　 　Discovery还可以用来创建服务提供者的(singleton)实例并调用其方法，语法如下： ((MyInterface)discover.newInstance(MyInterface.class)).myMethod();。注意在这个 例子中，我们并不知道到底哪一个服务提供者实现了myMethod，甚至我们根本不必关心这一点。具体的情形与运行这段代码的方式以及运行环境中已经注册 了什么服务提供者有关，在不同的环境下运行，实际得到的服务提供者可能不同。 

　　2.3 Lang

　　■ 概况：Lang是java.lang的一个扩展包，增加了许多操作String的功能，另外还支持C风格的枚举量。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：当java.lang包提供的方法未能满足需要，想要更多的功能来处理String、数值和System属性时；还有，当你想要使用C风格的枚举量时。 

　　■ 示例应用：LangDemo.java，Mortgage.java，OnTV.java。CLASSPATH中必须包含commons-lang.jar。 

　　■ 说明： 

　 　这个包提供了许多出于方便目的而提供的方法，它们中的大多数是静态的，简化了日常编码工作。StringUtils类是其中的一个代表，它使得开发者能 够超越标准的java.lang.String包来处理字符串。使用这些方法很简单，通常只要在调用静态方法时提供适当的参数就可以了。例如，如果要将某 个单词的首字符改为大写，只需调用：StringUtils.capitalise("name")，调用的输出结果是Name。请浏览 StringUtils API文档了解其他静态方法，也许你会找到一些可以直接拿来使用的代码。本文提供的示例程序示范了其中一些方法的使用。 

　　另一个值得注意的类是RandomStringUtils，它提供了生成随机字符串的方法，用来创建随机密码实在太方便了。 

　　NumberUtils类提供了处理数值数据的方法，许多方法值得一用，例如寻找最大、最小数的方法，将String转换成数值的方法，等等。NumberRange和CharRange类分别提供了创建和操作数值范围、字符范围的方法。 

　 　Builder包里的类提供了一些特殊的方法，可用来构造类的toString、hashCode、compareTo和equals方法，其基本思路 就是构造出类的高质量的toString、hashCode、compareTo和equals方法，从而免去了用户自己定义这些方法之劳，只要调用一下 Builder包里面的方法就可以了。例如，我们可以用ToStringBuilder来构造出类的toString描述，如下例所示： 

public class Mortgage { private float rate; private int years; .... public String toString() { return new ToStringBuilder(this). append("rate", this.rate). append("years", this.years). toString(); } }

*******************************************************************************************
*                                                                                                                                                                                  *
*******************************************************************************************
在上一篇文章中，我们将Jakarta Commons的组件分成了五类，并介绍了其中的Web类和其他类，本文接着介绍XML类和包装类，接下来的最后一篇文章将介绍工具类。注意Commons本身并不进行这种分类，这里进行分类纯粹是为组织方便起见。 

　　一、包装类

　　这一类包含Codec和Modeler两个组件。 

　　1.1 Codec

　　■ 概况：提供常用的编码器和解码器。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：当你需要Base64和Hex编码功能的标准实现之时。 

　　■ 示例应用：CodecDemo.java。要求CLASSPATH必须包含commons-codec-1.1.jar。 

　　■ 说明： 

　　Codec里面的类分成两个包，其中一个包实现的是常用的Base64和Hex编码机制，另一个包是语言、语音方面的编码。两个包的用法相似，鉴于语言、语音的编码并不是很常用，所以下面主要介绍第一个包。 

　　Base64编码主要用于Email传输。定义MIME文档传输的RFC规 定了Base 64编码，从而使得任何二进制数据都可以转换成可打印的ASCII字符集安全地传输。例如，假设要通过Email传输一个图形文件，Email客户端软件 就会利用Base64编码把图形文件的二进制数据转换成ASCII码。在Base64编码中，每三个8位的字节被编码成一个4个字符的组，每个字符包含原 来24位中的6位，编码后的字符串大小是原来的1.3倍，文件的末尾追加"="符号。除了MIME文档之外，Base64编码技术还用于BASIC认证机 制中HTTP认证头的"用户：密码"字符串。 

　 　Base64类的使用相当简单，最主要的两个静态方法是：Base64.encodeBase64(byte[] byteArray)，用于对字节数组中指定的内容执行Base64编码；Base64.decodeBase64(byte[] byteArray)，用于对字节数组中指定的内容执行Base64解码。另外，Base64还有一个静态方法 Base64.isArrayByteBase64(byte[] byteArray)，用于检测指定的字节数组是否可通过Base64测试（即是否包含了经过Base64编码的数据，如前所述，Base64编码的结果 只包含可打印的ASCII字符）。 

byte[] encodedBytes=Base64.encodeBase64(testString.getBytes()); String decodedString=new String(Base64.decodeBase64(encodedBytes)); System.err.println("\'^\'是一个合法的Base64字符吗？" + Base64.isArrayByteBase64(invalidBytes));

　　Hex编码/解码就是执行字节数据和等价的十六进制表示形式之间的转换。Hex编码的编码、解码过程和Base64相似，此处不再赘述。 

　　1.2 Modeler

　　■ 概况：根据JMX（Java Management Extensions）规范的定义，支持对Model MBean（Managed Bean）的配置和实例化。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：当你想要创建和管理Model MBean，以便利用标准的管理API来管理应用之时。 

　 　■ 示例应用：ModelerDemo.java，DemoManagedBean.java和mbeans-descriptors.xml。要求 CLASSPATH中包含commons-modeler-1.0.jar、commons-logging.jar、commons- digester.jar、commons-collections.jar、commons-beanutils.jar，以及Sun的JMX参考实现 jmxri.jar。 

　　■ 说明： 

　　下面的说明要求读者对JMX有一定的了解。 

　 　Managed Bean简称MBean，是一种关联到应用程序中被管理组件的Bean，是一种对资源抽象。Model MBean是一种特殊的MBean，具有高度动态和可配置的特点，但Model MBean的这种能力是有代价的，程序员需要设置大量的元信息来告诉JMX如何创建Model MBean，这些元信息包括组件的属性、操作和其它信息。Modeler的目的就是降低程序员实现Model MBean的工作量，它提供的一组函数为处理元数据信息带来了方便。另外，Modeler还提供了注册工具和一个基本的Model MBean。 

　　Modeler允许以XML文件的形式定义元数据信息，该XML文件应当遵从随同Modeler提供的DTD定义。元数据信息用来在运行时创建注册信息，注册信息是所有Model MBean的中心知识库，实际上相当于一个创建这类Bean的工厂。 

　　下面我们首先为一个Managed Bean（DemoManagedBean）创建这个XML文件。DemoManagedBean有一个name属性，可读写。 

<?xml version="1.0" encoding="GB2312" ?> <!DOCTYPE mbeans-descriptors PUBLIC "-//Apache Software Foundation //DTD Model MBeans Configuration File" "http://jakarta.apache.org/commons/dtds/mbeans-descriptors.dtd"> <!-- JMX MBean的描述 --> <mbeans-descriptors> <mbean name="ManagedBean" description="Example Managed Bean" type="ManagedBean"> <attribute name="name" description="Simple Name" type="java.lang.String" /> <constructor name="ManagedBean"/> </mbean> </mbeans-descriptors>

　 　可以看到，这个XML文件提供了许多ManagedBean的信息，包括它的属性、构造函数，另外还有它的操作（不过本例没有显示），这就是所谓的元数 据信息。如果你打算扩展随同Modeler提供的标准MBean（称为BaseModelMBean），可以在mbean元素中以属性的形式指定 Model MBean的类名称：。在前面的例子中，标准的Model MBean只是简单地把所有调用直接传递给ManagedBean类。 

　　接下来，我们要注册上述信息。注意通过描述文件装入注册信息之后，我们通过一个静态方法提取格式化的注册信息： 

// 创建一个Registry Registry registry = null; try { URL url = ModelerDemo.class.getResource ("mbeans-descriptors.xml"); InputStream stream = url.openStream(); Registry.loadRegistry(stream); stream.close(); registry = Registry.getRegistry(); } catch (Throwable t) { t.printStackTrace(System.out); System.exit(1); }

　　创建好Registry之后，我们要创建一个Model MBean，并将它注册到默认的管理服务器。这样，任何JMX客户程序都可以通过Model MBean调用Managed Bean的功能了。 

// 获得一个Managed Bean实例的句柄 DemoManagedBean mBean = new DemoManagedBean(); // 创建一个Model MBean，并将它注册到MBean服务器 MBeanServer mServer = registry.getServer(); ManagedBean managed = registry.findManagedBean("ManagedBean"); try { ModelMBean modelMBean = managed.createMBean(mBean); String domain = mServer.getDefaultDomain(); ObjectName oName = new ObjectName(domain + ":type=ManagedBean"); mServer.registerMBean(modelMBean, oName); } catch(Exception e) { System.err.println(e); System.exit(0); } try { ObjectName name = new ObjectName(mServer.getDefaultDomain() + ":type=ManagedBean"); ModelMBeanInfo info = (ModelMBeanInfo) mServer. getMBeanInfo(name); System.err.println(" className="+info.getClassName()); System.err.println(" description="+info.getDescription()); System.err.println(" mbeanDescriptor="+info.getMBeanDescriptor()); System.err.println("==== 测试 ===="); System.err.println("Name的原始值: " + mServer.getAttribute(name, "name")); mServer.setAttribute(name, new Attribute("name", "Vikram")); System.err.println("Name的新值: " + mServer.getAttribute(name, "name")); } catch(Exception e) { System.err.println(e); System.exit(0); }

　　虽然这个例子比较简单，但它仍旧清楚地说明了使用Modeler带来的方便，不妨将它与不使用Modeler的情况下创建一个类似的Model MBean相比较。通过XML文件来描述ModelMBeanInfo不仅灵活方便，而且也很容易扩展，比手工编写这类信息改进不少。 

　　二、XML类

　　XML类包含了与Java、XML技术相关的类，包括：Betwixt，Digester，Jelly，和JXPath。 

　　2.1 Betwixt

　　■ 概况：实现XML和JavaBean的映射。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：当你想要以灵活的方式实现XML和Bean的映射，需要一个数据绑定框架之时。 

　　■示例应用：BetwixtDemo.java，Mortgage.java，mortgage.xml。要求CLASSPATH中必须包含 commons-betwixt-1.0-alpha-1.jar、commons-logging.jar、commons- beanutils.jar、commons-collections.jar、以及commons-digester.jar。 

　　■ 说明： 

　　如果你以前曾经用Castor绑定数据，一定会欣赏Betwixt的灵活性。Castor适合在一个预定义模式（Schema）的基础上执行Bean 和XML之间的转换；但如果你只想执行数据和XML之间的转换，最好的选择就是Betwixt。Betwixt的特点就是灵活，能够方便地将数据输出成为 人类可阅读的XML。 

　　Betwixt的用法相当简单。如果要把Bean转换成XML，首先创建一个BeanWriter的实例，设置其属性，然后输出；如果要把XML转换成Bean，首先创建一个BeanReader的实例，设置其属性，然后用Digester执行转换。 

　　将Bean转换成XML： 

// 用Betwixt将Bean转换成XML必须有BeanWriter的实例。 // 由于BeanWriter的构造函数要求有一个写入器对象， // 所以我们从创建一个StringWriter开始 StringWriter outputWriter = new StringWriter(); // 注意输出结果并不是格式良好的，所以需要在开始位置 // 写入下面的内容： outputWriter.write("<?xml version='1.0' ?>"); // 创建一个BeanWriter BeanWriter writer = new BeanWriter(outputWriter); // 我们可以设置该写入器的各种属性。 // 下面的第一行禁止写入ID， // 第二行允许格式化输出 writer.setWriteIDs(false); writer.enablePrettyPrint(); // 创建一个Bean并将其输出 Mortgage mortgage = new Mortgage(6.5f, 25); // 将输出结果写入输出设备 try { writer.write("mortgage", mortgage); System.err.println(outputWriter.toString()); } catch(Exception e) { System.err.println(e); } 将XML转换成Bean： // 用Betwixt来读取XML数据并以此为基础创建 // Bean，必须用到BeanReader类。注意BeanReader类扩展了 // Digester包的Digester类。 BeanReader reader = new BeanReader(); // 注册类 try { reader.registerBeanClass(Mortgage.class); // 并解析它… Mortgage mortgageConverted = (Mortgage)reader.parse(new File("mortgage.xml")); // 检查转换得到的mortgage是否包含文件中的值 System.err.println("Rate: " + mortgageConverted.getRate() + ", Years: " + mortgageConverted.getYears()); } catch(Exception ee) { ee.printStackTrace(); }

　　注意，通过BeanReader注册类时，如果顶层元素的名称和类的名称不同，必须用另一个方法注册并指定准确的路径，如reader.registerBeanClass("toplevelelementname", Mortgage.class)。 

　　2.2 Digester

　　■ 概况：提供友好的、事件驱动的高级XML文档处理API。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：当你想要处理XML文档，而且希望能够根据XML文档中特定的模式所触发的一组规则来执行某些操作时。 

　　■ 示例应用：DigesterDemo.java、 Employee.java、 Company.java、 rules.xml以及company.xml。要求CLASSPATH中必须包含commons-digester.jar、 commons-logging.jar、 commons-beanutils.jar以及commons-collections.jar。 

　　■ 说明： 

　　Digester在解析配置文件的时候最为有用。实际上，Digester最初就是为读取Struts配置文件而开发的，后来才移到Commons包。 

　　Digester是一个强大的模式匹配工具，允许开发者在一个比SAX或DOM API更高的层次上处理XML文档，当找到特定的模式（或找不到模式）时能够触发一组规则。使用Digester的基本思路是：首先创建一个 Digester的实例，然后用它注册一系列模式和规则，最后将XML文档传递给它。此后，Digester就会分析XML文档，按照注册次序来触发规 则。如果XML文档中的某个元素匹配一条以上的规则，所有的规则会按照注册次序被依次触发。 

　　Digester本身带有12条预定义的规则。当XML文档中找到一个特定的模式时，想要调用某个方法吗？很简单，使用预定义的CallMethodRule！另外，你不一定要使用预定的规则，Digester允许用户通过扩展Rule类定义自己的规则。 

　　在指定模式时，元素必须用绝对名称给出。例如，根元素直接用名称指定，下一层元素则通过"/"符号引出。例如，假设company是根元 素，company/employee就是匹配其中一个子元素的模式。Digester允许使用通配符，例如*/employee将匹配XML文档内出现 的所有employee元素。 

　　找到匹配的模式时，关联到该匹配模式的规则内有四个回调方法会被调用，它们是：begin，end，body，和finish。这些方法被调用的时刻 正如其名字所示，例如调用begin和end的时刻分别是遇到元素的开始标记和结束标记之时，body是在遇到了匹配模式之内的文本时被调 用，finish则是在全部对匹配模式的处理工作结束后被调用。 

　　最后，模式可以在一个外部的规则XML文档内指定（利用digester-rules.dtd），或者在代码之内指定，下面要使用的是第一种办法，因为这种办法比较常用。 

　　使用Digester之前要创建两个XML文档。第一个就是数据或配置文件，也就是我们准备对其应用规则的文件。下面是一个例子（company.xml） 

<?xml version="1.0" encoding="gb2312"?> <company> <name>我的公司</name> <address>中国浙江</address> <employee> <name>孙悟空</name> <employeeNo>10000</employeeNo> </employee> <employee> <name>猪八戒</name> <employeeNo>10001</employeeNo> </employee> </company>

　　第二个文件是规则文件rules.xml。rules.xml告诉Digester要在company.xml中查找什么、找到了之后执行哪些操作： 

<?xml version="1.0" encoding="gb2312"?> <digester-rules> <!-- 创建顶层的Company对象 --> <object-create-rule pattern="company" classname="Company" /> <call-method-rule pattern="company/name" methodname="setName" paramcount="0" /> <call-method-rule pattern="company/address" methodname="setAddress" paramcount="0" /> <pattern value="company/employee"> <object-create-rule classname="Employee" /> <call-method-rule pattern="name" methodname="setName" paramcount="0" /> <call-method-rule pattern="employeeNo" methodname= "setEmployeeNo" paramcount="0" /> <set-next-rule methodname="addEmployee" /> </pattern> </digester-rules>

　　这个文件有哪些含义呢？第一条规则，<object-create-rule pattern="company" classname="Company" />，告诉Digester如果遇到了模式company，则必须遵从object-create-rule，也就是要创建一个类的实例！那么要创 建的是哪一个类的实例呢？classname="Company"属性指定了类的名称。因此，解析company.xml的时候，当遇到顶级的 company元素，等到object-create-rule规则执行完毕，我们就拥有了一个Digester创建的Company类的实例。 

　　现在要理解call-method-rule规则也应该不那么困难了，这里call-method-rule的功能是在遇到company/name或company/address模式时调用一个方法（方法的名字通过methodname属性指定）。 

　　最后一个模式匹配值得注意，它把规则嵌套到了匹配模式之中。两种设定规则和模式的方式都是Digester接受的，我们可以根据自己的需要任意选择。 在这个例子中，模式里面定义的规则在遇到company/employee模式时创建一个Employee类的对象，设置其属性，最后用set- next-rule将这个雇员加入到顶层的Company。 

　　创建好上面两个XML文件之后，只要用两行代码就可以调用Digester了： 

Digester digester = DigesterLoader.createDigester(rules.toURL()); Company company = (Company)digester.parse(inputXMLFile);

　　第一行代码装入规则文件，创建一个Digester。第二行代码利用该Digester来应用规则。请参见本文后面提供的DigesterDemo.java完整源代码。 

　　2.3 Jelly

　　■ 概况：一种基于Java和XML的脚本语言。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：简单地说，当你想要一种灵活的、可扩展的XML脚本工具之时。 

　　■ 示例应用：JellyDemo.java，jellydemo.xml以及TrivialTag.java。要求CLASSPATH中必须有 commons-jelly-1.0-dev.jar、dom4j.jar、commons-logging.jar、commons- beanutils.jar以及commons-collections.jar。 

　　■ 说明： 

　　要说清楚Jelly到底是什么以及它扮演着哪种角色是件很不容易的事情。Jelly试图提供一个通用的XML脚本引擎，这种脚本引擎是可以由开发者通 过定制动作和标记扩展的，XML文档之中的元素映射到JavaBean，而XML元素的属性映射到JavaBean的属性。从某种意义上说，Jelly是 一种结合了Betwixt和Digester的工具，但Jelly更强大，具有更好的可扩展性。 

　　一个Jelly系统由多个组件构成。第一个组件是Jelly脚本，它是一种由Jelly引擎解析的XML文档，经过解析的XML文档元素被绑定到 Jelly标记动态处理。第二个组件是Jelly标记，它是一种实现了Jelly的Tag接口的JavaBean，凡是Jelly标记都可以实现 doTag方法，这个doTag方法就是当脚本引擎遇到XML文档中的特定元素时所执行的方法。Jelly正是通过这一机制实现动态的脚本处理能力，从某 种意义上看，有点类似于Digester的工作机制。 

　　Jelly带有许多预定义的标记，其中部分标记提供核心Jelly支持，其他标记用来提供解析、循环、条件执行代码等方面的支持。另外，Jelly还为Ant任务提供了广泛的支持。 

　　要在Java应用程序中使用Jelly，首先要创建一个JellyContext的实例，例如：JellyContext context = new JellyContext();。我们可以把JellyContext对象看成是一个编译和运行Jelly脚本的运行环境。有了JellyContext 就可以运行Jelly脚本。JellyContext的输出实际上是一个XMLOutput类的实例：context.runScript(new File("jellydemo.xml"), output);。 

　　创建自定义标记时，我们既可以覆盖上面提到的doTag方法（如下面的例子所示），或者提供一个执行方法，如invoke()或run()： 

public void doTag(XMLOutput output) throws Exception { // 在这里加入要执行的操作， // 例如设置属性、访问文件系统等… this.intProp = 3; }

　　下面提供了一个定义Jelly脚本的XML文件示例： 

<j:jelly xmlns:j="jelly:core" xmlns:define="jelly:define" xmlns:tr="trivialTag"> <define:taglib uri="trivialTag"> <define:jellybean name="trivial" className="TrivialTag" /> </define:taglib> <tr:trivial intProp="1" stringProp="ball">Hello World</tr:trivial> </j:jelly>

　　这个例子用到jelly:define和jelly:core标记，以及一个trivialTag标记。当遇到trivial标记实例时，Jelly创建相应的JavaBean的实例，执行doTag方法（或者也可以是一个run或invoke之类可调用的方法）。 

　　Jelly还有许多其他功能，它既可以直接从命令行或Ant脚本运行，也可以嵌入到应用程序的代码之内，请参见Jelly文档了解详情。 

　　2.4 JXPath

　　■ 概况：Java中的XPath解释器。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：当你想要在JavaBean、DOM或其他对象构成的结构中应用XPath查询之时。 

　　■ 示例应用：JXPathDemo.java，Book.java，Author.java。要求CLASSPATH必须包含commons-jxpath-1.1.jar。 

　　■ 说明： 

　　下面的说明要求读者已具备基本的XPath知识。 

　　XPath是一种查询XML文档的语言，JXPath将同一概念应用到了其他Java对象的查询，诸如JavaBean、Collection、Array和Map等。 

　　JXPathContext是JXPath中的核心类，它利用一个工厂方法来定位和创建一个上下文的实例。由于有了这一机制，必要时开发者可以插入一 个新的JXPath的实现。要使用JXPathContext，只要简单地向它传递一个JavaBean、Collection或Map，例 如：JXPathContext context = JXPathContext.newContext(book);。 

　　利用JXPathContext可执行许多任务。例如访问属性或嵌套属性，当然还可以设置属性： 

System.err.println(context.getValue("title")); System.err.println(context.getValue("author/authorId")); context.setValue("author/authorId", "1001");

　　利用JXPath还可以查找其他类型的对象，不过创建上下文对象的方式都一样，都是用上面介绍的静态方法获得一个新的上下文，传入想要查询的对象。 

　　结束语：有关包装类和XML类的介绍就到这里结束。在下一篇也是最后一篇文章中，我们将了解工具类的包。 

　　请从这里下载本文代码：jakartacommons2code.zip。 
*******************************************************************************************
*                                                                                                                                                                                  *
*******************************************************************************************
在这个系列文章的第一篇中，我们把Commons项目包含的组件分成了5类，介绍了Web类和其他类。第二篇文章论及XML类和包装类。这是最后一篇，探讨工具类的组件。注意Commons本身并不进行这种分类，这里进行分类纯粹是为说明和组织方便起见。 

工具类包含BeanUtils、 

Logging、DBCP、Pool和 

Validator这几个组件。 

一、BeanUtils

■ 概况：提供了动态操作JavaBean的工具。 

■ 官方资源：主页，二进制，源代码。 

■ 何时适用：当你需要动态访问JavaBean，但对已编译好的accessor和 

modifier一无所知之时。被动态访问的JavaBean必须遵从JavaBeans 

specification定义的命名设计规范。 

■ 示例应用：BeanUtilsDemo.java，AppLayer1Bean.java， 

AppLayer2Bean.java，SubBean.java。要求CLASSPATH中必须包含commons-beanutils.jar、 

commons-logging.jar以及commons-collections.jar。 

■ 说明： 

在动态Java应用程序设计环境中，我们不一定能够预先获知JavaBean的各种set、get方法。即使已经知道了这些方法的名字，为Bean的每个 属性依次写出setXXX或getXXX方法也是一件很麻烦的事情。考虑一下这种情形：几个几乎完全相同的Bean从应用的一个层传递到另一个层，你会为 每一个属性调用bean1.setXXX(bean2.getXXX())吗？虽然你可以这么做，但并非一定得这么做，因为你可以让BeanUtils为 你完成这些繁琐的操作！BeanUtils可以帮助开发者动态地创建、修改和复制JavaBean。 

BeanUtils能够操作符合下列条件的JavaBean： 

⑴ JavaBean必须提供一个没有参数的构造函数。 

⑵ JavaBean的属性必须能够通过getXXX和setXXX方法访问和修改。对于Boolean属性，也允许使用isXXX和setXXX。JavaBean的属性可以是只读或只写的，也就是说，允许只提供属性的set或get方法。 

⑶ 如果不采用传统的命名方式（即用get和set），改用其它方式命名JavaBean的accessor和modifier，那么必须通过与JavaBean关联的BeanInfo类声明这一点。 

下面来看一个简单的例子。 

要获取和设置JavaBean的简单属性，分别使用PropertyUtils. 

getSimpleProperty(Object bean, String name)以及PropertyUtils. 

setSimpleProperty(Object bean, String name, Object value)方法。如下面的例子所示，其中AppLayer1Bean.java和AppLayer2Bean.java定义了两个测试用的JavaBean。 

PropertyUtils.setSimpleProperty(app1Bean,"intProp1", new Integer(10)); System.err.println("App1LayerBean, stringProp1: " + PropertyUtils.getSimpleProperty(app1Bean, "stringProp1"));

既然我们可以通过直接调用Bean的方法（app1Bean.getStringProp1()或 

app1Bean.setIntProp1(10)）来获取或设置Bean的属性，为什么还要使用setSimpleProperty、 getSimpleProperty方法呢？这是因为，我们不一定能够预先知道JavaBean属性的名字，因此也不一定知道要调用哪些方法才能获取/设 置对应的属性。这些属性的名字可能来自其他过程或外部应用程序设置的变量。因此，一旦搞清楚了JavaBean的属性的名字并把它保存到一个变量，你就可 以将变量传递给PropertyUtils，再也不必依靠其他开发者才能预先得知正确的方法名字。 

　　那么，如果JavaBean的属性不是简单数据类型，又该怎么办呢？例如，JavaBean的属性可能是一个Collection，也可能是一个 Map。在这种情况下，我们要改用PropertyUtils.getIndexedProperty或 PropertyUtils.getMappedProperty。对于集合类属性值，我们必须指定一个索引值，规定待提取或设置的值在集合中的位置；对 于Map类属性，我们必须指定一个键，表示要提取的是哪一个值。下面是两个例子： 

PropertyUtils.setIndexedProperty( app1Bean, "listProp1[1]", "新字符串1"); System.err.println("App1LayerBean, listProp1[1]: " + PropertyUtils.getIndexedProperty(app1Bean, "listProp1[1]"));

　　请注意，对于可索引的属性，索引值是通过方括号传递的。例如上面的例子中，我们把JavaBean（app1Bean）的List中索引为1的值设置 成了"新字符串1"，后面的一行代码又从索引1的位置提取同一个值。还有另一种方式也可以达到同样的目标，即使用 PropertyUtils.setIndexedProperty(Object bean, String name, int index, Object value)和PropertyUtils.getIndexedProperty(Object bean, String name, int index)方法，在这两个方法中索引值作为方法的参数传递。对于Map类属性，也有类似的方法，只要改用键（而不是索引）来获取或设置指定的值。 

　　最后，Bean的属性可能也是一个Bean。那么，怎样来获取或设置那些以属性的形式从属于主Bean的属性Bean呢？只要使用 PropertyUtils.getNestedProperty(Object bean, String name)和PropertyUtils.setNestedProperty(Object bean, String name, Object value)方法就可以了。下面提供了一个例子。 

// 访问和设置嵌套的属性 PropertyUtils.setNestedProperty( app1Bean, "subBean.stringProp", "来自SubBean的信息，通过setNestedProperty设置。"); System.err.println( PropertyUtils.getNestedProperty(app1Bean, "subBean.stringProp"));

通过上面的例子可以看出，从属Bean的属性是通过一个句点符号访问的。 

上述几种访问属性的方式可以结合在一起使用，嵌套深度不受限制。具体要用到的两个方法是 PropertyUtils.getProperty(Object bean, String name)和PropertyUtils.setProperty(Object bean, String name, Object value)。例如：PropertyUtils.setProperty(app1Bean, "subBean.listProp[0]", "属性的值");。 

这个例子是把嵌套Bean对象和可索引属性结合在一起访问。 

　BeanUtils经常用于动态访问Web应用中的请求参数。实际上，正是BeanUtils触发了Struts项目中把请求参数动态转换成系统 JavaBean的灵感：利用代码把用户填写的表单转换成一个Map，其中参数的名字变成Map中的键，参数的值则来自于用户在表单中输入的数据，然后由 一个简单的BeanUtils.populate调用把这些值转换成一个系统Bean。 

　　最后，BeanUtils提供了一个一步到位的方法把数据从一个Bean复制到另一个Bean： 

// 把app1Bean的数据复制到app2Bean BeanUtils.copyProperties(app2Bean, app1Bean);

BeanUtils还有一些这里尚未提及的实用方法。不过不必担心，BeanUtils是Commons中文档较为完善的组件之一，建议读者参阅BeanUtils包的JavaDoc文档了解其余方法的相关信息。 

二、Logging

■ 概况：一个封装了许多流行日志工具的代码库，并提供统一的日志访问接口。 

■ 官方资源：主页，二进制，源代码。 

■ 何时适用：当你的应用需要一种以上的日志工具之时，或者预期以后会有这种需要之时。 

■ 示例应用：LoggingDemo.java，commons-logging.properties。要求CLASSPATH中必须包含 

commons-logging.jar，有时还需要log4j.jar。 

■ 说明： 

日志（Logging）使得我们能够调试和跟踪应用程序任意时刻的行为和状态。在任何规模较大的应用中，Logging都是不可或缺的组成部分，因此现在 已经有许多第三方Logging工具，它们免去了开发者自己编写Logging API之劳。实际上，即使JDK也带有构造好了的Logging API。既然已经有这么多选择（log4j，JDK，Logkit，等等），通常我们总是可以找到最适合自己应用要求的现成API。 

不过也有可能出现例外的情形，例如一个熟悉的Logging API不能和当前的应用程序兼容，或者是由于某种硬性规定，或者是由于应用的体系结构方面的原因。Commons项目Logging组件的办法是将记录日 志的功能封装为一组标准的API，但其底层实现却可以任意修改和变换。开发者利用这个API来执行记录日志信息的命令，由API来决定把这些命令传递给适 当的底层句柄。因此，对于开发者来说，Logging组件对于任何具体的底层实现都是中立的。 

如果你熟悉log4j，使用Commons的Logging API应该不会有什么问题。即使你不熟悉log4j，只要知道使用Logging必须导入两个类、创建一个Log的静态实例，下面显示了这部分操作的代码： 

import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; public class LoggingDemo { private static Log log = LogFactory.getLog (LoggingDemo.class); // ... }

　　有必要详细说明一下调用LogFactory.getLog()时发生的事情。调用该函数会启动一个发现过程，即找出必需的底层日志记录功能的实现， 具体的发现过程在下面列出。注意，不管底层的日志工具是怎么找到的，它都必须是一个实现了Log接口的类，且必须在CLASSPATH之中。 Commons Logging API直接提供对下列底层日志记录工具的支持：Jdk14Logger，Log4JLogger，LogKitLogger，NoOpLogger （直接丢弃所有日志信息），还有一个SimpleLog。 

　　⑴ Commons的Logging首先在CLASSPATH中寻找一个commons-logging.properties文件。这个属性文件至少必须定 义org.apache.commons.logging.Log属性，它的值应该是上述任意Log接口实现的完整限定名称。 

　　⑵ 如果上面的步骤失败，Commons的Logging接着检查系统属性org.apache.commons.logging.Log。 

　　⑶ 如果找不到org.apache.commons.logging.Log系统属性，Logging接着在CLASSPATH中寻找log4j的类。如果 找到了，Logging就假定应用要使用的是log4j。不过这时log4j本身的属性仍要通过log4j.properties文件正确配置。 

　　⑷ 如果上述查找均不能找到适当的Logging API，但应用程序正运行在JRE 1.4或更高版本上，则默认使用JRE 1.4的日志记录功能。 

　　⑸ 最后，如果上述操作都失败，则应用将使用内建的SimpleLog。SimpleLog把所有日志信息直接输出到System.err。 

　　获得适当的底层日志记录工具之后，接下来就可以开始记录日志信息。作为一种标准的API，Commons 

Logging API主要的好处是在底层日志机制的基础上建立了一个抽象层，通过抽象层把调用转换成与具体实现有关的日志记录命令。 

　　本文提供的示例程序会输出一个提示信息，告诉你当前正在使用哪一种底层的日志工具。请试着在不同的环境配置下运行这个程序，例如，在不指定任何属性的情况下运行这个程序，这时默认将使用 

Jdk14Logger；然后指定系统属性-Jorg.apache.commons.logging.Log=org.apache.commons. 

logging.impl.SimpleLog再运行程序，这时日志记录工具将是SimpleLog；最后，把Log4J的类放入CLASSPATH，只要正确设置了log4j的log4j.properties配置文件，就可以得到Log4JLogger输出的信息。 

三、Pool

　　■ 概况：用来管理对象池的代码库。 

　　■ 官方资源：主页，二进制，源代码。 

　　■ 何时适用：当你需要管理一个对象实例池之时。 

　　■示例应用：PoolDemo.java和MyObjectFactory.java。要求CLASSPATH中必须有 

commons-pool.jar和commons-collections.jar。