Mit JAXB-Schemagen-Tools eine XML-Schemadatei aus einer Java-Klasse generieren

Verwenden Sie die JAXB-Schemagen-Tools (Java™ Architecture for XML Binding), um eine XML-Schemadatei aus Java-Klassen zu erstellen.

Vorbereitungen

Geben Sie die Java-Klassen oder eine Gruppe von Java-Objekten für die Zuordnung zu einer XML-Schemadatei an.

Informationen zu dieser Task

Verwenden Sie JAXB-APIs und -Tools, um Zuordnungen zwischen Java-Klassen und XML-Schema herzustellen. In XML-Schemadokumenten werden die Datenelemente und Beziehungen in einem XML-Dokument beschrieben. Wenn eine Datenzuordnung oder -bindung vorhanden ist, können Sie XML-Dokumente in Java-Objekte und umgekehrt konvertieren. Anschließend können Sie auf die in einem XML-Dokument gespeicherten Daten zugreifen, ohne die Datenstruktur verstehen zu müssen.

Wenn Sie Web-Services mit einem Bottom-up-Entwicklungsansatz aus vorhandenen JavaBeans oder Enterprise-Beans entwickeln möchten, verwenden Sie das Tool wsgen , um die Artefakte für JAX-WS-Anwendungen (Java API for XML-Based Web Services) zu generieren. Nachdem die Java-Artefakte für Ihre Anwendung generiert wurden, können Sie mit dem JAXB-Schemagenerator, dem Befehlszeilentool schemagen , ein XML-Schemadokument aus einer vorhandenen Java-Anwendung erstellen, die die Datenelemente einer Java-Anwendung darstellt. Der JAXB-Schemagenerator verarbeitet entweder Java-Quellendateien oder Klassendateien. Annotationen für Java-Klassen bieten die Möglichkeit, die Standardzuordnungen von vorhandenen Java-Klassen zu den generierten Schemakomponenten anzupassen. Die XML-Schemadatei und die annotierten Java-Klassendateien enthalten alle erforderlichen Informationen, die die JAXB-Laufzeit benötigt, um die XML-Dokumente für das Marshaling und Unmarshaling syntaktisch zu analysieren.

Sie können ein XML-Schemadokument aus einer vorhandenen Java-Anwendung erstellen, die die Datenelemente einer Java-Anwendung darstellt, indem Sie das Befehlszeilentool schemagen des JAXB-Schemagenerators verwenden. Der JAXB-Schemagenerator verarbeitet entweder Java-Quellendateien oder Klassendateien. Annotationen für Java-Klassen bieten die Möglichkeit, die Standardzuordnungen von vorhandenen Java-Klassen zu den generierten Schemakomponenten anzupassen. Die XML-Schemadatei und die annotierten Java-Klassendateien enthalten alle erforderlichen Informationen, die die JAXB-Laufzeit benötigt, um die XML-Dokumente für das Marshaling und Unmarshaling syntaktisch zu analysieren.

Unterstützte Konfigurationen: Die Befehlszeilentools wsimport, wsgen, schemagen und xjc werden auf der Plattform z/OS® nicht unterstützt. Diese Funktionalität wird von den Assembliertools bereitgestellt, die mit WebSphere® Application Server auf der z/OS -Plattform bereitgestellt werden. Weitere Informationen zur Verwendung dieser Befehlszeilentools für JAX-WS-Anwendungen finden Sie in der Dokumentation zu diesen Tools.

Best Practice: WebSphere Application Server stellt JAX-WS-Tools (Java API for XML-Based Web Services) und JAXB-Tools (Java Architecture for XML Binding) bereit. Die Befehlszeilentools wsimport, wsgen, schemagen und xjc befinden sich im Verzeichnis Stammverzeichnis_des_Anwendungsservers\bin\ in WebSphere Application Server traditional.Die Befehle xjc und schemagen befinden sich im Verzeichnis Stammverzeichnis_des_Anwendungsservers\jaxb\bin\ in Liberty Profile. In einigen Fällen unterstützen die Artefakte, die von den Tools von WebSphere Application Server und dem JDK generiert werden, dieselben Versionen der Spezifikationen. Im Allgemeinen sind die von den JDK-Tools generierten Artefakte in kompatible Laufzeitumgebungen portierbar. Es ist jedoch ein bewährtes Verfahren, die mit diesem Produkt bereitgestellten Tools zu verwenden, um eine nahtlose Integration in die WebSphere Application Server -Umgebung zu erreichen und die Features zu nutzen, die möglicherweise nur in WebSphere Application Serverunterstützt werden. Um den Vorteil der JAX-WS- und JAXB-V2.2-Tools zu nutzen, verwenden Sie die mit Application Server bereitgestellten Tools, die sich im Verzeichnis Stammverzeichnis_des_Anwendungsservers\bin\ befinden.

Unterstützte Konfigurationen Dieses Produkt unterstützt die Spezifikation JAXB 2.2 . JAX-WS 2.2 erfordert JAXB 2.2 für die Datenbindung.

JAXB vorgenommenen bietet Kompilierungsunterstützung, um Ihnen zu ermöglichen, den Schemagenerator schemagen so zu konfigurieren, dass er nicht automatisch ein neues Schema generiert. Diese Verbesserung ist nützlich, wenn Sie ein einheitliches Schema wie World Wide Web Consortium (W3C), XML Schema, Web Services Description Language (WSDL) oder WS-Addressing verwenden und kein neues Schema für ein bestimmtes referenziertes Paket generiert werden soll. Das Attribut location in der Annotation "@XmlSchema" bewirkt, dass der Generator "schemagen" auf den URI des vorhandenen Schemas verweist, anstatt ein neues Schema zu generieren.

Sie können das JAXB-Tool schemagen nicht nur über die Befehlszeile aufrufen, sondern auch in Ant-Build-Umgebungen. Verwenden Sie die Ant-Task com.sun.tools.jxc.SchemaGenTask in der Ant-Build-Umgebung, um das Schemageneratortool schemagen aufzurufen. Damit diese Ant-Task richtig ausgeführt wird, müssen Sie Ant mit dem Script "ws_ant" aufrufen.

Vermeiden Sie Probleme: Wenn das Tool schemagen ausgeführt wird, liest der Schema-Generator die @XmlSchema -Annotationen aus der Package-Info-Klassendatei nicht korrekt, um targetNamespaces abzuleiten. Verwenden Sie an Stelle der Annotation "@XMLSchema" eine der folgenden Methoden:

Stellen Sie eine Datei "package-info.java" mit der Annotation "@XmlSchema" bereit, z. B.:
```
schemagen sample.Address sample\package-info.java
```
Verwenden Sie das Attribut "namespace" der Annotation "@XmlType" an, um einen Namespace anzugeben, z. B.:
```
@XmlType(namespace="http://myNameSpace")
```

Vorgehensweise

Suchen Sie die Java-Quellendateien oder Java-Klassendateien, die beim Generieren einer XML-Schemadatei verwendet werden sollen.
Stellen Sie sicher, dass alle Klassen, auf die von Ihren Java-Klassendateien verwiesen wird, im Klassenpfad enthalten sind oder mit den Optionen für-classpath/-cp für das Tool bereitgestellt werden.
Verwenden Sie den JAXB-Schemagenerator schemagen , um ein XML-Schema zu generieren.
Der Schemagenerator befindet sich im Verzeichnis Stammverzeichnis_des_Anwendungsservers\bin\.
```
app_server_root\bin\schemagen.bat myObj1.java myObj2.java
```
```
app_server_root/bin/schemagen.sh myObj1.java myObj2.java
```
```
app_server_root/bin/schemagen myObj1.java myObj2.java
```
Die Parameter myObj1.java und myObj2.javasind die Namen der Java-Dateien, die die Datenobjekte enthalten. Wenn myObj1.java oder myObj2.java auf Java-Klassen verweisen, die nicht an den schemagen -Befehl übergeben werden, müssen Sie die Option -cp verwenden, um die Klassenpfadposition für diese Java-Klassen anzugeben.
Lesen Sie die Dokumentation zum Befehl schemagen, um mehr über diesen Befehl und die zusätzlichen Parameter zu erfahren, die Sie angeben können.
(Optional) Verwenden Sie JAXB-Programmannotationen, die im Paket javax.xml.bind.annotations definiert sind, um die JAXB-XML-Schemazuordnungen anzupassen.

(Optional) Konfigurieren Sie die Eigenschaft location in der Anmerkung @XmlSchema, um dem Schema-Compiler mitzuteilen, dass er ein vorhandenes Schema verwenden soll, anstatt ein neues zu erstellen.

Beispiel:

@XmlSchema(namespace="foo")
package foo;
@XmlType
class Foo {
@XmlElement Bar zot;
}
@XmlSchema(namespace="bar",
location="http://example.org/test.xsd")
package bar;
@XmlType
class Bar {
...
}
<xs:schema targetNamespace="foo">
<xs:import namespace="bar"
schemaLocation="http://example.org/test.xsd"/>
<xs:complexType name="foo">
<xs:sequence>
<xs:element name="zot" type="bar:Bar" xmlns:bar="bar"/>
</xs:sequence>
</xs:complex

location="http://example.org/test.xsd" gibt die Position des vorhandenen Schema für das Tool schemagen an. Es wird kein neues Schema generiert.

Ergebnisse

Nachdem Sie nun eine XML-Schemadatei aus Java-Klassen generiert haben, können Sie das Marshaling und Unmarshaling der Java-Objekte als XML-Instanzdokumente ausführen.

Vermeiden Sie Probleme: Der Befehl 'schemagen' unterscheidet den XML-Namensbereich nicht zwischen mehreren @XMLType -Annotationen, für die derselbe @XMLType -Name in verschiedenen Java-Paketen definiert ist. Tritt dieser Fall ein, wird die folgende Fehlernachricht angezeigt:

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

Dieser Fehler gibt an, dass Sie Klassennamen oder @XMLType.name -Werte haben, die denselben Namen haben, aber in verschiedenen Java-Paketen vorhanden sind. Fügen Sie zur Vermeidung dieses Fehlers die Klasse "@XML.Type.namespace" zur vorhandenen Annotation "@XMLType" hinzu, um die Unterscheidung zwischen den XML-Typen zu ermöglichen.

Beispiel

Das folgende Beispiel veranschaulicht, wie JAXB-Tools eine XML-Schemadatei aus einer vorhandenen Java-Klasse namens Bookdata.javagenerieren können.

Kopieren Sie die folgende Datei Bookdata.java in ein temporäres Verzeichnis.

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;
    }

}

Öffnen Sie eine Eingabeaufforderung.

Führen Sie das Schemageneratortool "schemagen" in dem Verzeichnis aus, in das Sie die Datei Bookdata.java kopiert haben.

app_server_root\bin\schemagen.bat Bookdata.java

app_server_root/bin/schemagen.sh Bookdata.java

app_server_root/bin/schemagen Bookdata.java

Die XML-Schemadatei schema1.xsd wird generiert:

<?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>

Weitere Informationen zum Befehl schemagen finden Sie in der Dokumentation zu einer Referenzimplementierung von JAXB.