[学习交流] 【广州校区】【原创】Castor 模式之间的映射（篇章三）

通过上面两篇的学习，相信也了解了对Castor的下载并安装操作和熟悉 Castor 的解组器和编组器。

初看上去，您似乎已经掌握了有效地使用 Castor 所需了解的所有过程：设置、编组和解组。但是，您到目前为止学到的所有东西只适用于所谓的理想环境。在这样的环境中，每个人编写的 XML 都是完美的，其中的元素名是有意义的，比如 “title” 和 “authorAddress”，而不是 “t” 或 “aa”。Java 类是按照有组织的方式创建的，采用单数作为类名（比如 “Book”），采用单数名词作为成员变量名（比如 “isbn” 和 “price”）。另外，数据类型也是正确的：没有开发人员把 price 的数据类型设置为 int 而不是 float，或者使用 char 数组存储字符串数据（这是 C 语言的做法）。

但是，大多数程序员所处的环境并不完美，在大多数程序员所处的环境中有许多不理想的情况：XML 文档常常有糟糕的元素名和属性名，还要应付名称空间问题。元素数据存储在属性中，一些数据甚至由管道符或分号分隔。

Java 类是继承的，对它们进行重新组织在时间和工作量方面的成本可能会超过带来的好处。这些类常常无法简洁地映射到 XML 模式（认为 XML 和数据人员会与 Java 程序员相互妥协的想法也是非常不可思议的），而且在某些情况下，即使实现了简洁映射，也肯定不会跨所有类和数据。XML 元素名可能不合适，许多 Java 变量名也可能不合适。甚至可能遇到使用 Hungarian 表示法的名称，按照这种表示法，所有成员变量都以 “m” 开头，比如 mTitle。这很不好看。

　　在这些情况下，您目前学到的数据绑定方法就无能为力了。XML 文档中可能会出现 Hungarian 风格的元素名，Java 类中也可能出现没有意义的结构。这种情况是无法接受的。如果不能按照您希望的方式获取和操作 XML 文档的数据，那么 Castor（或任何数据绑定框架）又有什么意义呢？

一灵活数据绑定的目标

在 Castor 或任何其他数据绑定框架中，使用映射文件都要花一些时间。必须先学习一些新语法。尽管映射文件使用 XML 格式（大多数框架都是这样的），但是您需要学习一些新元素和属性。还必须做一些测试，确保 XML 和 Java 代码之间的相互转换产生您希望的结果。最后，如果亲自指定映射，而不是让框架处理映射，就可能在数据绑定中遇到更多的错误。例如，如果希望让框架把 XML 中的 fiddler 元素映射到 Java 代码中的 violin 属性，但是错误地声明这个属性是在 player 类中（应该是在 Player 类中），那么就会遇到错误。因此，在亲自指定映射时，必须非常注意拼写、大小写、下划线、单引号和双引号。

在学习使用映射文件之前，应该确定确实需要这么做。如果掌握了映射文件，但是却不使用它，那就是浪费时间。但是，映射确实有一些优点。

二 Java 代码不再受 XML 命名方式的限制

前面曾经提到，在把 XML 转换为 Java 代码时，大小写可能会导致错误。在 XML 中，最常用的做法是名称全部小写并加连字符，比如 first-name。有时候，甚至会看到 first_name。这样的名称会转换为很难看的 Java 属性名；没人愿意在代码中调用 getFirst-name()。实际上，在大多数由程序员（而不是 XML 开发人员或数据管理员）编写的文档中，往往使用驼峰式（camel-case）命名法，比如 firstName。通过使用映射文件，很容易把 XML 风格的名称（比如 first-name）映射为 Java 风格的名称（比如 firstName）。最棒的一点是，不需要强迫 XML 人员像 Java 程序员那样思考，这往往比学习新的映射语法困难得多。

是的，这似乎很明显。既然可以调整 XML 到 Java 的命名转换，反过来肯定也可以：在把 Java 类和属性包含的数据转换为 XML 时，可以修改 Java 名称。但是，有一个更重要，也更微妙的好处：不再受到 Java 类名和包名的限制。

这很可能成为一个组织问题。例如，在大多数情况下，XML 中的嵌套元素转换为类结构，最内层的嵌套元素转换成类属性（成员变量）。看一下清单 1 中的 XML：

清单 1. 代表图书的 XML

<?xml version="1.0" encoding="UTF-8"?>

<book>

　<last-name>Finder</last-name>

　<first-name>Joseph</first-name>

</authors>

<title>Power Play</title>

</book>

Castor（或任何其他数据绑定框架）可能假设您需要一个 Book 类，这个类引用几个 Author 类实例。author 类应该有成员变量 lastName 和 firstName（这里会出现前面提到的命名问题，Author 中的成员变量应该是 last-name，还是 lastName？对于名字也有这个问题）。但是，如果这不是您希望的结果，应该怎么办？例如，您可能在一个称为 Person 或 Professional 的类中存储所有作家、会议演讲人和教授。在这种情况下就真有麻烦了，而且您不会愿意全面修改 XML 元素的结构和名称来解决这个问题。实际上，在这种情况下，要想原样保持 XML，使用映射是惟一的办法。

映射允许我们在 Java-XML 转换的两端指定命名方式。我们不希望由于 XML 文档的原因修改 Java 代码，同样不愿意修改 XML 结构来适应 Java 类和成员变量。另外，Java 包也会增加复杂性。尽管在 Castor 中包并不是大问题，但是仍然必须在编组的 XML 中存储 Java 类和包的相关信息，这对于业务逻辑（Java 类）和数据（XML）的隔离很不利。映射可以解决所有这些问题。

三映射允许在现有环境中添加数据绑定

前两个问题（对 XML 和 Java 代码的限制）实际上与一个更大的问题相关。大多数情况下，您已经有了一组 Java 对象和一个或多个 XML 文档。因此，不具备前两篇文章中的那种自由度：不能让 Castor 根据它自己的规则把 Java 代码解组为 XML，或者为 XML 文档生成 Java 类。

相反，更为常见的情况是，您需要把一种新技术 — 数据绑定 — 添加到现有的结构中。在这种情况下，映射文件就是使用数据绑定的关键。在两个 “端点”（当前的对象模型和当前的 XML 结构）固定的情况下，映射使我们仍然能够把这两者的数据联系起来。简而言之，良好的映射系统使数据绑定能够在真实环境中发挥作用，而不仅仅停留在理论上。

一个映射场景示例

　　我们先来看一个简单的映射场景。在前一篇文章中，我们开发了 Book 和 Author 类。清单 2 是 Book 类。

清单 2. Book 类

package ibm.xml.castor;

import java.util.LinkedList;

import java.util.List;

public class Book {

　private String isbn;

　private String title;

　private List<Author> authors;

　public Book() { }

　public Book(String isbn, String title, List<Author> authors) {

　　this.isbn = isbn;

　　this.title = title;

　　this.authors = authors;

　}

　public Book(String isbn, String title, Author author) {

　　this.isbn = isbn;

　　this.title = title;

　　this.authors = new LinkedList<Author>();

　　authors.add(author);

　}

　public void setIsbn(String isbn) {

　　this.isbn = isbn;

　}

　public String getIsbn() {

　　return isbn;

　}

　public void setTitle(String title) {

　　this.title = title;

　}

　public String getTitle() {

　　return title;

　}

　public void setAuthors(List<Author> authors) {

　　this.authors = authors;

　}

　public List<Author> getAuthors() {

　　return authors;

　}

　public void addAuthor(Author author) {

　　authors.add(author);

　}

清单 3 是 Author 类。

　　清单 3. Author 类

　　　　　　　　package ibm.xml.castor;

public class Author {

　private String firstName, lastName;

　public Author() { }

　public Author(String firstName, String lastName) {

　　this.firstName = firstName;

　　this.lastName = lastName;

　}

　public void setFirstName(String firstName) {

　　this.firstName = firstName;

　}

　public void setLastName(String lastName) {

　　this.lastName = lastName;

　}

　public String getFirstName() {

　　return firstName;

　}

　public String getLastName() {

　　return lastName;

　}

一个比较麻烦的 XML 文档

这一次不使用前一篇文章中的 XML，而是使用一个不太容易映射的 XML 文档。清单 4 给出希望绑定到清单 2 和清单 3 中的 Java 类的 XML 文档。

清单 4. 用于数据绑定的 XML

<?xml version="1.0" encoding="UTF-8"?>

<book>

</author>

</author>

<book-info>

</book-info>

</book>

需要映射哪些数据？

　　在处理映射文件语法或 Castor 的 API 之前，第一个任务是判断需要把 XML（清单 4）中的哪些数据绑定到 Java 类（清单 2 和清单 3）。请考虑一会儿。

　　下面简要总结一下这个 XML 文档应该如何映射到 Java 类：

　　book 元素应该映射到 Book 类的一个实例。

　　每个 author 元素应该映射到 Author 类的一个实例。

　　每个 Author 实例应该添加到 Book 实例中的 authors 列表中。

　　对于每个 Author 实例，firstName 应该设置为 name 元素上的 first 属性的值。

　　对于每个 Author 实例，lastName 应该设置为 name 元素上的 last 属性的值。

　　Book 实例的 ISBN 应该设置为 book-info 元素中嵌套的 isbn 元素的值。

　　Book 实例的书名应该设置为 book-info 元素中嵌套的 title 元素的值。

其中一些映射您已经知道如何实现了。例如，book 到 Book 类实例的映射是标准的，Castor 会默认处理这个任务。但是，也有一些新东西，比如说作者。尽管把一个 author 元素映射到一个 Author 实例没什么问题，但是没有分组元素，比如 authors，它清楚地显示出所有作者属于 Book 实例中的一个集合。

这里还有一些元素和属性并不直接映射到 Java 对象模型。Author 类包含表示名字和姓氏的变量，但是在 XML 中只用一个元素（name）表示作者姓名，这个元素有两个属性。book-info 元素中嵌套的书名和 ISBN 并不映射到任何 Java 对象。

这种情况非常适合使用映射文件。它使我们能够使用这种 XML（包含我们需要的数据，但是结构不符合希望），仍然能够把文档中的数据放到 Java 对象中。而且，映射文件本身并不难编写。

四基本的映射文件

Castor 中的映射是通过使用映射文件（mapping file）实现的。映射文件仅仅是一个 XML 文档，它提供了如何在 Java 代码和 XML 之间进行转换的相关信息。因为您熟悉 XML，所以您会发现编写映射文件是非常容易的。实际上，对于简单的映射（只需修改元素名和 Java 类或成员变量的名称），只需一点儿时间就能编写好映射文件。

　　然后，当进行编组和解组时（前两篇文章已经介绍过如何在程序中进行编组和解组），Castor 会使用这个文件。只需对 Castor 多做一个 API 调用；其他代码都是一样的。

　　mapping 元素

Castor 映射文件的开始是一个普通的 XML 文档，然后是根元素 mapping。还可以引用 Castor 映射 DTD。这样就可以检验文档，确保结构和语法没有任何问题。这会大大简化对映射的调试。

清单 5. 基本的 Castor 映射文件

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　　　　　　　　 "http://castor.org/mapping.dtd">

</mapping>

　　这个文件显然没有实质性内容，但它是所有映射文件的起点。

用 class 元素对类进行映射

建立基本的映射文件之后，差不多总是先要把一个 Java 类映射到一个 XML 元素。在这个示例中，需要把 Book 类映射到 book 元素中的数据。映射文件首先考虑类，所以需要添加一个 class 元素，并在这个元素的 name 属性中指定完全限定的 Java 类名，比如：

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　　　　　　　　 "http://castor.org/mapping.dtd">

　</class>

</mapping>

现在，可以使用 map-to 元素和 xml 属性指定这个类要映射到的 XML 元素。这个元素嵌套在 XML 元素映射到的 Java 类（完全限定，包括包名）的 class 元素中，比如：

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　　　　　　　　 "http://castor.org/mapping.dtd">

　<map-to xml="book" />

　</class>

</mapping>

这非常简单。实际上，到目前为止，这个映射文件只实现 Castor 的默认操作。除非由于以下两个原因，否则可以删除这个部分并让 Castor 处理这个任务：

　　需要指定如何填充 Book 中的某些字段，比如书名和 ISBN。

　　如果使用映射文件，那么最好指定所有内容的映射方式。这会更明确 XML 和 Java 代码之间的配合。

　　把字段映射到元素

　　有了基本的类到元素的映射之后，就可以开始把 Book 类的字段映射到 XML 文档中的特定元素。Castor 映射文件使用 field 元素指定要使用的 Java 成员变量，使用其中嵌套的 bind-xml 元素指定映射到的 XML 元素。因此，下面的代码指定把 Book 类中的 title 变量映射到 book 元素中嵌套的 title 元素：

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　　　　　　　　 "http://castor.org/mapping.dtd">

　　<map-to xml="book" />

　　　　　　　　　　 <bind-xml name="title" node="element" />

　　　　　　　　　　</field>

　</class>

</mapping>

在这里要注意两点。首先，提供了属性名（在这个示例中是 “title”）。这是属性（property）名，而不是成员变量名。换句话说，Castor 通过调用 set[PropertyName]() 来使用这个属性名。如果提供属性名 “foo”，Castor 就会尝试调用 setfoo() — 这可能不是您希望的情况。因此，要仔细注意大小写，并使用属性名而不是 Java 类中的变量名。

　　要注意的第二点是 type 属性。这个属性向 Castor 说明数据究竟是什么类型的。在这个示例中，这很简单；但是在某些情况下，希望将以 XML 文本式数据存储的数字存储为整数、小数或者只是字符串，这时指定正确的数据类型就很重要了。另外，类型应该使用完全限定的 Java 类名，比如 java.lang.String。

　　在 bind-xml 元素中，指定要绑定到的 XML 元素的名称（在这个示例中是 “title”），并使用 node 属性指定是绑定到元素还是绑定到属性。这样就可以轻松地使用元素和属性数据，只需在映射文件中稍做修改即可。

五指定 XML 元素的位置

　但是，这里需要解决一个问题：书名和 ISBN 嵌套在 book-info 元素中，而不是直接嵌套在 book 元素中。所以需要在映射文件中指出这一情况。

　　当遇到这种情况时 — 一个类中的一个字段并不直接映射到与这个类对应的 XML 元素中的数据 — 就需要在 bind-xml 元素中使用 location 属性。这个属性的值应该是 XML 文档中包含您希望绑定到的数据的元素。如果绑定到元素数据，它就应该是目标元素的父元素；如果绑定到属性数据，它就应该是包含这个属性的元素。

　　因此，在这个示例中，希望把 Book 类的书名属性绑定到 title 元素的值，而这个元素嵌套在 book-info 元素中。下面是映射方法：

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　　　　　　　　 "http://castor.org/mapping.dtd">

　　<map-to xml="book" />

　　　<bind-xml name="title" node="element" location="book-info"

　　</field>

　</class>

</mapping>

　　然后为书的 ISBN 添加另一个字段映射：

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　　　　　　　　 "http://castor.org/mapping.dtd">

　　<map-to xml="book" />

　　　<bind-xml name="title" node="element" location="book-info" />

　　</field>

　　　　　　　　<bind-xml name="isbn" node="element" location="book-info" />

　　　　　　　　</field>

　</class>

</mapping>

现在，Book 类的属性都已经设置好了。该处理 Author 类了。

　　对其他类进行映射

　　按照相同的方式对其他类进行映射。惟一的差异是在其他类中不需要使用 map-to 元素。

　　对 Author 类进行映射

　　需要把 Author 类中的字段映射到 author 元素。请记住，下面是要处理的 XML 片段：

</author>

　　惟一需要注意的是，这里并不用两个元素分别包含名字和姓氏，而是使用一个带两个属性的元素。但是，前面已经使用过 location 属性（需要用这个属性指定 name 元素是映射到的位置）和 node 属性（可以在这里指定要绑定到属性数据，而不是元素）。所以在映射文件中需要以下代码：

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　"http://castor.org/mapping.dtd">

　　<map-to xml="book" />

　　　<bind-xml name="title" node="element" location="book-info" />

　　</field>

　　　<bind-xml name="isbn" node="element" location="book-info" />

　　</field>

　</class>

　　　　　　　　<bind-xml name="first" node="attribute" location="name" />

　　　　　　　　</field>

　　　　　　　　<bind-xml name="last" node="attribute" location="name" />

　　　　　　　　</field>

　　　　　　　　</class>

</mapping>

现在，您应该很容易看懂这些代码。这里指定了映射到的类（Author）和这个类上要映射的属性（FirstName 和 LastName）。对于每个属性，指定要查看的 XML 元素（都是 name）并指定需要的是属性数据。

　　把 Book 和 Author 类链接起来

　　如果看一下上面的 XML，就会注意到并没有指定 Author 类应该映射到哪个 XML 元素。这是一个问题，因为 Castor 不会猜测您的意图；只要使用映射文件，最好指定所有映射信息。

　　如果每本书只有一位作者，那么在 Book 类中可能有一个 Author 属性。在这种情况下，可以在映射文件中插入以下代码：

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　"http://castor.org/mapping.dtd">

　　<map-to xml="book" />

　　　<bind-xml name="title" node="element" location="book-info" />

　　</field>

　　　<bind-xml name="isbn" node="element" location="book-info" />

　　</field>

　　　　　　　　<bind-xml name="author" />

　　　　　　　　</field>

　</class>

　　　<bind-xml name="first" node="attribute" location="name" />

　　</field>

　　　<bind-xml name="last" node="attribute" location="name" />

　　</field>

　</class>

</mapping>

在这种情况下，把这一映射放在映射文件的图书部分中，因为映射的是属于 Book 类的一个属性。映射的类型指定为 ibm.xml.castor.Author，并指定 XML 元素 author。这样的话，Castor 的映射系统就会使用 class 元素中的 Author 类的定义处理作者的属性。

但是，问题在于 Book 类中没有 Author 属性。相反，这个类中有一个 Authors 属性，其中包含 Author 实例的集合。因此，必须让 Castor 把每个 author 元素映射到一个 Author 实例（这一步差不多已经完成了），然后把所有实例组合成 Book 的 Authors 属性。

　六把元素映射到集合

　　为了映射图书和作者的关系，需要把几个元素（XML 文档中的每个 author）映射到一个集合，然后把这个集合分配给 Book 的 Authors 属性。

　　首先使用 field 元素，因为确实要映射到 Book 的一个字段。还要把 name 属性的值指定为 “Authors”，因为这是 Book 中将映射到的属性：

</field>

　　接下来，需要提供属性的类型。您可能认为这应该是集合类型。但是，实际上希望指定集合中每个成员的类型。所以类型应该是 ibm.xml.castor.Author。您将会获得 ibm.xml.castor.Author 类的实例，Castor 将把这些实例放到 Authors 属性中：

</field>

　　下面是关键之处：使用 collection 属性指定这个属性是一个集合。这个属性的值是集合的类型。Castor 当前只支持两个值：vector（代表列表类型）和 array（代表数组类型）。通过标准的 Java 集合 API（比如 next() 等调用）访问第一种集合；管理第二种集合的方法与 Java 数组相似，按照索引来访问它们，比如 ar[2]。在这个示例中，因为 Java 类型是 List，所以使用 vector：

</field>

　　如果指定了 collection 属性，Castor 就知道应该用与 type 属性对应的值构建这个集合。因此，这里的 Authors 属性应该是 ibm.xml.castor.Author 类型的实例的集合。

　　现在只剩下一步了：指定获取这些 Author 实例的来源。这要使用 bind-xml 元素：

　<bind-xml name="author" />

</field>

所有工作都完成了；现在形成了一个完整的映射文件。最终的文件应该像清单 6 这样。

清单 6. 完整的映射文件

<?xml version="1.0"?>

<!DOCTYPE mapping PUBLIC "-//EXOLAB/Castor Mapping DTD Version 1.0//EN"

　　　　　"http://castor.org/mapping.dtd">

　　<map-to xml="book" />

　　　<bind-xml name="title" node="element" location="book-info" />

　　</field>

　　　<bind-xml name="isbn" node="element" location="book-info" />

　　</field>

　　　<bind-xml name="author" />

　　</field>

　</class>

　　　<bind-xml name="first" node="attribute" location="name" />

　　</field>

　　　<bind-xml name="last" node="attribute" location="name" />

　　</field>

　</class>

</mapping>

七在程序中使用映射文件

最后，需要在解组过程中使用这个映射文件。以前，我们静态地使用 Unmarshaller 类，通过调用 Unmarshaller.unmarshal() 把 XML 转换为 Java 代码。但是，因为现在要使用映射文件，所以需要创建一个 Unmarshaller 实例并设置一些选项。清单 7 给出的类处理从 XML 文档到 Java 对象的解组过程。

清单 7. 用映射文件进行解组

package ibm.xml.castor;

import java.io.FileReader;

import java.util.Iterator;

import java.util.List;

import org.exolab.castor.mapping.Mapping;

import org.exolab.castor.xml.Unmarshaller;

public class BookMapUnmarshaller {

　public static void main(String[] args) {

　　Mapping mapping = new Mapping();

　　try {

　　　mapping.loadMapping("book-mapping.xml");

　　　FileReader reader = new FileReader("book.xml");

　　　Unmarshaller unmarshaller = new Unmarshaller(Book.class);

　　　　　　　　unmarshaller.setMapping(mapping);

　　　Book book = (Book)unmarshaller.unmarshal(reader);

　　　System.out.println("Book ISBN: " + book.getIsbn());

　　　System.out.println("Book Title: " + book.getTitle());

　　　List authors = book.getAuthors();

　　　for (Iterator i = authors.iterator(); i.hasNext(); ) {

　　　　Author author = (Author)i.next();

　　　　System.out.println("Author: " + author.getFirstName() + " " +

　　　　　　　　　　　　　　　　　　　　author.getLastName());

　　　}

　　} catch (Exception e) {

　　　System.err.println(e.getMessage());

　　　e.printStackTrace(System.err);

　　}

现在完成了！这个过程与以前的过程差异并不大。作为练习，您可以自己试着编写把 Java 代码编组为 XML 的代码。请参考前一篇文章中的 BookMarshaller 类并设置映射文件，然后尝试在 XML 和 Java 代码之间来回转换。

Yin灬Yan · Yin灬Yan

我来占层楼啊

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] 【广州校区】【原创】Castor 模式之间的映射（篇章三）

1 个回复

新人专属

QQ达人

交际达人

黑马签到小蜜蜂

黑马土豪金

回帖达人

活动达人