Verwenden des JAXB-Schemagen-Tools zum Generieren einer XML-Schemadatei aus einer Java-Klasse

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

Vorbereitungen

Identifizieren Sie die Java-Klassen oder eine Gruppe von Java-Objekten, die einer XML-Schemadatei zugeordnet werden sollen.

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.

Entwicklung von Webdiensten mit einem Bottom-Up-Entwicklungsansatz ausgehend von bestehenden JavaBeans oder Enterprise Beans, verwenden Sie diewsgen Tool zum Generieren der Artefakte für Java API für XML-basierte Web Services (JAX-WS)-Anwendungen. Nachdem die Java-Artefakte für Ihre Anwendung generiert wurden, können Sie mithilfe des JAXB-Schemagenerators ein XML-Schemadokument aus einer vorhandenen Java-Anwendung erstellen, das die Datenelemente einer Java-Anwendung darstellt.schemagen Befehlszeilentool. Der JAXB-Schemagenerator verarbeitet entweder Java-Quelldateien oder Klassendateien. Java-Klassenanmerkungen bieten die Möglichkeit, die Standardzuordnungen von vorhandenen Java-Klassen zu den generierten Schemakomponenten anzupassen. Die XML-Schemadatei enthält zusammen mit den kommentierten Java-Klassendateien alle notwendigen Informationen, die die JAXB-Laufzeitumgebung zum Parsen der XML-Dokumente zum Marshallen und Unmarshalling benötigt.

Sie können aus einer vorhandenen Java-Anwendung ein XML-Schemadokument erstellen, das die Datenelemente einer Java-Anwendung darstellt. Dazu verwenden Sie den JAXB-Schemagenerator.schemagen Befehlszeilentool. Der JAXB-Schemagenerator verarbeitet entweder Java-Quelldateien oder Klassendateien. Java-Klassenanmerkungen bieten die Möglichkeit, die Standardzuordnungen von vorhandenen Java-Klassen zu den generierten Schemakomponenten anzupassen. Die XML-Schemadatei enthält zusammen mit den kommentierten Java-Klassendateien alle notwendigen Informationen, die die JAXB-Laufzeitumgebung zum Parsen der XML-Dokumente zum Marshallen und Unmarshalling benötigt.

Unterstützte Konfigurationen: Derwsimport ,wsgen ,schemagen Undxjc Befehlszeilentools werden nicht unterstützt auf dem z/OS® Plattform. Diese Funktionalität wird durch die Montagewerkzeuge bereitgestellt, die mitgeliefert werden WebSphere® Application Server läuft auf dem z/OS Plattform. Weitere Informationen zur Verwendung dieser Befehlszeilentools für JAX-WS-Anwendungen finden Sie in der Dokumentation zu diesen Tools.

Beste Übung:WebSphere Application Server bietet Java API für XML-basierte Webdienste (JAX-WS) und Java Architecture for XML Binding (JAXB)-Tools. Die Befehlszeilentools wsimport, wsgen, schemagen und xjc befinden sich im Verzeichnis "Stammverzeichnis_des_Anwendungsservers\bin\" des vollständigen Profils. Die Befehle wsimport und wsgen befinden sich im Verzeichnis Stammverzeichnis_des_Anwendungsservers\jaxws\bin\ im Liberty-Profil. Derxjc Undschemagen Befehle befinden sich im Stammverzeichnis_des_Anwendungsservers\jaxb\bin\-Verzeichnis im Liberty-Profil. Ähnliche Tools werden vom Java SE Development Kit (JDK) 6 bereitgestellt. In einigen Fällen werden die Artefakte, die sowohl durch die Werkzeuge von WebSphere Application Server und das JDK unterstützen dieselben Spezifikationsebenen. Im Allgemeinen sind die von den JDK-Tools generierten Artefakte in kompatible Laufzeitumgebungen portierbar. Es empfiehlt sich jedoch, die mit diesem Produkt bereitgestellten Tools zu verwenden, um eine nahtlose Integration in das WebSphere Application Server Umgebung und um die Vorteile der Funktionen zu nutzen, die möglicherweise nur unterstützt werden in WebSphere Application Server. 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 JAXB 2.2 Spezifikation. 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.

Vermeide Ärger: Beim Ausführen desschemagen Tool, der Schemagenerator liest die @XmlSchema Annotationen aus der Klassendatei package-info zum Ableiten targetNamespaces. 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-Quelldateien oder Java-Klassendateien, die zum Generieren einer XML-Schemadatei verwendet werden sollen.
Stellen Sie sicher, dass alle Klassen, auf die Ihre Java-Klassendateien verweisen, im Klassenpfad enthalten sind oder dem Tool über den-classpath/-cp Optionen.
Verwenden Sie den JAXB-Schemagenerator.schemagen Befehl zum Generieren eines XML-Schemas.
Der Schemagenerator befindet sich im Stammverzeichnis_des_Anwendungsservers\bin\-Verzeichnis.
```
app_server_root\bin\schemagen.bat myObj1.java myObj2.java
```
```
app_server_root/bin/schemagen.sh myObj1.java myObj2.java
```
Die Parameter,myObj1.java UndmyObj2.java , sind die Namen der Java-Dateien, die die Datenobjekte enthalten. WennmyObj1.java odermyObj2.java beziehen sich auf Java-Klassen, die nicht an dieschemagen müssen Sie den Befehl-cp Option zum Angeben des Klassenpfadspeicherorts für diese Java-Klassen.
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 in derjavax.xml.bind.annotations Paket zum Anpassen der JAXB-XML-Schemazuordnungen.

(Optional) Konfigurieren Sie dielocation Eigentum auf der @XmlSchema Annotation, um dem Schemacompiler mitzuteilen, dass ein vorhandenes Schema verwendet werden soll, anstatt ein neues zu generieren.

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 mit dem Marshallen und Desmarshalieren der Java-Objekte als XML-Instanzdokumente beginnen.

Vermeide Ärger: Der Befehl schemagen unterscheidet nicht zwischen dem XML-Namespace mehrerer @XMLType-Annotationen, die den gleichen @XMLType-Namen haben, der 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 zeigt an, dass Sie Klassennamen oder @ habenXMLType.name Werte, die denselben Namen haben, aber in unterschiedlichen 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 zeigt, wie JAXB-Tools eine XML-Schemadatei aus einer vorhandenen Java-Klasse generieren können. Bookdata.java.

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

Die XML-Schemadatei schema1.xsd wird generiert:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<xs:schema version="1.0" xmlns:xs="https://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.