内容


实用数据绑定

深入考察 JAXB,第 2 部分

进一步考察 JAXB 的往返能力

Comments

系列内容:

此内容是该系列 # 部分中的第 # 部分: 实用数据绑定

敬请期待该系列的后续内容。

此内容是该系列的一部分:实用数据绑定

敬请期待该系列的后续内容。

数据绑定 API 允许通过编程操纵 XML,从这一点上说它非常有用。输入 someElement.addAttribute("name", "value"); 要比解析文件、缓冲输出、添加组成属性声明的字符、关闭流和刷新输出流容易得多。但是如果不能正确地把变动写回文件,所有这些操纵就没有多少用处。本文重点讨论数据绑定世界中所谓的 编组(marshalling)过程,特别是 JAXB 的编组能力。具体来说,您将了解 JAXB 如何在往返的舞台上取得成功。

回顾

本专栏的 第一篇中,您已经了解一些重要的术语: 编组解组(unmarshalling)是数据绑定世界固有的概念;不过还有一些新的术语,如 往返语义等价。往返是指从 XML 转换成 Java 代码然后再转换回去的过程。数据绑定往返能力的质量通过输入和输出文档匹配的程度衡量。语义等价使得比较成为可能,它允许丢弃 XML 中不重要的成分如可以忽略的空格,从而可以进行有效的比较。

第 2 篇中,我介绍了一个简单的 XML 文档,在这里再写出来,如清单 1 所示。

清单 1. 吉他的基本 XML 清单(guitars.xml)
<guitars>
  <guitar id="10021">
    <builder luthier="true">Ryan</builder>
    <model>Mission Grand Concert</model>
    <back-sides>Brazilian Rosewood</back-sides>
    <top>Adirondack Spruce</top>
    <notes>
      <![CDATA[
        Just unbelievable...   this guitar has all the tone & 
        resonance you could ever want. I mean, <<WOW!!!>> This 
        is a lifetime guitar.
      ]]>
    </notes>
  </guitar>
  <guitar id="0923">
    <builder smallShop="true">Bourgeois</builder>
    <model>OMC</model>
    <back-sides>Bubinga</back-sides>
    <top>Adirondack Spruce</top>
  </guitar>
  <guitar id="11091">
    <builder>Martin & Company</builder>
    <model>OM-28VR</model>
    <back-sides>Indian Rosewood</back-sides>
    <top bearclaw="true">Sitka Spruce</top>
    <notes>It's certainly true that Martin isn't the only game in town anymore. 
           Still, the OM-28VR is one of their best models...     and this one 
           has some fabulous bearclaw to boot.              Nice specimen of a 
           still-important guitar manufacturer.
    </notes>
  </guitar>
</guitars>

我还为这个文档准备了一个模式,为了简化起见这里不再重复列出,要说明的是如何从这个模式生成 Java 源文件,如清单 2 所示。

清单 2. 生成的JAXB 类
C:\developerworks>xjc -p com.ibm.dw guitars.xsd -d src
parsing a schema...
compiling a schema...
com\ibm\dw\impl\runtime\MSVValidator.java
com\ibm\dw\impl\runtime\SAXUnmarshallerHandlerImpl.java
com\ibm\dw\impl\runtime\ErrorHandlerAdaptor.java
com\ibm\dw\impl\runtime\AbstractUnmarshallingEventHandlerImpl.java
com\ibm\dw\impl\runtime\UnmarshallableObject.java
com\ibm\dw\impl\runtime\SAXMarshaller.java
com\ibm\dw\impl\runtime\XMLSerializer.java
com\ibm\dw\impl\runtime\ContentHandlerAdaptor.java
com\ibm\dw\impl\runtime\UnmarshallingEventHandlerAdaptor.java
com\ibm\dw\impl\runtime\SAXUnmarshallerHandler.java
com\ibm\dw\impl\runtime\ValidatorImpl.java
com\ibm\dw\impl\runtime\ValidatableObject.java
com\ibm\dw\impl\runtime\UnmarshallerImpl.java
com\ibm\dw\impl\runtime\NamespaceContext2.java
com\ibm\dw\impl\runtime\Discarder.java
com\ibm\dw\impl\runtime\NamespaceContextImpl.java
com\ibm\dw\impl\runtime\ValidatingUnmarshaller.java
com\ibm\dw\impl\runtime\UnmarshallingContext.java
com\ibm\dw\impl\runtime\GrammarInfoImpl.java
com\ibm\dw\impl\runtime\ValidationContext.java

要保证生成并编译了这些 Java 源文件以备使用。详细的步骤请参阅本系列的 上一篇文章

XML 到 Java 代码

只要生成并准备好这些类,就可以把 清单 1中的 XML 文档解组成 JAXB 在内存中的模型。这是测试 JAXB 往返能力的第一步。因为这不是一篇关于 JAXB 基础的文章(这类文章请参阅 参考资料),我仅仅把代码列在下面,如清单 3 所示。

清单 3. 解组 XML 到 Java 代码
import java.io.FileInputStream;
import javax.xml.bind.*;
// Import generated classes
import com.ibm.dw.*;
public class RoundTripper {
  private String inputFilename;
  private String outputFilename;
  private JAXBContext jc;
  private final String PACKAGE_NAME = "com.ibm.dw";
  public RoundTripper(String inputFilename, String outputFilename) throws Exception {
    this.inputFilename = inputFilename;
    this.outputFilename = outputFilename;
    jc = JAXBContext.newInstance(PACKAGE_NAME);
  }
  public Guitars unmarshal() throws Exception {
    Unmarshaller u = jc.createUnmarshaller();
    return (Guitars)u.unmarshal(new FileInputStream(inputFilename));
  }
  public static void main(String[] args) {
    if (args.length < 2) {
     System.err.println("Incorrect usage: java RoundTripper" +
                   "[input XML filename] [output XML filename]");
      return;
    }
    try {
      RoundTripper rt = new RoundTripper(args[0], args[1]);
      Guitars guitars = rt.unmarshal();
    } catch (Exception e) {
      e.printStackTrace();
      return;
    }
  }
}

注意:如果设置和运行这些类有问题,请参考本文的最后一节“ 运行示例程序”。

在这里一些人可能认为应该打印出内存中的版本。但是,用于打印内存中某些内容的 API 也可用于把数据写入输出流,因此这一步实际上不需要。

Java 代码到 XML

现在可以要求 JAXB 把内存中的表示再返回到 XML。这样就可以观察输入文件和输出文件的区别。我已经向 RoundTripper 类中增加了一些代码来完成这项工作,如清单 4 所示。

清单 4. 编组 Java 到 XML
import java.io.FileInputStream;
        import java.io.FileOutputStream;
import javax.xml.bind.*;
// Import generated classes
import com.ibm.dw.*;
public class RoundTripper {
  private String inputFilename;
  private String outputFilename;
  private JAXBContext jc;
  private final String PACKAGE_NAME = "com.ibm.dw";
  public RoundTripper(String inputFilename, String outputFilename) 
  throws Exception {
    this.inputFilename = inputFilename;
    this.outputFilename = outputFilename;
    jc = JAXBContext.newInstance(PACKAGE_NAME);
  }
  public Guitars unmarshal() throws Exception {
    Unmarshaller u = jc.createUnmarshaller();
    return (Guitars)u.unmarshal(new FileInputStream(inputFilename));
  }
        
  public void marshal(Guitars guitars) throws Exception {
    Marshaller m = jc.createMarshaller();
    m.marshal(guitars, new FileOutputStream(outputFilename));
  }
  public static void main(String[] args) {
    if (args.length < 2) {
     System.err.println("Incorrect usage: java RoundTripper" +
         "[input XML filename] [output XML filename]");
      return;
    }
    try {
      RoundTripper rt = new RoundTripper(args[0], args[1]);
      Guitars guitars = rt.unmarshal();
      
        rt.marshal(guitars);
    } catch (Exception e) {
      e.printStackTrace();
      return;
    }
  }
}

同样,这里的代码也相当简单,意义明确。我使用 guitars.xml 作为输入文件运行这个程序,并提供 output.xml 作为输出文件名。没有什么输出值得一提,和写到终端上的文本一样,不过执行这个过程您将得到一个新的文件(output.xml)。理论上讲,这个文件应该是 guitars.xml 的完全复制,因为在内存中没有改变该文件。

拿苹果和苹果比较

生成 output.xml 之后打开它。即使不完全相同,也应该和清单 5 类似。

清单 5. output.xml
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<guitars>
	<guitar id="10021">
		<builder luthier="true">Ryan<builder>
		<model>Mission Grand Concert</model>
		<back-sides>Brazilian Rosewood<back-sides>
		<top>Adirondack Spruce<top>
		<notes>
      
        Just unbelievable...   this guitar has all the tone & 
        resonance you could ever want. I mean, <<WOW!!!>> 
        This is a lifetime guitar.
      
    <notes>
	</guitar>
	<guitar id="0923">
		<builder smallShop="true">Bourgeois</builder>
		<model>OMC<model>
		<back-sides>Bubinga<back-sides>
		<top>Adirondack Spruce</top>
	<guitar>
	<guitar id="11091">
		<builder>Martin & Company<builder>
		<model>OM-28VR<model>
		<back-sides>Indian Rosewood<back-sides>
		<top bearclaw="true">Sitka Spruce<top>
		<notes>It's certainly true that Martin isn't the only
		 game in town anymore.
      Still, the OM-28VR is one of their best models... 
      and this one 
      has some fabulous bearclaw to boot.
       Nice specimen of a 
      still-important guitar manufacturer.
    <notes>
	<guitar>
<guitars>

现在有了输入和输出文件,通过互相比较可以看看 JAXB 在往返中是如何工作的(原始文件如 清单 1所示)。

增加 XML 声明

首先,注意到输入文件没有 XML 声明(以 <xml version=... 开始的那一行)。JAXB 自动在输出中插入这一行。这看起来似乎是一个小问题,但非常重要——现在常常需要在一个 XML 文档中包含另一个 XML 文件,特别是在使用 SOAP 或者其他传输技术的时候。插入 XML 声明的问题在与一个 XML 文档只能有一个声明。如果把 guitars.xml 插入另一个 XML 文档,您并没有违反这一规则;但是另一方面如果插入的是 output.xml,问题就出来了。因此现在 JAXB 又一个需要注意的特性。

去掉 CDATA 节

还要注意,原始 XML 文档中的 CDATA 节被去掉了。从技术上讲这并没有违反语义等价的规则,两个文档的内容在语义上是相同的。第一个文档使用 CDATA 避免实体引用,而在输出文档中为了支持实体引用而放弃了 CDATA。这更多的是文档的事实等价问题而非 语义等价问题。虽然这不是一个重要的问题,但也应该注意。

空白处理

高兴地看到正确地处理了空白。虽然去掉了 CDATA 节,但空白正确地保留了下来。此外,关于 Martin OM-28VR 吉他描述中的长空白也原样保留了下来,这方面解决得很好。

为了确认重新测试一遍

评价往返能力最好的也是最有效的方式是 重新测试往返过程。但是要注意,我并不是说简单地再进行一次测试。相反,这次把输出文件(output.xml)提供给往返程序作为 输入文件。如果说这个过程向 XML 文件中引入了不应该有的什么内容,那就是每次后续的往返创建的输出都和原始文件(guitars.xml)离得更远一点。这对于隔离问题是一种很好的方式。好的数据绑定工具应该能够一遍一遍地总是创建相同的文件,特别是在最初的往返过程之后。

在这一步中,我要求 RoundTripper 生成 retest.xml,以 output.xml 作为源 XML。结果如清单 6 所示。

清单 6. retest.xml
<xml version="1.0" encoding="UTF-8" standalone="yes"?>
<guitars>
	<guitar id="10021">
		<builder luthier="true">Ryan<builder>
		<model>Mission Grand Concert</model>
		<back-sides>Brazilian Rosewood<back-sides>
		<top>Adirondack Spruce<top>
		<notes>
      
        Just unbelievable...   this guitar has all the tone & 
        resonance you could ever want. I mean, <<WOW!!!>> This 
        is a lifetime guitar.
      
    <notes>
	<guitar>
	<guitar id="0923">
		<builder smallShop="true">Bourgeois<builder>
		<model>OMC<model>
		<back-sides>Bubinga<back-sides>
		<top>Adirondack Spruce<top>
	<guitar>
	<guitar id="11091">
		<builder>Martin & Company</builder>
		<model>OM-28VR<model>
		<back-sides>Indian Rosewood<back-sides>
		<top bearclaw="true">Sitka Spruce<top>
		<notes>It's certainly true that Martin isn't 
		the only game in town anymore.
      Still, the OM-28VR is one of their best models...  and this one 
      has some fabulous bearclaw to boot. Nice specimen of a 
      still-important guitar manufacturer.
    <notes>
	</guitar>
<guitars>

好消息是 清单 5清单 6完全相同,这说明 JAXB 经过最初的往返步骤之后可以很好地工作。

总的来说 JAXB 表现得很好。虽然我认为自动增加 XML 声明确实是一个问题,但和影响内容的 API 相比不算很糟。JAXB 还以和预期稍有不同的方式处理 CDATA 节,但确实保持了语义等价。下一篇文章中,我将介绍进一步影响输出文件的各种选项,手工解决 JAXB 造成的一些问题。但总而言之,JAXB 证明自己能够很好地按照期望保持输入文档。

运行示例程序

最后让我们来分享我的一个秘技,用于轻松制作 classpath 和 JAXB 示例的 Ant 设置。清单 7 是我在本文中使用的 Ant 构建文件。您要使用这个文件,只需要把路径改为您自己的 XML 输入文件,以及您的 JAXB JAR 文件。

清单 7. Ant 构建文件
<?xml version="1.0"?>
<project basedir="." default="roundtrip">
	<property name="jwsdp.home" value="c:\jwsdp-1.3"/>
	<property name="xml.inputFile" value="guitars.xml"/>
	<property name="xml.outputFile" value="output.xml"/>
	<property name="xml.retestFile" value="retest.xml"/>
	<path id="classpath">
		<pathelement path="build"/>
		<fileset dir="${jwsdp.home}" includes="jaxb/lib/*.jar"/>
		<fileset dir="${jwsdp.home}" includes="jwsdp-shared/lib/*.jar"/>
		<fileset dir="${jwsdp.home}" includes="jaxp/lib/**/*.jar"/>
	<path>
	<taskdef name="xjc" classname="com.sun.tools.xjc.XJCTask">
		<classpath refid="classpath"/>
	<taskdef>
	<!-- compile Java source files -->
	<target name="compile">
		<!-- generate the Java content classes from the schema -->
		<echo message="Compiling the schema external binding file..."/>
		<xjc schema="guitars.xsd" package="com.ibm.dw" target="src"/>
		<!-- compile all of the java sources -->
		<echo message="Compiling the java source files..."/>
		<javac srcdir="src" destdir="build" debug="on">
			<classpath refid="classpath"/>
		</javac>
		
		<!-- Copy over the properties files -->
		<copy todir="build">
		  <fileset dir="src">
		    <exclude name="**/*.java"/>
		  </fileset>
		<copy>
	<target>
	
	<target name="roundtrip" depends="compile">
	  <echo message="Converting XML file to Java and back..."/>
	  <java classname="RoundTripper">
	    <arg value="${xml.inputFile}" />
	    <arg value="${xml.outputFile}" />
	    <classpath refid="classpath" />
	  </java>
	<target>
	
	<target name="roundtrip-retest" depends="roundtrip">
	  <echo message="Converting XML file to Java and back... (Second iteration)"/>
	  <java classname="RoundTripper">
	    <arg value="${xml.outputFile}" />
	    <arg value="${xml.retestFile}" />
	    <classpath refid="classpath" />
	  <java>
	<target>
<project>

默认情况下,这个文件将从模式生成源文件、编译这些源文件并复制需要的 JAXB 属性文件,然后编译并运行 RoundTripper 类。您可以手工运行 roundtrip-retest 目标,它执行第二遍往返过程,使用 output.xml 作为输入文件。该文件会使生活轻松许多,但愿您喜欢它!


相关主题


评论

添加或订阅评论,请先登录注册

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=10
Zone=XML
ArticleID=21954
ArticleTitle=实用数据绑定: 深入考察 JAXB,第 2 部分
publish-date=07012004