Brett McLaughlin, 作家/编辑, O‘Reilly Media, Inc.
2004 年 9 月 01 日
在
上一篇文章中，Brett 帮助您对 JaxMe API 有了深入的了解。在这一基础上，本文将说明如何将 XML 文档转化成 Java
类实例、操纵底层的 XML 数据然后再把修改后的数据转换成 XML。本文将为您提供翔实的 JaxMe
应用知识，以便在您的应用程序编写中加以运用。
首先要指出我希望您已经读过本系列文章的
上一篇，事实上我将沿用那篇文章中的例子，如果您没有按照顺序阅读可能会有点手足无措。
迭代的过程
本文将指出数据绑定的迭代特性，这也是您需要真正注意的一点。很多 API，特别是那些属于
工具类
的 API，都只需要放入类路径然后直接使用即可，Jakarta Commons 类就是一个很好的例子。就是说只要放到 Java
工具组中就随时都可以使用。但事实上，数据绑定 API
的工作方式有点不同，人们很少会到处使用数据绑定中的方法，而是在应用程序的某一部分集中使用数据绑定。
为了强调这一点，这些文章就是按照人们编写代码的方式写成的。上一篇文章中我给出了一个简单的
XML
模式，并假设有两个实体以此作为相互通信的标准。这两个实体可以是公司、同一公司内的不同部门，也可以是两个应用程序组件。无论哪种情况，都使用
JaxMe 从该模式生成类，这些类然后大概被交给 Java 开发人员。通过 XML 模式的这种 Java 表示，就可以将符合那种模式的 XML
文档转化到 Java 类，或者相反。
 |
再重复一次
我相信有些读者一直坚持阅读本专栏，对于数据绑定是什么的议论听到过不下十次。但是，每个月都有不少新手写信告诉我，他们正在努力弄明白这些东西。请原谅我的罗嗦吧，也许您旁边的那个人正在学习呢，多重复一遍说不定能让您的日子好过一点！
|
|
赶上进度
首先我们来回顾上一篇文章中用于生成类的模式，如清单 1 所示。
清单 1. 用于学生的 XML Schema
<?xml version="1.0" encoding="UTF-8"?>
<schema attributeFormDefault="unqualified"
elementFormDefault="qualified"
targetNamespace="http://dw.ibm.com/jaxme/student"
xml:lang="EN"
xmlns:stu="http://dw.ibm.com/jaxme/student"
xmlns="http://www./2001/XMLSchema"
>
<element name="students">
<complexType>
<sequence>
<element name="student" maxOccurs="unbounded"
type="stu:Student" />
<element name="college" minOccurs="0"
maxOccurs="unbounded" type="stu:College" />
</sequence>
</complexType>
</element>
<complexType name="Student">
<sequence>
<element name="firstName" type="string" />
<element name="lastName" type="string" />
<element name="collegeId" type="string" />
<element maxOccurs="unbounded" name="address"
type="stu:Address" />
</sequence>
</complexType>
<complexType name="Address">
<sequence>
<element name="street" type="string" />
<element name="city" type="string" />
<element name="state" type="string" />
<element name="zip" type="positiveInteger" />
</sequence>
<attribute name="type" type="string" use="required" />
</complexType>
<complexType name="College">
<sequence>
<element name="name" type="string" />
<element name="address" type="stu:Address" />
</sequence>
<attribute name="id" type="string" use="required" />
</complexType>
</schema>
|
有了这个模式之后就可以处理它的实例文档，如清单 2 所示。
清单 2. 基本的学生列表
<?xml version="1.0" encoding="UTF-8"?>
<students
xmlns="http://dw.ibm.com/jaxme/student"
xmlns:xsi="http://www./2001/XMLSchema-instance"
xsi:schemaLocation="http://dw.ibm.com/jaxme/student student.xsd"
>
<student>
<firstName>Brett</firstName>
<lastName>McLaughlin</lastName>
<collegeId>LBU</collegeId>
<address type="home">
<street>1029 Burlingham</street>
<city>Waco</city>
<state>TX</state>
<zip>87610</zip>
</address>
</student>
<student>
<firstName>Gary</firstName>
<lastName>Greathouse</lastName>
<collegeId>LBU</collegeId>
<address type="home">
<street>9098 Townhall Drive</street>
<city>Waco</city>
<state>TX</state>
<zip>87621</zip>
</address>
</student>
<college id="LBU">
<name>Louisiana Baptist University</name>
<address type="home">
<street>6301 Westport Avenue</street>
<city>Shreveport</city>
<state>LA</state>
<zip>71129</zip>
</address>
</college>
</students>
|
我分别把这两个文件命名为
students.xsd和
student1.xml。本文中将读取 student1.xml，打印其中的一些信息，增加和改变一些信息，然后将修改的数据序列化为一个新的文件
student2.xml。任务非常简单，但是涉及到了使用 JaxMe 进行基本的数据绑定所需要了解的大部分知识。
把 XML 转化为 Java 代码
第一步是把这个 XML 文件转化为 Java 表示。
上一篇 文章的
com.ibm.dw.jaxme.student 包提供了我们需要的类。现在要做的就是读入 XML 文件，告诉 JaxMe 用什么类表示文件中的对象，让数据绑定 API 完成它们的工作。清单 3 是一个完成这项工作的例子，先看一遍，后面有详细的说明。
清单 3. 读取并打印 student1.xml
package com.ibm.dw.jaxme.example;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
// JAXB classes
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
// SAX classes
import org.xml.sax.InputSource;
// Generated classes
import com.ibm.dw.jaxme.student.*;
public class JaxMeTester {
/** Input XML File */
private File inputFile;
public JaxMeTester(String inputFilename) {
this.inputFile = new File(inputFilename);
}
public Students readXML() throws IOException, JAXBException {
// Get a handle to the input file
InputSource source =
new InputSource(new FileInputStream(inputFile));
source.setSystemId(inputFile.toURL().toString());
// Parse
JAXBContext ctx = JAXBContext.newInstance(
"com.ibm.dw.jaxme.student");
Unmarshaller u = ctx.createUnmarshaller();
return (Students)u.unmarshal(source);
}
public void printStudents(Students students, PrintStream out) throws IOException {
// Get a map of college IDs and names
Map colleges = new HashMap();
List list = students.getCollege();
for (Iterator i = list.iterator(); i.hasNext(); ) {
College college = (College)i.next();
colleges.put(college.getId(), college.getName());
}
out.print("\n\n--- Student Listings ---\n\n");
list = students.getStudent();
for (Iterator i = list.iterator(); i.hasNext(); ) {
Student student = (Student)i.next();
out.println("Name: " + student.getFirstName() + " " + student.getLastName());
List addresses = student.getAddress();
for (Iterator j = addresses.iterator(); j.hasNext(); ) {
Address address = (Address)j.next();
printAddress(address, out);
}
out.println("College: " + colleges.get(student.getCollegeId()));
out.println();
}
list = students.getCollege();
for (Iterator i = list.iterator(); i.hasNext(); ) {
College college = (College)i.next();
out.println("Name: " + college.getName());
out.println("Address: ");
printAddress(college.getAddress(), out);
out.println();
}
}
private void printAddress(Address address, PrintStream out) throws IOException {
out.print(" " + address.getStreet() + "\n");
out.print(" " + address.getCity() + ", " + address.getState() + " " +
address.getZip() + "\n");
}
public static void main(String[] args) {
if (args.length < 1) {
System.err.println("Incorrect arguments supplied!");
System.err.println("Usage: java com.ibm.dw.jaxme.example.JaxMeTester " +
"[input XML filename]");
return;
}
try {
JaxMeTester tester = new JaxMeTester(args[0]);
Students students = tester.readXML();
tester.printStudents(students, System.out);
} catch (Exception e) {
System.err.println("Error occurred: " + e.getMessage());
e.printStackTrace(System.err);
}
}
}
|
设置输入文件
首先要将 XML 输入文件变为 JaxMe（以及底层的 SAX 解析器）能够使用的形式。显然应该选择 SAX 的
InputSource 类，这是文件、流以及您能够想到的任何东西的统一输入格式。清单 4 中的内容是从上例中摘出来的，可以看到
JaxMeTester 所接受的
String 文件名被转化为
InputSource （包括几个中间步骤）。
清单 4. 将输入文件转化为 InputSource
/** Input XML File */
private File inputFile;
public JaxMeTester(String inputFilename) {
this.inputFile = new File(inputFilename);
}
public Students readXML() throws IOException, JAXBException {
// Get a handle to the input file
InputSource source =
new InputSource(new FileInputStream(inputFile));
source.setSystemId(inputFile.toURL().toString());
// Parse
}
|
如果您恰好熟悉 SAX，没有什么特别值得注意的地方。惟一需要指出的是
File 的使用，这里没有直接传递
String 。虽然可以采用后一种方法，但是这样做就没有 Java 语言
File 类所提供的保护了。事实上，
InputSource 在构造函数中做的第一件事就是将
String 转化为
File ，这正是我们要做的。此外，这种方法很容易设置输入文件的系统 ID，如果直接使用
String 而不是对象就麻烦得多了。
设置 JaxMe
接下来要设置 JaxMe 解组，只需要一行代码，如清单 5 所示。这里要告诉 JAXB 上下文（要记住 JaxMe 是 JAXB 的一种实现，因此常常使用这种语义）到哪里寻找
jaxb.properties文件。我总是将其放在与相关类相同的目录中，就是说只要使用生成类的包名就可以了。
清单 5. 告诉 JaxMe 到哪里寻找属性文件
JAXBContext ctx = JAXBContext.newInstance(
"com.ibm.dw.jaxme.student");
|
该文件本身只有一行，如清单 6 所示，它告诉 JAXB 要加载哪一种数据绑定上下文实现。
清单 6. jaxb.properties 文件
javax.xml.bind.context.factory=org.apache.ws.jaxme.impl.JAXBContextImpl
|
这里值得一提的是代码中
没有JaxMe 专用的类。虽然必须将 JaxMe 放在类路径中，但 JAXB 从这个属性文件中获得所有 JaxMe 专用的信息。换句话说，不用改变代码就可以从 JAXB 的参考实现切换为 JaxMe（强烈建议使用）。
解组
建立了 JAXB 上下文之后，将 XML 文件转化为 Java 表示很容易，如清单 7 所示，这些细节没有吸引人的地方。
清单 7. 解组 XML
public Students readXML() throws IOException, JAXBException {
// Get a handle to the input file
InputSource source =
new InputSource(new FileInputStream(inputFile));
source.setSystemId(inputFile.toURL().toString());
// Parse
JAXBContext ctx = JAXBContext.newInstance(
"com.ibm.dw.jaxme.student");
Unmarshaller u = ctx.createUnmarshaller();
return (Students)u.unmarshal(source);
}
|
当然，这段代码非常令人厌烦，但正因如此也就显得很棒；这仅仅是
劳动，就您而言不用花费多少心思。
处理 XML
一旦获得
Students 对象，也就完成了这个练习中的数据绑定部分。
printStudents() 方法可以说明这一点，因为它根本不知道 JAXB 或者 JaxMe 的存在。事实上也可以在不同的类中（甚至非 Java 语言模块中），没有任何问题。这里不再重复列出代码，只不过是 Java 对象的一些打印调用。
程序的输出
您可以运行
JaxMeTester 并提供前面的 XML 输入文件来测试这些代码。该程序将会折腾上一秒钟，然后输出与清单 8 类似的结果。这是最漂亮的打印工作，但是应该让您明白使用 JaxMe 读 XML 文件是多么简单。
清单 8. 程序对 student1.xml 的输出结果
test:
[java] --- Student Listings ---
[java] Name: Brett McLaughlin
[java] 1029 Burlingham
[java] Waco, TX 87610
[java] College: Louisiana Baptist University
[java] Name: Gary Greathouse
[java] 9098 Townhall Drive
[java] Waco, TX 87621
[java] College: Louisiana Baptist University
[java] Name: Louisiana Baptist University
[java] Address:
[java] 6301 Westport Avenue
[java] Shreveport, LA 71129
BUILD SUCCESSFUL
Total time: 3 seconds
|
|
转向 Ant
与以前的文章一样，我使用 Ant 完成编译、运行和其他大部分工作。上一篇文章中已经详细介绍了 Ant 的用法，因此这里只需要引入构建文件（
build.xml）就可以了。默认的目标包括生成类、编译生成的示例类并运行该例子，因此您只需要修改几个路径并输入
ant 就可以了。
|
|
使用数据
您可能已经猜到，一旦转化成 Java 形式这些数据的使用就非常简单了。而且这些操作同样与 JaxMe 毫无关系。因此我只给出一些代码，这些代码增加一所新的学院并改变一直处理的学校，代码的功能您可以自己分析，新增的方法如清单 9 所示。
清单 9. 在内存中修改学生信息
public void modifyStudents(Students students) {
// Add a college
College college = new com.ibm.dw.jaxme.student.impl.CollegeImpl();
college.setName("Norris Bible Baptist Seminary");
college.setId("NBBS");
Address address = new com.ibm.dw.jaxme.student.impl.AddressImpl();
address.setStreet("724 North Jim Wright Freeway");
address.setCity("Ft. Worth");
address.setState("TX");
address.setZip(new java.math.BigInteger("76108"));
college.setAddress(address);
// Add the college in
List colleges = students.getCollege();
colleges.add(college);
// Change a student‘s college
List list = students.getStudent();
for (Iterator i = list.iterator(); i.hasNext(); ) {
Student student = (Student)i.next();
if (student.getFirstName().equals("Brett") &&
student.getLastName().equals("McLaughlin")) {
student.setCollegeId("NBBS");
}
}
}
|
代码主体中还增加了一些额外的打印语句，如清单 10 所示。
清单 10. 其他的打印语句
public static void main(String[] args) {
if (args.length < 1) {
System.err.println("Incorrect arguments supplied!");
System.err.println("Usage: java com.ibm.dw.jaxme.example.JaxMeTester " +
"[input XML filename]");
return;
}
try {
JaxMeTester tester = new JaxMeTester(args[0]);
Students students = tester.readXML();
System.out.println("Students after reading in from disk...");
tester.printStudents(students, System.out);
tester.modifyStudents(students);
System.out.println("\n\nStudents after in-memory modifications...");
tester.printStudents(students, System.out);
} catch (Exception e) {
System.err.println("Error occurred: " + e.getMessage());
e.printStackTrace(System.err);
}
}
|
输出结果如清单 11 所示，其中仅列出了学生清单修改
后的结果。
清单 11. 修改后的打印输出
[java] --- Student Listings ---
[java] Name: Brett McLaughlin
[java] 1029 Burlingham
[java] Waco, TX 87610
[java] College: Norris Bible Baptist Seminary
[java] Name: Gary Greathouse
[java] 9098 Townhall Drive
[java] Waco, TX 87621
[java] College: Louisiana Baptist University
[java] Name: Louisiana Baptist University
[java] Address:
[java] 6301 Westport Avenue
[java] Shreveport, LA 71129
[java] Name: Norris Bible Baptist Seminary
[java] Address:
[java] 724 North Jim Wright Freeway
[java] Ft. Worth, TX 76108
|
对于多数读者而言这都是些老生常谈，但对于刚接触数据绑定的读者而言，让我强调一下这一小段代码的重要意义。它说明您不需要
将 XML 作为 XML处理。事实上，除了将您带入数据绑定的大门之外，Java 代码一直在完成其他所有工作。虽然 SAX 和 DOM（以及 JDOM、dom4j 等等）很重要，而且对于底层系统可以说至关重要，但一般的 Java 程序员不再需要了解这些东西了。
Java 程序员可以编写接收和输出基本 Java 对象的所有方法，不论这些对象来自何处去向何方。就像良好的数据库代码把数据库交互和普通程序员分隔开一样，数据绑定也能做到。一旦某个方法不再使用对象，它就不需要知道信息是否被保存，当然也不需要知道信息是
如何保存的。这正是数据绑定的优美之处！
从 Java 转化到 XML
现在要将修改后的列表再保存到 XML 中。虽然可以覆盖原来的 student1.xml 文件，但是我更喜欢写入一个新的文件（从而可以比较异同）student2.xml。为此需要稍微修改
main() 方法，如清单 12 所示。
清单 12. 增加第二个参数作为输出文件名
public static void main(String[] args) {
if (
args.length < 2) {
System.err.println("Incorrect arguments supplied!");
System.err.println("Usage: java com.ibm.dw.jaxme.example.JaxMeTester " +
"[input XML filename] [output XML filename]");
return;
}
try {
JaxMeTester tester = new JaxMeTester(args[0]);
Students students = tester.readXML();
System.out.println("Students after reading in from disk...");
tester.printStudents(students, System.out);
tester.modifyStudents(students);
System.out.println("\n\nStudents after in-memory modifications...");
tester.printStudents(students, System.out);
tester.writeStudents(students, args[1]);
} catch (Exception e) {
System.err.println("Error occurred: " + e.getMessage());
e.printStackTrace(System.err);
}
}
|
增加序列化代码
现在剩下的只有新的
writeStudents() 方法了，这个方法如此简单，我找不到任何理由来进一步解释，如清单 13 所示。
清单 13. 序列化 XML
public void writeStudents(Students students, String outputFile)
throws IOException, JAXBException {
// Serialize
JAXBContext ctx = JAXBContext.newInstance(
"com.ibm.dw.jaxme.student");
Marshaller m = ctx.createMarshaller();
FileWriter writer = new FileWriter(outputFile);
m.marshal(students, writer);
writer.close();
}
|
 |
丢失的 import 语句
现在还需要增加几个 import 语句。我不准备列出整个文件，但建议您下载本文的代码，其中包括完整的
JaxMeTester 源代码。
|
|
这些代码看起来与解组过程非常相似。通过 JAXB 创建了一个新的
Marshaller ，同样使用指定位置的 jaxb.properties 文件。然后将输出文件名包装在一个 writer 中，执行序列化并关闭 writer(
千万不要忘记关闭 writer！）。呜啦！编码、编译然后运行。
还记得“往返”吗？
结束之前让我们看一看输出文件（如果您使用了我给出的名称应该是 student2.xml），如清单 14 所示。
清单 14. student2.xml
<stu:students xmlns:stu="http://dw.ibm.com/jaxme/student">
<stu:student>
<stu:firstName>Brett</stu:firstName>
<stu:lastName>McLaughlin</stu:lastName>
<stu:collegeId>NBBS</stu:collegeId>
<stu:address type="home">
<stu:street>1029 Burlingham</stu:street>
<stu:city>Waco</stu:city>
<stu:state>TX</stu:state>
<stu:zip>87610</stu:zip>
</stu:address>
</stu:student>
<stu:student>
<stu:firstName>Gary</stu:firstName>
<stu:lastName>Greathouse</stu:lastName>
<stu:collegeId>LBU</stu:collegeId>
<stu:address type="home">
<stu:street>9098 Townhall Drive</stu:street>
<stu:city>Waco</stu:city>
<stu:state>TX</stu:state>
<stu:zip>87621</stu:zip>
</stu:address>
</stu:student>
<stu:college id="LBU">
<stu:name>Louisiana Baptist University</stu:name>
<stu:address type="home">
<stu:street>6301 Westport Avenue</stu:street>
<stu:city>Shreveport</stu:city>
<stu:state>LA</stu:state>
<stu:zip>71129</stu:zip>
</stu:address>
</stu:college>
<stu:college id="NBBS">
<stu:name>Norris Bible Baptist Seminary</stu:name>
<stu:address>
<stu:street>724 North Jim Wright Freeway</stu:street>
<stu:city>Ft. Worth</stu:city>
<stu:state>TX</stu:state>
<stu:zip>76108</stu:zip>
</stu:address>
</stu:college>
</stu:students>
|
您马上就会注意到所有的元素都正确使用了名称空间，而这个名称空间用前缀
stu 给出。因此该文件在语义上与输入是等价的（当然包含了新增加的信息），虽然看起来非常不同。这需要回顾
本系列文章的第一篇中所讨论的问题 —— 往返，XML 允许这样做，如果不习惯的话可能会令您感到困惑。如果您完全迷惑了，请再读一读第一篇文章。但是在明确指出这种差别之前，我还不想结束本文。
再论工具 API
还
记得前面对工具 API 的讨论吗？我曾经说过数据绑定和工具 API 不同。我希望您注意到了这句话，因为这一点非常重要。数据绑定
API（JaxMe
仅是其中之一）的不利之处是很容易弥漫到所有的代码中。我曾经见过一些项目，虽然采用的体系结构相对不错，但是数据绑定出现在所有能够想像得到的地方，并
且有几个地方我 从来都没有想像过。结果如果需要修改代码，升级和 API 转换是完全不可能的，因为应用程序的很多部分必须重新实现、重新测试、重新部署。
作为一名程序员应尽量避免出现这种情况。按照经验法则，应用程序层次之间应保持
无关性而非
依赖性。
为此，应使用数据绑定 API 隔离业务层和编组解组 XML 的代码之间的交互。可以增加一个数据绑定层，防止直接调用 JaxMe（或者 JAXB
以及所用的其他 API）。我曾经看到过各种各样的解决方案 —— 我自己也曾提出几种方法 ——
只要您愿意隔离这些代码。这意味着升级或者修改只影响到隔离的少量代码，应用程序的其他部分仍然可以运行。记住这一点，您就不会烦恼缠身了。
结束语
掌握了 JaxMe 的基本用法之后，下一篇文章将介绍该 API 较难的地方，分析 JaxMe 为什么比它的表兄弟 JAXB 提供了
更多的功能。具体来说，我将关注数据库支持，详细探讨如何使用 JaxMe 向数据库中插入数据，如 MySQL。然后如果时间和空间允许的话（只能希望），我还将说明同样的技术如何用于 XML 数据库。
再后面呢？只有我的想像力才知道。：）我确实有一些想法，不过您要坚持读下去才会知道到底是什么。到那时候希望能再看到您。
参考资料
关于作者
|
|
|
|
Brett
McLaughlin 从 Logo 时代（还记得那个小三角吗？）就开始从事计算机。最近几年，他已经成为 Java 技术和 XML
社区最知名的作家和程序员之一。他曾经在 Nextel Communications 实现过复杂的企业系统，在 Lutris
Technologies 实际编写应用程序服务器，最近又在 O‘Reilly Media, Inc. 继续撰写和编辑这方面的书籍。他的新著 Java 1.5 Tiger: A Developer‘s Notebook是关于新版本 Java 技术的第一本参考书，经典巨著
Java and XML仍然是在 Java 技术中使用 XML 技术的权威参考。
|
|
