使用 JAXB 工具根据 Java 类生成 XML 模式

使用 JAXB 工具根据 Java 类生成 XML 模式文件2008-10-31 20:02使用 JAXB 工具根据 Java 类生成 XML 模式文件

使用 Java XML 绑定体系结构（JAXB）工具根据 Java 类生成 XML 模式文件。
在您开始之前
标识 Java 类或一组 Java 对象以映射至 XML 模式文件。
关于本任务

使用 JAXB API 和工具在 Java 类与 XML 模式之间建立映射。XML 模式文档描述了 XML 文档中的数据元素和关系。在数据映射或绑定存在后，可以在 XML 文档与 Java 对象之间进行转换。现在不必理解数据结构即可访问 XML 文档中存储的数据。

通过使用 JAXB 模式生成器 schemagen 命令行工具，可以根据表示 Java 应用程序的数据元素的现有 Java 应用程序来创建 XML 模式文档。JAXB 模式生成器处理 Java 源文件或类文件。Java 类注释能够定制从现有 Java 类到生成模式组件的缺省映射。XML 模式文件以及带注释的 Java 类文件包含 JAXB 运行时对 XML 文档以进行编组和取消编组所需的所有必需信息。
过程

   1. 找到带注释的 Java 源文件或 Java 类文件以用于生成 XML 模式文件。 确保 Java 类文件所引用的所有类均包含在类路径定义中，或者通过 -classpath/-cp 选项提供给工具。
   2. 使用 JAXB 模式生成器 schemagen 命令来生成 XML 模式。 模式生成器位于 app_server_root\bin\ 目录中。
      [Windows]

      app_server_root\bin\schemagen.bat myObj1.java myObj2.java

      [Linux] [AIX] [HP-UX] [Solaris]

      app_server_root/bin/schemagen.sh myObj1.java myObj2.java

      其中，参数 myObj1.java 和 myObj2.java 是包含数据对象的 Java 文件的名称。
      如果 myObj1.java 或 myObj2.java 引用未传递至 schemagen 命令的 Java 类，那么必须使用 -cp 选项来提供这些 Java 类的类路径位置。
   3. （可选）使用在 javax.xml.bind.annotations 包中定义的 JAXB 程序注释来定制 JAXB XML 模式映射。

结果

在根据 Java 类生成 XML 模式文件后，那么可以将 Java 对象作为 XML 实例文档进行编组和取消编组。
避免故障： 当多个 XMLType 注释在不同 Java 包中定义了同一个 @XMLType 名称时，schemagen 命令无法在这些注释之间区分 XML 名称空间。如果出现了这种情况，那么将产生以下错误：

Error: Two classes have the same XML type name ....
Use @XmlType.name and @XmlType.namespace to assign different names to them...

此错误指示您具有同名的类或 @XMLType.name 值，但它们存在于不同的 Java 包中。要防止此错误，请将 @XML.Type.namespace 类添加至现有的 @XMLType 注释以区分 XML 类型。gotcha
示例
以下示例说明 JAXB 工具如何根据现有 Java 类 Bookdata.java 生成 XML 模式文件。

   1. 将以下 Bookdata.java 文件复制到临时目录。

      package generated;

      import javax.xml.bind.annotation.XmlAccessType;
      import javax.xml.bind.annotation.XmlAccessorType;
      import javax.xml.bind.annotation.XmlAttribute;
      import javax.xml.bind.annotation.XmlElement;
      import javax.xml.bind.annotation.XmlType;
      import javax.xml.datatype.XMLGregorianCalendar;



      @XmlAccessorType(XmlAccessType.FIELD)
      @XmlType(name = "bookdata", propOrder = {
          "author",
          "title",
          "genre",
          "price",
          "publishDate",
          "description"
      })
      public class Bookdata {

          @XmlElement(required = true)
          protected String author;
          @XmlElement(required = true)
          protected String title;
          @XmlElement(required = true)
          protected String genre;
          protected float price;
          @XmlElement(name = "publish_date", required = true)
          protected XMLGregorianCalendar publishDate;
          @XmlElement(required = true)
          protected String description;
          @XmlAttribute
          protected String id;

           public String getAuthor() {
              return author;
          }
          public void setAuthor(String value) {
              this.author = value;
          }
          public String getTitle() {
              return title;
          }

           public void setTitle(String value) {
              this.title = value;
          }

       
          public String getGenre() {
              return genre;
          }
        
          public void setGenre(String value) {
              this.genre = value;
          }

         
          public float getPrice() {
              return price;
          }

         
          public void setPrice(float value) {
              this.price = value;
          }

        
          public XMLGregorianCalendar getPublishDate() {
              return publishDate;
          }

         
          public void setPublishDate(XMLGregorianCalendar value) {
              this.publishDate = value;
          }

        
          public String getDescription() {
              return description;
          }

         
          public void setDescription(String value) {
              this.description = value;
          }

        
          public String getId() {
              return id;
          }

         
          public void setId(String value) {
              this.id = value;
          }

      }

   2. 打开命令提示符。
   3. 从复制 Bookdata.java 文件的目录中运行 schemagen 模式生成器工具。
      [Windows]

      app_server_root\bin\schemagen.bat Bookdata.java

      [Linux] [AIX] [HP-UX] [Solaris]

      app_server_root/bin/schemagen.sh Bookdata.java

   4. 将生成 XML 模式文件 schema1.xsd：

      <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
      <xs:schema version="1.0" xmlns:xs="http://www.w3.org/2001/XMLSchema">

        <xs:complexType name="bookdata">
          <xs:sequence>
            <xs:element name="author" type="xs:string"/>
            <xs:element name="title" type="xs:string"/>
            <xs:element name="genre" type="xs:string"/>
            <xs:element name="price" type="xs:float"/>
            <xs:element name="publish_date" type="xs:anySimpleType"/>
            <xs:element name="description" type="xs:string"/>
          </xs:sequence>
          <xs:attribute name="id" type="xs:string"/>
        </xs:complexType>
      </xs:schema>

请参阅 JAXB 2.0 参考实施文档，以了解 schemagen 命令的更多信息


================================================================

将 JAXB 用于 XML 数据绑定

Java XML 绑定体系结构（JAXB）是一种 Java 技术，提供一种简单便捷的方法来映射 Java 类和 XML 模式，从而简化 Web Service 开发。JAXB 提供模式编译器、模式生成器和运行时框架来支持 Java 对象与 XML 文档之间的双向映射。
关于本任务

JAXB 是一种 XML 至 Java 绑定技术，允许在模式与 Java 对象之间进行变换以及在 XML 实例文档与 Java 对象实例之间进行变换。JAXB 技术包含运行时 API 并随附可简化对 XML 文档的访问权的工具。可以使用 JAXB API 和工具在 Java 类与 XML 模式之间建立映射。XML 模式定义 XML 文档的数据元素和结构。JAXB 技术提供相应的工具，使您能够在 XML 文档与 Java 对象之间进行转换。不必理解 XML 数据结构即可访问存储在 XML 文档中的数据。

JAXB 是缺省数据绑定技术，供本产品中的“针对 XML Web Service 的 Java API”（JAX-WS）2.0 工具和实现使用。可以开发 JAXB 对象以便在 JAX-WS 应用程序中使用。也可以独立于 JAX-WS 编程模型使用 JAXB 作为便捷的方法来利用 XML 数据绑定技术，以便在 Java 应用程序中控制 XML。

JAXB 提供 xjc 模式编译器工具、schemagen 模式生成器工具以及运行时框架。xjc 模式编译器工具使您能够从 XML 模式定义（XSD）着手，创建一组 JavaBeans 以映射至 XSD 模式中定义的元素和类型。也可以从一组 JavaBeans 着手，使用 schemagen 模式生成器工具来创建 XML 模式。在使用模式编译器或模式生成器工具后，可以在 XML 文档与 Java 对象之间进行转换，并使用生成的 Java 类来组装 Web Service 应用程序。

JAXB 注释类和工件包含 JAXB 运行时 API 用于处理 XML 实例文档所需的所有信息。JAXB 运行时 API 支持将 JAXB 对象编组为 XML 文件及取消对 XML 文档的编组以使其恢复为 JAXB 类实例。JAXB 绑定包 javax.xml.bind 定义与内容类直接配合使用的抽象类和接口。此外，此包还定义 marshal 和 unmarshal API。

在缺省绑定未满足业务应用程序需求时，可根据情况使用 JAXB 绑定定制内容以通过覆盖或扩展缺省 JAXB 绑定来定制生成的 JAXB 类。在大多数情况下，缺省绑定规则足以生成一组可靠的模式派生类。JAXB 支持将定制和覆盖绑定至缺省绑定规则，这可以通过各种方法来实现。例如，可以将覆盖内联为源模式中的注释、内联为由 JAXB 绑定编译器使用的外部绑定定制文件中的声明，或者内联为由 JAXB 模式生成器使用的 Java 类文件中的 Java 注释。请参阅 JAXB 规范以了解有关绑定定制选项的信息。

借助 JAXB，可以使用下列方法控制数据对象：
过程

    * 根据 Java 类生成 XML 模式。 使用模式生成器 schemagen 命令根据 Java 类生成 XML 模式。
    * 根据 XML 模式生成 Java 类。 使用模式编译器 xjc 命令根据 XML 模式来创建一组使用 JAXB 注释的 Java 类。
    * 对 XML 文档进行编组和取消编组。 在 XML 模式与 Java 类之间存在映射后，请使用 JAXB 绑定运行时将 XML 实例文档转换为 Java 对象及将 Java 对象转换为 XML 实例文档。

结果
您现在具有 Java 应用程序可用于控制 XML 数据的 JAXB 对象。

===========================================================================================

使用 JAXB 工具根据 XML 模式文件生成 JAXB 类

使用 Java XML 绑定体系结构（JAXB）工具将 XML 模式文件编译为完全注释的 Java 类。
在您开始之前
开发或获取 XML 模式文件。
关于本任务

可以使用 JAXB API 和工具在 Java 类与 XML 模式之间建立映射。XML 模式描述 XML 文档中的数据元素和关系。在数据映射或绑定存在后，可以在 XML 文档与 Java 对象之间进行转换。现在不必理解数据结构即可访问 XML 文档中存储的数据。

通过使用 JAXB 模式编译器 xjc 命令行工具根据 XML 模式文件生成完全注释的 Java 类。生成的带注释 Java 类包含 JAXB 运行时解析 XML 以进行编组和取消编组所需的所有必需信息。可以在“针对 XML Web Service 的 Java API”（JAX-WS）应用程序或非 JAX-WS Java 应用程序中使用生成的 JAXB 类来处理 XML 数据。
过程

   1. 使用 JAXB 模式编译器 xjc 命令来生成 JAXB 注释 Java 类。 模式编译器位于 app_server_root\bin\ 目录中。模式编译器根据编译时使用的绑定选项生成一组包含 Java 源文件和 JAXB 属性文件的包。
   2. （可选）使用定制绑定声明来更改缺省 JAXB 映射。 在 XML 模式文件或单独绑定文件中定义绑定声明。可通过将 -b 选项与 xjc 命令配合使用来传递定制绑定文件。
   3. 编译生成的 JAXB 对象。 要编译生成的工件，请将 Thin Client for JAX-WS with WebSphere Application Server 添加至类路径。

结果
在生成 JAXB 对象后，可以使用生成的 JAXB 对象编写 Java 应用程序并通过生成的 JAXB 类来控制 XML 内容。
示例
以下示例说明从现有 XML 模式文件着手时 JAXB 工具如何生成 Java 类。

   1. 将以下 bookSchema.xsd 模式文件复制到临时目录。

        <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
           <xsd:element name="CatalogData">                                            
             <xsd:complexType >                                                        
               <xsd:sequence>
                 <xsd:element name="books" type="bookdata" minOccurs="0"
                              maxOccurs="unbounded"/>
               </xsd:sequence>
             </xsd:complexType>
           </xsd:element>
           <xsd:complexType name="bookdata">                                           
             <xsd:sequence>
               <xsd:element name="author" type="xsd:string"/>                          
               <xsd:element name="title" type="xsd:string"/>                           
               <xsd:element name="genre" type="xsd:string"/>                           
               <xsd:element name="price" type="xsd:float"/>                            
               <xsd:element name="publish_date" type="xsd:dateTime"/>                  
               <xsd:element name="description" type="xsd:string"/>                     
             </xsd:sequence>
             <xsd:attribute name="id" type="xsd:string"/>                              
           </xsd:complexType>
         </xsd:schema>

   2. 打开命令提示符。
   3. 从模式文件所在的目录中运行 JAXB 模式编译器 xjc 命令。xjc 模式编译器工具位于 app_server_root\bin\ 目录中。
      [Windows]

      app_server_root\bin\xjc.bat bookSchema.xsd

      [Linux] [AIX] [HP-UX] [Solaris]

      app_server_root/bin/xjc.sh bookSchema.xsd

      运行 xjc 命令将生成下列 JAXB Java 文件：

      generated\Bookdata.java
      generated\CatalogdData.java
      generated\ObjectFactory.java

   4. 在 Java 应用程序中使用生成的 JAXB 对象通过生成的 JAXB 类来控制 XML 内容。

请参阅 JAXB 2.0 参考实施文档，以了解 xjc 命令的更多信息。

=========================================================

使用 JAXB 运行时对 XML 文档进行编组和取消编组

使用 Java XML 绑定体系结构（JAXB）运行时来控制 XML 实例文档。
在您开始之前
使用 JAXB 通过模式编译器 xjc 命令根据 XML 模式生成 Java 类，也可以通过模式生成器 schemagen 命令根据 Java 类生成 XML 模式。
关于本任务

可以使用 JAXB API 和工具在 Java 类与 XML 模式之间建立映射。在数据绑定存在后，请使用 JAXB 绑定运行时 API 在 XML 实例文档与 Java 对象之间进行转换。不必理解数据结构即可访问存储在 XML 文档中的数据。JAXB 注释类和工件包含 JAXB 运行时 API 用于处理 XML 实例文档所需的所有信息。JAXB 运行时 API 支持将 JAXB 对象编组为 XML 及取消对 XML 文档的编组以使其恢复为 JAXB 类实例。
过程

    * 将 JAXB 对象编组为 XML 实例文档。

      使用 JAXB 运行时 API 将 JAXB 对象实例编组或转换为 XML 实例文档。
         1. 对 JAXB 类进行实例化。
         2. 调用 JAXB 编组器。

      本示例演示如何在应用程序中对生成的 JAXB 对象进行实例化，以及如何使用 JAXBContext 类和 JAXB 运行时编组器 API 将 JAXB 对象编组为 XML 实例。

      JAXBContext jc = JAXBContext.newInstance("myPackageName");
      //Create marshaller
      Marshaller m = jc.createMarshaller();
      //Marshal object into file.
      m.marshal(myJAXBObject, myOutputStream);

      JAXB 参考实现引入了其他特定于供应商的编组器属性，例如，名称空间前缀映射、缩进以及字符转义控制，这些属性不是由 JAXB 规范定义。使用这些属性来指定编组过程的其他控制。这些属性仅与 JAXB 参考实现配合使用，无法与其他 JAXB 提供程序配合使用。可在 Java XML 绑定体系结构 JAXB RI Vendor Extensions Runtime Properties 规范中找到有关特定于供应商的属性的更多信息。
    * 将 XML 文件取消编组为 JAXB 对象。

      使用 JAXB 运行时 API 将 XML 实例文档取消编组或转换为 JAXB 对象实例。
         1. 获取现有 XML 实例文档。
         2. 调用 JAXB 取消编组器。

      本示例演示了读取 XML 文档及将 XML 文档取消编组或转换为 JAXB 对象实例的程序。使用 JAXBContext 类和 JAXB 运行时取消编组器 API 对 XML 文档进行取消编组。

      JAXBContext jc = JAXBContext.newInstance("myPackageName");
      //Create unmarshaller
      Unmarshaller um = jc.createUnmarshaller();
      //Unmarshal XML contents of the file myDoc.xml into your Java
        object instance.
      MyJAXBObject myJAXBObject = (MyJAXBObject)
      um.unmarshal(new java.io.FileInputStream( "myDoc.xml" ));

结果
您现在可以使用 JAXB 绑定框架对 JAXB Java 类进行编组及对 XML 数据进行取消编组。请参阅 JAXB 2.0 参考实施文档，以了解有关编组和取消编组运行时 API 的更多信息。