Utilisation d'outils schemagen JAXB pour générer un fichier schéma XML à partir d'une classe Java

Utilisez les outils schemagen JAXB (Java™ Architecture for XML Binding) pour générer un fichier schéma XML à partir de classes Java.

Avant de commencer

Identifiez les classes Java ou un ensemble d'objets Java pour mapper vesr un fichier schéma XML.

Pourquoi et quand exécuter cette tâche

Les API et les outils JAXB permettent d'établir des mappages entre des classes Java et un schéma XML. Les documents de schéma XML décrivent les éléments de données et les relations dans un document XML. Lorsqu'un mappage de données ou une liaison existe, vous pouvez convertir des documents XML en objets Java ou à partir d'objets Java. Vous pouvez maintenant traiter les données stockées dans un document XML sans qu'il soit nécessaire de comprendre la structure des données.

Pour développer des services web à l'aide d'une approche ascendante à partir de JavaBeans ou de beans enterprise existants, utilisez l'outil wsgen afin de générer les artefacts pour les applications JAX-WS (Java API for XML-Based Web Services). Une fois que les artefacts Java pour votre application sont générés, vous pouvez créer un schéma XML à partir d'une application Java existante qui représente les éléments de données d'une application Java à l'aide du générateur de schéma JAXB, de l'outil de ligne de commande schemagen. Le générateur de schéma JAXB est capable de traiter soit des fichiers source Java, soit des fichiers classe. Les annotations de classe Java permettent de personnaliser les mappages par défaut des classes Java existantes vers les composants de schéma générés. Le fichier schéma XML lié avec les fichiers annotés de classe Java contient les informations nécessaires. JAXB runtime en a besoin pour analyser les documents XML pour la conversion et la déconversion de paramètres.

Vous pouvez créer un schéma XML à partir d'une application Java existante qui représente les éléments de données d'une application Java à l'aide du générateur de schéma JAXB, de l'outil de ligne de commande schemagen. Le générateur de schéma JAXB est capable de traiter soit des fichiers source Java, soit des fichiers classe. Les annotations de classe Java permettent de personnaliser les mappages par défaut des classes Java existantes vers les composants de schéma générés. Le fichier schéma XML lié avec les fichiers annotés de classe Java contient les informations nécessaires. JAXB runtime en a besoin pour analyser les documents XML pour la conversion et la déconversion de paramètres.

Configurations prises en charge Configurations prises en charge: Les outils de ligne de commande wsimport, wsgen, schemagen et xjc ne sont pas pris en charge sur la plateforme z/OS. Leur fonctionnalité est assurée par les outils d'assemblage fournis avec WebSphere Application Server s'exécutant sur la plateforme z/OS. Pour plus d'informations sur ces outils de ligne de commande, reportez-vous aux outils de ligne de commande pour les applications JAX-WS.sptcfg
Pratiques recommandées Pratiques recommandées: WebSphere Application Server fournit des outils JAX-WS (Java API for XML-Based Web Services) et JAXB (Java Architecture for XML Binding). Les outils de ligne de commande wsimport, wsgen, schemagen et xjc se trouvent dans le répertoire app_server_root\bin\ de WebSphere Application Server Traditional.Les commandes xjc et schemagen se trouvent dans le répertoire app_server_root\jaxb\bin\ du profil Liberty. Il peut arriver que les artefacts générés par les outils fournis par WebSphere Application Server et le kit de développement Java SE prennent en charge les mêmes niveaux de spécifications. En général, les artefacts générés par les outils JDK sont compatibles avec d'autres environnements d'exécution conformes. Toutefois, il est recommandé d'utiliser les outils fournis avec ce produit pour effectuer une intégration transparente au sein de l'environnement WebSphere Application Server et pour bénéficier des fonctions qui peuvent être prises en charge uniquement dans WebSphere Application Server. Pour profiter des outils JAX-WS et JAXB V2.2, utilisez les outils fournis avec le serveur d'applications qui se trouvent dans le répertoire racine_serveur_app\bin\.bprac
Configurations prises en charge Configurations prises en charge: Le produit prend en charge la spécification JAXB 2.2. JAX-WS 2.2 requiert JAXB 2.2 pour la liaison des données. sptcfg

JAXB prend en charge la compilation et vous permet de configurer le générateur de schémas schemagen pour qu'il ne génère pas automatiquement un nouveau schéma. Ceci est utile si vous utilisez un schéma commun, tel que W3C (World Wide Web Consortium), un schéma XML, WSDL (Web Services Description Language) ou WS-Addressing, et que vous ne souhaitez pas qu'un nouveau schéma soit généré pour un package spécifique référencé. L'attribut location de l'annotation @XmlSchema incite le générateur schemagen à faire référence à l'URI du schéma existant plutôt qu'à en générer un nouveau.

Outre l'utilisation de l'outil schemagen à partir de la ligne de commande, vous pouvez appeler cet outil JAXB à partir des environnements de génération Ant. Utilisez la tâche Ant com.sun.tools.jxc.SchemaGenTask à partir de l'environnement de génération Ant pour appeler l'outil de génération de schéma schemagen. Pour fonctionner correctement, la tâche Ant doit être appelée par le script ws_ant.

Eviter les incidents Eviter les incidents: Lors de l'exécution de l'outil schemagen, le générateur de schéma ne lit pas correctement les annotations @XmlSchema dans le fichier classe package-info pour dériver targetNamespaces. Plutôt que d'utiliser l'annotation @XMLSchema, utilisez l'une des méthodes suivantes :
  • Fournissez un fichier package-info.java avec @XmlSchema, par exemple :
    schemagen sample.Address sample\package-info.java
  • Utilisez l'attribut d'espace de nom d'annotation @XmlType pour indiquer un nom d'espace, par exemple :
    @XmlType(namespace="http://myNameSpace")
gotcha

Procédure

  1. Localisez les fichiers source Java ou les fichiers classe Java à utiliser pour la génération d'un fichier schéma XML. Assurez-vous que toutes les classes référencées par vos fichiers classe Java figurent dans le chemin d'accès aux classes ou sont fournies à l'outil via les options -classpath/-cp.
  2. Utilisez le générateur de schéma JAXB ou la commande schemagen pour générer un schéma XML. Le générateur de schéma est situé dans le répertoire app_server_root\bin\.
    [Windows]
    racine_serveur_app\bin\schemagen.bat myObj1.java myObj2.java
    [AIX][HP-UX][Linux][Solaris]
    racine_serveur_app/bin/schemagen.sh myObj1.java myObj2.java
    [IBM i]
    racine_serveur_app/bin/schemagen myObj1.java myObj2.java

    Les paramètres myObj1.java et myObj2.java sont les noms des fichiers Java contenant les objets de données. Si myObj1.java et myObj2.java font référence à des classes Java qui ne sont pas transmises à la commande schemagen, vous devez utiliser l'option -cp pour fournir l'emplacement du chemin d'accès aux classes pour ces classes Java.

    Pour plus d'informations sur la commande et les options supplémentaires qui peuvent être spécifiées, voir la rubrique relative à la commande schemagen.
  3. (Facultatif) Utilisez les annotations de programmation JAXB définies dans le package javax.xml.bind.annotations pour personnaliser les mappages de schéma XML JAXB.
  4. (Facultatif) Configurez la propriété location sur l'annotation @XmlSchema pour indiquer au compilateur de schémas qu'il doit utiliser un schéma existant au lieu d'en générer un nouveau. Par exemple,
    @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
    Le code location="http://example.org/test.xsd" indique l'emplacement du schéma existant à l'outil schemagen et donc aucun nouveau schéma n'est généré.

Résultats

Maintenant que vous avez généré un fichier schéma XML à partir de classes Java, vous êtes prêt à convertir et à déconvertir des objets Java en tant que documents d'instance XML.

Eviter les incidents Eviter les incidents: La commande schemagen ne distingue pas l'espace de nom XML parmi plusieurs annotations @XMLType ayant le même nom @XMLType défini dans des packages Java différents. Dans ce cas, l'erreur suivante s'affiche :
Error: Two classes have the same XML type name .... (Erreur : deux classes ont le même nom de type XML)
Elle vous indique également d'utiliser @XmlType.name et @XmlType.namespace pour leur attribuer des noms différents.
Cette erreur signale que des noms de classes ou des valeurs @XMLType.name sont identiques mais se trouvent dans différents packages Java. Pour éviter cette erreur, ajoutez la classe espace de nom @XML.Type. à l'annotation @XMLType afin de faire la différence entre les types XML.gotcha

Exemple

L'exemple suivant illustre comment l'outil JAXB peut générer un fichier schéma XML à partir d'une classe Java existante, Bookdata.java.
  1. Copiez le fichier Bookdata.java suivant dans un répertoire temporaire.
    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. Ouvrez une invite de commande.
  3. Exécutez l'outil de générateur de schéma schemagen dans le répertoire dans lequel vous avez copié le fichier Bookdata.java.
    [Windows]
    racine_serveur_app\bin\schemagen.bat Bookdata.java
    [Linux][AIX][HP-UX][Solaris]
    racine_serveur_app/bin/schemagen.sh Bookdata.java 
    [IBM i]
    racine_serveur_app/bin/schemagen Bookdata.java
  4. Le fichier schéma XML, schema1.xsd est généré :
    <?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>

Voir la documentation de référence sur implémentation JAXB pour toute information supplémentaire concernant la commande schemagen.


Icône indiquant le type de rubrique Rubrique de tâche



Icône d'horodatage Dernière mise à jour: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=twbs_jaxbjava2schema
Nom du fichier : twbs_jaxbjava2schema.html