对象，无处不在的对象
　　在这个由四部分组成的系列文章的第一部分，我们将弄清什么是数据绑定，与在 Java 应用程序中处理 XML 数据的其它方法相比它有什么优势，以及如何开始使用它。这一部分将考查为什么使用数据绑定，以及如何为各种约束建立模型，使 XML 文档能转换成 Java 对象。同时还涵盖用于生成数据绑定类的输入和输出。
　　您希望在您的 Java 应用程序中使用 XML 吗？那么好，同成千上万的其他人一起上这条船吧。当您深入了解 XML 以后，也许您会发现 DOM 和 SAX API（请参阅参考资料）不过是唬人的东西。您可能认为肯定存在某种简单方法可以取得 XML 文档，并通过 Java 应用程序访问它，对吗？不必通过回调或复杂的树状结构，而是使用像 setOwner(Stringowner) 和 int getNumOrders() 这样的方法，对吗？如果您曾经沿着这一思路考虑问题，那么数据绑定就是您要寻找的解决方案。
　　分析各种选择
　　当今各种 XML 和 XML 主义正泛滥成灾（XSL、RDF、命名空间、RSS、XML Schema、XSLT...），您可能认为现在会有很多方法去访问 Java 应用程序中的 XML 数据。令人惊讶的是，如果您寻根究底，实际只存在三种访问 XML 数据的方法。没错 -- 只有三种方法，其中的一种还是最近随一种新的 Java API 才出现的。
　　应该这样来看待这一问题：选择范围小使您更易于选出适合于您的方法。
　　回调
　　回调是作为一种事件驱动模型工作的。当分析 XML 文档时，某些事件 -- 如文档的起始和某个元素中的字符数据的起始 -- 将触发回调方法。通过使用执行逻辑所需的数据，您可以实现这些事件的 Java 代码。要弄清这种方法不能全靠直觉；开发人员通常要花费一段时间来理解和掌握回调模型的使用。SAX，用于 XML 的一种简单 API，是这种 XML 使用方法的事实上的标准。
　　树
　　更常见、更流行的是这种 API，它们取得一个 XML 文档，然后创建数据的树状结构。XML 文档成为树首，充当一种容器。它有若干子级，如根元素。根元素又有其附加的子级，依此类推，直到（在某种意义上）获得 XML 数据的一幅图为止。因为几乎每个大学生在某个阶段肯定都处理过树状结构，所以这就可用作表示 XML 数据的一种非常直观的方法。
　　用于 XML 文档树状表示的最流行的 API 就是 W3C 的推荐标准，即文档对象模型 (DOM)。一种更新的 API，JDOM （这不是首字母缩写词）最近也正一直在推广并流行开来。（虽然这个方案是我和 Jason Hunter 建立的，但我还得说实话。）另外，DOM 和 JDOM 都是 Spinnaker 方案设计的基本要求，Spinnaker 是一种新的 XML 分析器，它作为 Apache XML 方案的一部分正在开发之中。
　　虽然树状 API 看起来比事件驱动的 SAX 更易于使用，但它们并不总是合适的。非常大的文档可能需要大量的内存（尤其是使用 DOM 时）；当对树结构执行转换 (XSLT) 时，系统可能停止运转甚至彻底崩溃。虽然更新的 API（如 JDOM）能处理这些问题，但如果您必须处理极大量的数据，它们仍将是一个问题。并且，有时开发人员宁愿将 XML 文档中的数据建模为一个简单的带有值的读写方法的 Java 对象，而不用树状模型工作。例如，开发人员会宁愿不去访问名为 skuNumber 的子节点并设置该节点的文本值，而只想调用 setSkuNumber("mySKU") 并继续进行。
　　术语解释
　　数据绑定:从 Java 应用程序内部访问 XML 数据的一种新方法，使用仍在开发中的一种 API，JSR-031。
　　JSR-031: Sun 仍在开发中的一种新的 Java 规范请求，设计用于将 XML 文档编译成一个或多个 Java 类，而在 Java 应用程序中可以方便地使用这些 Java 类。
　　打包:将 Java 对象转换为 XML 表示，拥有当前值。
　　解包:根据 XML 对象创建 Java 对象，通常是根据打包生成一个 Java 对象。
　　用 Java 代码访问 XML 数据的最新方法要依赖于一套新的 Java 方法和相关的 API，这些 API 仍在开发之中。数据绑定是由 Sun 构建的一种“Java 规范要求”（JSR-031，见参考资料），它设计用于使 Java 对象绑定到 XML 文档更加方便，这样就使一种格式能够容易地转换为另一种格式，反之亦然。绑定引用一个具有读写方法的 Java 对象，读写方法都会影响到底层的 XML 文档，并且也都直接映射为 XML 文档中的元素及特征的名称。当您进入到本系列文章下一部分中的某些细节时，这一说明会更有意义，但在目前，只说一点就够了：这样做使 XML 文档特征 name 能够通过一个称为 setName() 的方法，来更改它的值，就像我上面暗示的那样。
　　数据绑定
　　这种访问方式正在得到普及，并且当在 XML 文档中存储配置信息时特别有用。许多开发人员发现，它非常便于直接访问所需的参数，而无须使用更复杂的树状结构。虽然这种访问对于文档转换或消息传送没有什么用处，但它对于简单数据处理是极其方便的。它是我们在本文及本系列文章中关注的第三种使用 XML 的方法。
　　（当然，任何方法随后都会引出一系列新的术语，所以请查看术语解释以了解这些新的行话。）
　　是否任何 XML 文档都可以转换为 Java 对象？还是仅有某些类型的 XML 文档才可以？问得好！您很可能只希望将满足一组约束条件的文档转换为 Java 对象。这与定义 Java 接口的方法类似：您确保只实例化和使用适应该接口的对象，允许就如何操作该对象作出假定。同样，您只允许将满足一组约束条件的 XML 对象转换成 Java 对象；这使您能够按希望的方式来使用所创建的对象。
　　约束数据
　　在研究代码之前，您需要回答几个有关如何表示 XML 数据的问题。这是数据绑定的最具挑战性的方面之一。是为每个文档创建一个新类，还是创建某个现有类的一个实例？您要使用哪个现有类？并且最重要的是，您正在处理的文档是否适宜转换为 Java 对象？
　　那是一大堆问题，但您将在这里找到全部答案。将这些问题看作一系列决策点，一系列选择。首先，您必须确定您能否从该 XML 文档创建 Java 对象（如前面所讨论的那样）。如果能，您就要决定转换应该以新 Java 类的形式出现，还是仅以现有类的一个实例的形式出现。最后，如果选择了现有类，那么使用哪个类呢？结果就是各种各样的决策树。
　　如果我们考察清单 1 中所示的一个示例 XML 文档，然后再来处理这些问题，则决策树的意义就更加清楚了。此示例文档表示 Enhydra Application Server 中某个服务（具体说就是一个 web 容器）的配置。
　　清单 1. 一个用于配置 Enhydra 中的 web 容器的 XML 文档 ＜?xml version="1.0"?＞
　　＜webServiceConfiguration version="1.0" name="My Web Container" ＞
　　＜port number="80" protocol="http" protected="false" /＞
　　＜document root="/usr/local/enhydra/html" index="*.html,*.xml" error="error.html" /＞
　　＜/webServiceConfiguration＞
　　此配置文档包含有关服务本身的版本和名称的信息，以及几个嵌套的项目，每个项目都表示有关该 web 容器服务的一些附加信息。它给出了有关端口的详细信息（包括端口号、协议和安全性），也给出了文档服务信息（包括文档根、用于索引页的默认扩展名以及错误页）。所有这些合在一起，就是配置一个新的 web 容器服务所需的全部信息。
　　记住这个示例，您就可以开始回答数据表示的各个问题了。
　　是否适合转换？
　　绝对适合！只要看一看清单 1 中的 XML 文档就会发现，它表示一个对象（总体配置对象），具有若干特征或变量。其中某些变量又是另外的对象（端口和文档），这些对象又具有它们自己的特征。实际上，这是适合转换为 Java 对象的 XML 文档的一个极好例子。为了进一步保证此对象是可用的，稍后我将向您展示一种方法来约束文档中的数据。但是，还是先让我们继续沿着决策树往下走。
　　转换成类还是实例？
　　解决适宜性问题以后，现在就可以作出决定，是将每个 XML 配置文档都变为一个全新的 Java 类呢，还是简单地将其变为某个现有类的一个新实例。换句话说，就是到底应该生成新代码，还是利用现有的代码。照这样来看，这就变成了一个简单的可重用性问题。更容易且更明智的做法是，为每个 XML 文档生成现有类的新实例。如果您一定要尝试一下从每个文档创建一个新的 Java 类，则得到的各个类之间可能没有兼容性 -- 即两个完全相同的文档可能导致两个不同的 Java 类！
　　不用这个可能引起混乱的方法，您可以采用一组 XML 约束条件（由一个 DTD 或 XML 方案表示，将在下面讲述），并根据这些约束条件来生成一个 Java 类（或多个类，根据需要）。这个生成的类将表示符合这些约束条件的任何 XML 文档；这些 XML 文档中的每一个都将被解包到生成的类的一个实例中。在这种情况下，就可以为表示 web 服务配置的文档定义约束条件。这些约束条件将被映射为一个 Java 类，我们将称之为 WebServiceConfiguration。然后您就可以获得任何一种表示特定 web 服务配置的 XML 文档，并假定此文档符合我们的约束条件，由它而创建出前面生成的类的一个实例。这将允许应用程序将不同的 XML 文档用作相同类型的对象，只要这些文档中的数据对于该对象设计时要达到目的来说是有效的即可。
　　新类还是现有的类？
　　现在您也已经有条件回答下一个问题了：您希望创建一个现有类即 WebServiceConfiguration 类的一个实例。剩下需要弄清的全部事情是，这个类是如何预先生成的。所以，现在请将您的注意力集中在这样一个问题上：如何获得一组约束条件，用 XML 实现它们，并保证文档符合这些约束？再一个问题就是，您如何再从这些约束条件生成一个可重用的 Java 类？
　　利用文档约束条件
　　既然您知道此文档将转换成一个 Java 实例，这就产生了另一个问题：要考虑到必须以某种方式保证可将此文档正确地解包到一个选定的 Java 类中。缺少变量或数据类型不正确都可能导致在解包过程中出错 -- 或者甚至在客户机访问配置错误的容器时出现运

查看本文来源

　　从 XML 数据创建类
　　数据绑定系列的第二篇是如何从 XML 数据限制中生成一个 Java 语言。本文通过完整的代码展现了如何生成类和代码，并提供了如何定制您自己版本的建议。还没有看过第一篇吗？第一篇，"对象,无处不在的对象"， 解释了数据绑定是如何将 XML 和 Java 语言对象互为转换。它比较了数据绑定和其它在 Java 程序中处理 XML 的方法， 并介绍了一个 XML 配置文档示例。第一部分也介绍了使用 XML Schema 来约束数据。
　　在深入 Java 程序和 XML 代码之前，先快速回顾一下本系列第一部分所打下的基础。
　　在第一部分中，我们知道只要可以标识文档的一组约束，就可以将文档转换成 Java 对象。那些约束为数据提供了接口。如 Web 服务配置文档示例中所示，XML 文档应当成为现有 Java 类的一个实例，并且从数据约束生成那个类。最后，会看到表示样本 XML 文档约束的 XML schema。
　　如果对细节还有疑问，请回顾第一篇文章.
　　打造基础
　　现在，可以着手从 XML schema 创建 Java 类。该类必须准确表示数据约束，并提供 Java 应用程序将使用的简单读方法和写方法。开始之前，让我们先回顾清单 1，查看为 WebServiceConfiguration 文档定义的 XML schema。
　　清单 1. 表示 Web 容器配置文档数据接口的 XML schema
　　＜?xml version="1.0"?＞
　　＜schema targetNamespace="http://www.enhydra.org"
　　　　　　xmlns="http://www.w3.org/1999/xmlSchema"
　　　　　　　　xmlns:enhydra="http://www.enhydra.org"
　　＞
　　＜complexType name="ServiceConfiguration"＞
　　　　　＜attribute name="name" type="string" /＞
　　　　　＜attribute name="version" type="float" /＞
　　＜/complexType＞
　　＜element name="serviceConfiguration" type="ServiceConfiguration" /＞
　　＜complexType name="WebServiceConfiguration" 　　　　　　　　　baseType="ServiceConfiguration"　　　　　　　　　　derivedBy="extension"＞
　　　　　＜element name="port"＞
　　　　　　＜complexType＞
　　　　　　　＜attribute name="protocol" type="string" /＞
　　＜attribute name="number" type="integer" /＞
　　＜attribute name="protected" type="string" /＞
　　＜/complexType＞
　　＜/element＞
　　＜element name="document"＞
　　　　　　＜complexType＞
　　　　　　　＜attribute name="root" type="string" /＞
　　　　　　　＜attribute name="index" type="string" /＞
　　　　　　　＜attribute name="error" type="string" /＞
　　　　　　＜/complexType＞
　　　　　＜/element＞
　　　　＜/complexType＞
　　＜element name="webServiceConfiguration"type="WebServiceConfiguration" /＞
　　＜/schema＞
　　生成代码
　　开始生成 Java 代码之前，首先必须确定核心类的名称。将使用 org.enhydra.xml.binding 包中的 SchemaMapper，它是 Enhydra 应用服务器实用程序类集合的一部分。还可以将任何必需的支持类放到这个包中。
　　除了类名称以外，还必须确定用来读取和创建 XML 的 Java API。如上一篇文章中所讨论过的，三种主要选择是 SAX、DOM 和 JDOM。由于 SAX 仅仅适用于读取 XML 文档，因此它不适合创建 XML。由于在打包阶段中要将 Java 对象转换为 XML 表示，因此在此阶段中需要创建 XML。这就将选择的范围缩小到 DOM 和 JDOM。在这两种选择都可用的情况下，本例中我选择使用 JDOM API，仅为了显示其功能性（并不仅仅因为我是它的合著者之一！）。
　　最后，必须指出如何将 XML schema 提供给 SchemaMapper 类。通常，可以假设类的生成是脱机完成的（通过静态 main 方法）。仅通过使 main 方法调用非静态方法，还可以从运行时环境中使用类。做了这些决定后，就可以开始勾画类的框架了。
　　组装 SchemaMapper 类框架
　　要做的第一件事就是为要生成的代码设置一些基本存储器。必须能够从每个执行映射的 XML schema 生成多个接口和实现。Java HashMap 正好满足要求。键是接口或实现名称以及映射表中的值，该值是将要输出到新 Java 程序文件的实际代码。还需要存储每对接口／实现的属性（属性是在这两种类之间共享的）。这里，我再次使用 HashMap。其中，键是接口名称。但是，由于每个接口可能有多个属性，因此该值是另一个具有属性及其类型的 HashMap。最后，必须存储 XML schema 的名称空间，因为 JDOM 将使用这个名称空间来访问 XML schema 中的结构。所有这些具体信息都足以初步勾画出新类的框架，新类在清单 2 中。
　　还请注意在清单 2 中已添加了两个需要使用的基本方法：其中一个方法需要使用 XML schema 的 URL 来执行生成（允许它在网络可访问 schema 以及本地 schema 下运行），另一个方法将类输出到指定的目录中。最后，简单的 main 方法将 XML schema 看作一个变量，然后执行生成。
　　清单 2. SchemaMapper 类的框架 package org.enhydra.xml.binding;
　　
　　import java.io.File;
　　import java.io.FileNotFoundException;
　　import java.io.FileWriter;
　　import java.io.IOException;
　　import java.net.URL;
　　import java.util.HashMap;
　　import java.util.Map;
　　import java.util.Iterator;
　　import java.util.List;
　　
　　// JDOM classes used for document representation
　　import org.jdom.Document;
　　import org.jdom.Element;
　　import org.jdom.JDOMException;
　　import org.jdom.Namespace;
　　import org.jdom.NoSuchAttributeException;
　　import org.jdom.NoSuchChildException;
　　import org.jdom.input.SAXBuilder;
　　
　　/**
　　* ＜p＞
　　* ＜code＞SchemaMapper＜/code＞ handles generation of Java interfaces and classes
　　* from an XML schema, essentially allowing data contracts to be set up
　　* for the binding of XML instance documents to Java objects.
　　* ＜/p＞
　　*
　　* @author Brett McLaughlin
　　*/
　　public class SchemaMapper {
　　
　　/** Storage for code for interfaces */
　　private Map interfaces;
　　
　　/** Storage for code for implementations */
　　private Map implementations;
　　
　　/** Properties that accessor/mutators should be created for */
　　protected Map properties;
　　
　　/** XML Schema Namespace */
　　private Namespace schemaNamespace;
　　
　　/** XML Schema Namespace URI */
　　private static final String SCHEMA_NAMESPACE_URI =
　　"http://www.w3.org/1999/xmlSchema";
　　
　　/**
　　* ＜p＞
　　* Allocate storage and set up defaults.
　　* ＜/p＞
　　*/
　　public SchemaMapper() {
　　interfaces = new HashMap();
　　implementations = new HashMap();
　　properties = new HashMap();
　　schemaNamespace = Namespace.getNamespace(SCHEMA_NAMESPACE_URI);
　　}
　　/**
　　* ＜p＞
　　* This is the "entry point" for generation of Java classes from an XML
　　* Schema. It allows a schema to be supplied, via ＜code＞URL＜/code＞,
　　* and that schema is used for input to generation.
　　* ＜/p＞
　　*
　　* @param schemaURL ＜code＞URL＜/code＞ at which XML Schema is located.
　　* @throws ＜code＞IOException＜/code＞ - when problems in generation occur.
　　*/
　　public void generateClasses(URL schemaURL) throws IOException {
　　// Perform generation
　　}
　　
　　/**
　　* ＜p＞
　　* This will write out the generated classes to the supplied stream.
　　* ＜/p＞
　　*
　　* @param directory ＜code＞File＜/code＞ to write to (should be a directory).
　　* @throws ＜code＞IOException＜/code＞ - when output errors occur.
　　*/
　　public void writeClasses(File dir) throws IOException {
　　// Perform output to files
　　}
　　
　　/**
　　* ＜p＞
　　* This provides a static entry point for class generation from
　　* XML Schemas.
　　* ＜/p＞
　　*
　　* @param args ＜code＞String[]＜/code＞ list of files to parse.
　　*/
　　public static void main(String[] args) {
　　SchemaMapper mapper = new SchemaMapper();
　　try {
　　for (int i=0; i＜args.length; i++) {
　　File file = new File(args[i]);
　　mapper.generateClasses(file.toURL());
　　mapper.writeClasses(new File("."));
　　}
　　} catch (FileNotFoundException e) {
　　System.out.println("Could not locate XML Schema: ");
　　e.printStackTrace();
　　} catch (IOException e) {
　　System.out.println("Java class generation failed: ");
　　e.printStackTrace();
　　}
　　}
　　}
　　In 清单 2 中，可以看到对于每个作为自变量传递的 XML schema，main 方法都调用生成过程。首先，方法会生成类。将文件名转换为 URL，并传递到 generateClasses(URL schemaURL)。然后，通过 writeClasses(F

查看本文来源

　　从文本到字节码
　　本数据绑定系列的第三部分演示了如何使用“JSR-031：数据绑定，Sun 数据绑定规范申请”中指定的方法，将 XML 元素和属性转换成 Java 对象。这部分主要讲述从数据的XML 表示移到应用程序代码易于使用的 Java 实例。第三部分论及通过将 XML 文档中的嵌套元素取消编组成 Java 对象、测试和用某些实际示例来使用新的工具。
　　本系列的目标是演示如何将 XML 元素转换成 Java 对象，然后可以使用 Java 语言 accessor 和 mutator 方法直接处理 XML 数据。第一部分比较了数据绑定和 Java 应用程序中其它处理 XML 数据的方法，分析了设计决策，还定义了示例 Web 服务配置文档的 XML 模式。第二部分说明了如何从 XML 模式生成接口和实现，以便符合 XML 模式的 XML 文档可以转换成这些生成类的实例。
　　在第三部分（共四部分）中，将完成基础知识的讲解，并且描述了如何精心设计代码以执行取消编组，取消编组将完成将 XML 转换成 Java 对象的过程。执行了取消编组后，可以使用测试类（已包括在内）来检查是否所有部分都已正确组合在一起。本系列的每一部分都建立在其它部分的基础之上，所以如果您还没有看过第一和第二部分，您也许会看不懂本文中的一些描述。如果要回顾专门的词汇表，请参阅术语解释侧栏。
　　使用第一部分中为 WebServiceConfiguration 定义的 XML 模式（请参阅更新版本）和第二部分中的接口，即将创建为配置数据的特定实例提供数据的 XML 文档。任何符合模式的 XML 文档都可以编组成 Java 对象。这些对象应该是使用 SchemaMapper 类生成的类的实例。当然，最终结果就是数据绑定。
　　制作 XML 实例文档
　　创建符合模式的 XML 文档 -- 通常叫做 XML 实例 -- 很简单。文档必须只提供与模式中定义的约束相匹配的数据值，如清单 1 所示。
　　清单 1. 符合示例 XML 模式的 XML 实例文档
　　＜?xml version="1.0"?＞
　　＜webServiceConfiguration xmlns="http://www.enhydra.org"
　　　　　　　　　xmlns:xsi="http://www.w3.org/1999/XMLSchema/instance"
　　　　　　　　　xsi:schemaLocation="http://www.enhydra.org
　　　　　　　　　configuration.xsd"
　　　　　　　　　version="1.1"
　　　　　　　　　name="Unsecured Web Listener" ＞
　　＜port number="80" protocol="http" protectedPort="false" /＞
　　＜document root="/usr/local/enhydra/html" index="*.html,*.xml"　　　　　　 error="error.html" /＞
　　＜/webServiceConfiguration＞
　　清单 1 中的示例完整地显示了 WebServiceConfiguration 的实例。实例文档包括了两个名称空间声明。第一个是缺省名称空间声明，请参考 http://www.enhydra.org。这表示所有没有前缀的元素会分配到此名称空间。虽然，在本示例中不需要声明缺省名称空间，它还给予了文档一些身份。这个缺省名称空间有助于将该文档与其它有相似或等同元素名称的 XML 文档区分出来。
　　定义的另一个名称空间分配给 xsi 前缀，所以带该前缀的所有元素都分配到此名称空间。它 (http://www.w3.org/1999/XMLSchema/instance) 引用“XML 模式实例规范”的 URI。该规范依次定义了 XML 文档如何引用文档符合的 XML 模式。最后，schemaLocation 属性引用 XML 模式。该属性的第一个变量是受到约束的名称空间（示例缺省名称空间，它包括文档中的每个元素）。第二个变量，用空格与第一个变量分开，引用 XML 模式的实际位置。本例中，模式 configuration.xsd 是一个本地文件，它与文档在同一个目录中。也可以通过使用 URL 来引用网络上任意位置的模式。
　　在缺省名称空间中，附加属性（因为它们没有前缀）定义了版本 (1.1) 和名称 (Unsecured Web Listener)。
　　接着，声明了模式中的 Port 对象，并定义了它的数据：端口号为 80，协议是 http。正确取消编组成 Java 代码后，该文档就变成了 WebServiceConfigurationImpl 类的实例。然后，Java 代码可以使用本系列第二部分中设计的接口 WebServiceConfiguration，以使用基本 XML 文档中的数据。（请注意，可能会在应用程序中执行验证，如模式验证侧栏中所概述的。）
　　模式验证
　　较新的 XML 语法分析器，如 Apache Xerces 语法分析器的当前发行版，允许对 XML 实例文档执行模式验证。验证允许在程序格式上确保 XML 文档符合它引用的 XML 模式。请与语法分析器供应商联系或参考文档，以确定语法分析器是否支持模式验证，其验证范围，以及如何打开验证。
　　打开前门
　　正式开始之前，需要提供入口点以取消编组 XML 文档，该文档作为返回 Java 对象的方法的输入。（由于您会忆起，本例中取消编组的结果只是 Java 对象。）然后，该对象可以转换成适当的接口，其实，您已经生成了该接口（在本系列第二部分中）。
　　对于示例 SchemaMapper 类，允许传入 URL 是最有意义的。由于可以使用网络资源作为输入，而不是只允许文件名，这就提供了更多选择。知道了这一点后，下一步就从 URL 创建 JDOM 文档对象 (org.jdom.Document)，然后处理文档。请查看清单 2 中执行该操作的代码。
　　清单 2. 将字符串映射成 Java 指定的类型 /**
　　*
　　* This method is the public entry point for unmarshalling an object from
　　* an XML instance document.
　　*
　　*
　　* @param instanceURL URL for the instance document.
　　* @return Object - the created Java Object, or
　　* null if problems occur in a way that does not
　　* generate an Exception.
　　* @throws IOException when errors in binding occur.
　　*/
　　public static Object unmarshall(URL instanceURL) throws IOException {
　　// Read in the document
　　SAXBuilder builder = new SAXBuilder();
　　
　　try {
　　Document doc = builder.build(instanceURL);
　　Element rootElement = doc.getRootElement();
　　Unmarshaller unmarshaller = new Unmarshaller();
　　return unmarshaller.getJavaRepresentation(rootElement);
　　} catch (JDOMException e) {
　　throw new IOException (e.getMessage());
　　}
　　}
　　清单 2 中的方法是静态的，允许直接调用它而无需实例化类的实例。由于对 unmarshall 方法的多个调用之间没有需要共享的数据，因此该方法可以是静态的。一旦处理了 XML，就将文档的根元素（以 JDOM 表示）就被传到执行从 XML 到 Java 对象转换的内部方法。
　　转换数据
　　我不打算逐行解释取消编组中使用的完整代码。可以查看类的完整源码清单，它基本上是不需加以说明的。但是，在入口点示例中，有一些值得强调的事情。如果创建了适当类的新实例，将使用 XML 文档提供的值调用 mutator 方法（全都名为 setXXX）。当然，这将使 XML 数据在实例的 Java 方法中随处都可用。清单 3 显示了处理这种查找方法以及随后调用的代码片段。
　　清单 3. unmarshaller 类的入口点
　　
　　// For each attribute, get its name and call mutator
　　List attributes = rootElement.getAttributes();
　　Method[] methods = objectClass.getMethods();
　　
　　for (Iterator i = attributes.iterator(); i.hasNext(); ) {
　　　Attribute att = (Attribute)i.next();
　　
　　　// Only want attributes for this namespace
　　　if ((!att.getNamespace().equals(ns)) &&
　　　　　(!att.getNamespace().equals(Namespace.NO_NAMESPACE))) {
　　　　　　　continue;
　　　　　}
　　
　　　// Determine method to call
　　　String methodName = new StringBuffer()
　　　　　　　　.append("set")
　　　　　　　　.append(BindingUtils.initialCaps(att.getName()))
　　　　　　　　.toString();
　　
　　　// Find the method to call, and its parameter type
　　　for (int j=0; j
　　找到了根元素的属性，并确定了每个属性的适用方法。然后，就是处理实际的 java.lang.reflect.Method 对象。XML 属性的值已确定，并作为调用的参数传送到方法。但是，需要解决一个映射问题；XML 文档中的所有数据都作为 String 抽取，但传递时必须是适当的 Java 类型。清单 4 将一个方法添加到 DataMapping 辅助类中，以满足转换的需要。
　　清单 4 将字符串映射成 Java 特定的类型
　　/**
　　*
　　* This will take the String value supplied and convert it
　　* to an Object of the type specified in paramType.
　　*
　　*
　　* @param value String value to convert.
　　* @param paramType Class with type to convert to.
　　* @return Object - value in correct type.
　　*/
　　public static Object getParameter(String value, Class paramType) {
　　Object ob = null;
　　String type = paramType.getName();
　　
　　if (type.equals("java.lang.String")) {
　　ob = value;
　　} else if ((type.equals("int")) || (type.equals("java.lang.Integer"))) {
　　ob = Integer.valueOf(value);
　　} else if ((type.equals("long")) || (type.equals("java.lang.Long"))) {
　　ob = Long.valueOf(value);
　　} else if ((type.equals("float")) || (type.equals("java.lang.Float"))) {
　　ob = Float.valueOf(value);
　　} else if ((type.equals("double")) || (type.equals("java.lang.Double"))) {
　　ob = Double.valueOf(value);
　　} els

查看本文来源