EPITA
XML et les services Web

Jean-François Perrot

XML-Schémas

  1. I. Validation d'un document XML.

  2. II. Les XML-Schémas (XMLS) : première étape
    1. Principe
    2. Types simples, types complexes
      1. Les types simples
      2. Les types complexes (notions de base)
    3. Premier exemple : les noms & notes
      1. Représentation par éléments-enfants
      2. Représentation par attributs
      3. Synthèse

  3. III. Les XML-Schémas (XMLS) : deuxième étape
    1. Plus sur le principe de XMLS : des références plutôt que des types
    2. Plus sur les types simples
      1. Le mécanisme des restrictions
      2. Autres constructions
    3. Les unions
    4. Les listes
    5. Plus sur les types complexes
      1. Les groupes d'éléments
      2. Les groupes d'attributs
      3. Second exemple : un schéma pour les expressions arithmétiques
    6. Modifications de types déjà définis
      1. Des types simples aux types complexes par simpleContent
      2. Les modifications par complexContent

  4. IV. Schémas et instances de schémas
    1. Instances : au niveau document
    2. Validation
    3. Instances : an niveau élément
    4. L'attribut nillable
    5. Espaces de noms
      1. Principe
      2. Premier exemple avec le type Voiture unique:
      3. Deuxième exemple avec des types dérivés :
      4. Conclusion
    6. Inclusion, importation

I. Validation d'un document XML.

Voir le cours n°1 pour le côté DTD. Nous traitons ici des schémas.

II. Les XML-Schémas (XMLS) : première étape

  1. Principe

    Le principe des XMLS est d'élaborer un système de types (au sens informatique du terme)
    et d'associer des types aux différents éléments qui apparaissent dans le document XML visé.
    XMLS entre donc dans la perspective générale du contrôle de types plutôt que dans celui
    des descriptions grammaticales comme les DTDs ou RELAX-NG.

    C'est à ce titre qu'il est employé dans les services Web, où se pose la question d'un contrôle de types
    indépendant des langages dans lequel sont implémentés le client et le serveur.

    Ce système de types a la particularité de s'écrire lui-même en XML (d'où une inévitable lourdeur d'écriture).
    Il utilise comme espace de noms
    xmlns:xsd="http://www.w3.org/2001/XMLSchema"

  2. Types simples, types complexes

    Avant de prendre un premier exemple, il faut introduire la distinction primaire
    entre types simples (xsd:simpleType) et types complexes (xsd:complexType).
  3. Premier exemple : les noms & notes

    Nous en savons assez pour aborder notre premier exemple, à savoir la spécification de
    nos fichiers de noms & de notes.

III. Les XML-Schémas (XMLS) : deuxième étape

  1. Plus sur le principe de XMLS : des références plutôt que des types


    Nous avons vu ci-dessus deux manières de procéder pour décrire un élément XML,
    qui sont :
    1. En déclarant son nom et en définissant son type immédiatement sous le nom,
      dans le même élément déclarant <xsd:element ... >

      La méthode de la poupée russe est basée sur ce procédé, qui a un inconvénient grave :
      si des éléments de même espèce (nom & type) apparaissent dans des contextes différents,
      il faudra répéter leur description dans chaque contexte.

    2. En définissant le type sans référence à un élément particulier,
      par un élément déclarant <xsd:simpleType> ou <xsd:complexType>
      et en établissant ensuite une association entre le nom et le type,
      par un second élément déclarant <xsd:element name="leNom" type="leType" />.

    Cette fois, on ne risque plus de devoir redéfinir le type d'un élément,
    en revanche cette approche oblige à donner des noms aux types, en plus des noms des éléments.
    S'il se trouve que le type est caractéristique de l'élément,
    c'est-à-dire que deux élements de même type ont aussi le même nom,
    ceci conduit à dédoubler le vocabulaire sans valeur ajoutée.

    On observe la chose dans notre premier exemple,
    avec la triple distinction entre l'élément liste et le type listEleves,
    entre l'élément eleve et le type typEleve,
    et entre l'élément ou l'attribut note et le type noteSur20.

    Certes, sur le plan de la logique, cette distinction est fondamentale :
    un objet et son type ne sont pas du tout la même chose !
    Mais ne pourrait-on pas simplement parler du type de l'élément eleve (par exemple)
    sans devoir lui inventer un nom propre ?

    Il existe effectivement une troisième manière de faire :
    une fois un élément défini (par la démarche a. ou par la démarche b.),
    on signale son apparition dans un contexte donné nom plus par une association nom-type
    mais par une référence, de la forme
    <xsd:element ref="leNomdelElement"/>.
    Cette démarche est également applicable aux attributs :
    <xsd:attribute ref="leNomdelAttribut"/>.

    Ceci permet une écriture plus légère mais tout aussi précise.
    Voici notre exemple  Nom_note2-2.xsd reformulé avec cette syntaxe
    [fichier Nom_note2-4.xsd] :

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

    <!-- Méthode avec refs -->

    <xsd:element name="liste">
        <xsd:complexType>
            <xsd:choice>
                <xsd:element ref="eleve"
                    minOccurs="0" maxOccurs="unbounded"/>
            </xsd:choice>
        </xsd:complexType>
    </xsd:element>

    <xsd:element name="eleve">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element name="nom" type="xsd:string"/>
                <xsd:element name="note" type="noteSur20"/>
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>

    <xsd:simpleType name="noteSur20">
        <xsd:restriction base="xsd:integer">
            <xsd:minInclusive value="0"/>
            <xsd:maxInclusive value="20"/>
        </xsd:restriction>
    </xsd:simpleType>

    </xsd:schema>


    Le texte du schéma n'est pas plus court, mais on a économisé l'effort d'abstraction des deux types complexes.
    Il n'est plus question que des éléments "concrets" liste et eleve.
    Et le contenu informatif est exactement le même.

    Autre illustration de cette démarche, appliquée aux attributs,
    extraite du schéma Voiture-3-0.xsd.

    <xsd:element name="Transmission" type="typTrans"/>

    <xsd:complexType name="typtrans" >
        <xsd:sequence>
            <xsd:element name="Boîte" />
            <xsd:element name="TrainAV"/>
            <xsd:element name="TrainAR"/>
        </xsd:sequence>
        <xsd:attribute ref="nb_vitesses"/>
        <xsd:attribute ref="type"/>
    </xsd:complexType>

    <xsd:attribute name="nb_vitesses">
        <xsd:annotation>
            <xsd:documentation>En comptant la marche arrière</xsd:documentation>
        </xsd:annotation>
        <xsd:simpleType>
            <xsd:restriction base="xsd:int">
                <xsd:minInclusive value="4"/>
                <xsd:maxInclusive value="6"/>
            </xsd:restriction>
        </xsd:simpleType>
    </xsd:attribute>

    <xsd:attribute name="type">
        <xsd:simpleType>
            <xsd:restriction base="xsd:string">
                <xsd:enumeration value="automatique"/>
                <xsd:enumeration value="manuelle"/>
            </xsd:restriction>
        </xsd:simpleType>
    </xsd:attribute>

  2. Plus sur les types simples

    Les types simples de XMLS, connus également sous le nom de Datatypes, constituent une norme qui est utilisée
    même en-dehors des spécifications XMLS - par exemple, par RELAX NG.

  3. Plus sur les types complexes

  4. Modifications de types déjà définis

IV. Schémas et instances de schémas

  1. Instances : au niveau document

    Étant donné un document XML censé se conformer à un certain schéma,
    il est souhaitable de marquer le lien entre le document et son schéma.

    Les attributs qui permettent d'établir ces relations appartiennent à un espace de noms différent
    de celui des schémas, souvent associé au préfixe xsi (par opposition à xsd employé pour le vocabulaire des schémas).
    L'URL qui désigne cet espace de noms est  http://www.w3.org/2001/XMLSchema-instance.
    C'est cet espace de noms qu'on verra apparaître en SOAP rpc/encoded avec l'emploi de xsi:type="xsd:string".

    Le lien entre document et schéma s'établit de deux manières différentes selon que le document
    relève d'un namespace ou non. Supposons que le schéma soit logé dans un fichier appelé schema.xsd.
    Ici, le nom du fichier est en fait le chemin d'accès à ce fichier (au sens de Unix) sur le sysème local.
    On peut également le donner par une URL, qui le rendra accessible via HTTP.

    Sur cette affaire de "namespace" / "noNamespace", lire les bonnes explications d'Eric van der Vlist.
  2. Validation

    Pour valider un document XML par rapport au schéma qu'il déclare vouloir suivre, il faut d'abord extraire
    l'URL du schéma de l'en-tête du document, ce qui se fait aisément en DOM :

    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    dbf.setNamespaceAware(true);  // Indispensable ! Voyez le Bréviaire DOM
    /* Si on ne traite pas correctement le namespace, l'attribut  "xsi:noNamespaceSchemaLocation"
       est pris comme un attribut ordinaire, et comme il n'est pas prévu par le schéma, on a l'erreur :
       cvc-complex-type.3.2.2: Attribute 'xsi:noNamespaceSchemaLocation' is not allowed to appear in element 'garage'.
    */
    Document doc =    dbf.newDocumentBuilder().parse(fichXML);
    Element rac = doc.getDocumentElement();

    String fichSchema = "";
    if( rac.hasAttributeNS("http://www.w3.org/2001/XMLSchema-instance",
                           "noNamespaceSchemaLocation") ){
       
    fichSchema = rac.getAttributeNS("http://www.w3.org/2001/XMLSchema-instance",
                           "noNamespaceSchemaLocation"); 
    }else{
       String acc = rac.getAttributeNS("http://www.w3.org/2001/XMLSchema-instance",
                           "schemaLocation");
       String[] tacc = acc.split(" ");
       
    fichSchema = tacc[1];
    }

    et il ne reste plus qu'à modifier le programme précédent  sur l'accès au document, qu'il est inutile d'analyser une seconde fois :
    validator.validate(new DOMSource(doc) );


    Programme complet : MyValid.java

    Exemple :

    fichier garage.xml

    <?xml version="1.0" encoding="utf-8" ?>
    <garage xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:noNamespaceSchemaLocation="/Users/jfp/Sites/EPITA/XML09/Cours3/XMLS/VoituresS/garage.xsd" >

    <Voiture marque="Renault" modèle="Safrane">
      <Carosserie couleur="rouge">
        <Capot>Un peu cabossé</Capot>
      </Carosserie>
      <Moteur>
        <Cylindres></Cylindres>
        <Allumage>Défectueux</Allumage>
      </Moteur>
      <Transmission type="automatique" nb_vitesses="6">
        <Boîte/>
        <TrainAV/>
        <TrainAR/>
      </Transmission>
    </Voiture>

    <Voiture marque="Citroën" modèle="CX">
      <Carosserie couleur="vert">
        <Capot>impeccable</Capot>
      </Carosserie>
      <Moteur>
        <Cylindres></Cylindres>
        <Allumage>OK</Allumage>
      </Moteur>
      <Transmission type="automatique" nb_vitesses="6">
        <Boîte/>
        <TrainAV/>
        <TrainAR/>
      </Transmission>
    </Voiture>

    <Voiture marque="Fiat" modèle="Panda">
      <Carosserie couleur="gris">
        <Capot>Endommagé</Capot>
      </Carosserie>
      <Moteur>
        <Cylindres></Cylindres>
        <Allumage>Correct</Allumage>
      </Moteur>
      <Transmission type="manuel" nb_vitesses="5">
        <Boîte/>
        <TrainAV/>
        <TrainAR/>
      </Transmission>
    </Voiture>

    </garage>


    fichier garage.xsd

    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    <xsd:include schemaLocation="Voiture-3-0.xsd"/>

    <xsd:element name="garage">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element name="Voiture" type="typVoiture" minOccurs="0" maxOccurs="unbounded" />
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>
       
    </xsd:schema>



    jfp% java MyValid VoituresX/garage.xml
    Le fichier VoituresX/garage.xml est valide par rapport au schema /Users/jfp/Sites/EPITA/XML09/Cours3/XMLS/VoituresS/garage.xsd
    jfp%


  3. Instances : an niveau élément

    À un niveau individuel, il peut aussi être intéressant de pouvoir déclarer qu'un élément donné a un type dérivé
    du type annoncé par son nom : par exemple, typVoitureExt ou typVoitureB.
    Ce lien entre un élément du document et un type décrit dans le schéma,
    s'établit par l'attribut xsi:type (à ne pas confondre avec xsd:type).
    Voici un exemple d'utilisation de cet attribut.

    [fichier Voiture-3b.xml]

    <?xml version="1.0"?>

    <liste
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="/Users/jfp/Sites/EPITA/XML09/Cours3/XMLS/VoituresS/Voiture-3-2.xsd">

    <Voiture marque="Renault" modèle="Safrane">
        <Carosserie couleur="rouge">
            <Capot>Un peu cabossé</Capot>
        </Carosserie>
        <Moteur>
            <Cylindres></Cylindres>
            <Allumage>Défectueux</Allumage>
        </Moteur>
        <Transmission type="automatique" nb_vitesses="5">
            <Boîte/>
            <TrainAV/>
            <TrainAR/>
        </Transmission>
    </Voiture>

    <Voiture marque="Renault" modèle="VelSatis" nbPortes="5" xsi:type="typVoitureExt">
        <Carosserie couleur="noire">
            <Capot>Impeccable</Capot>
        </Carosserie>
        <Moteur>
            <Cylindres/>
            <Allumage>OK</Allumage>
        </Moteur>
        <Transmission type="automatique" nb_vitesses="6">
            <Boîte/>
            <TrainAV/>
            <TrainAR/>
        </Transmission>
        <Genre>berline</Genre>
    </Voiture>

    <Voiture marque="Renault" modèle="Twingo" xsi:type="typVoitureB">
        <Carosserie couleur="verte">
            <Capot>repeint</Capot>
        </Carosserie>
        <Moteur>
            <Cylindres/>
            <Allumage>Hésitant</Allumage>
        </Moteur>
        <Transmission type="manuelle" nb_vitesses="4">
            <Boîte/>
            <TrainAV/>
            <TrainAR/>
        </Transmission>
    </Voiture>

    </liste>


    [fichier Voiture-3-2.xsd]

    <?xml version="1.0" encoding="utf-8"?>
    <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

    <xsd:include schemaLocation="Voiture-3-0.xsd" />

    <xsd:element name="liste">
    <xsd:complexType>
    <xsd:sequence>
    <xsd:element name="Voiture" type="typVoiture"
    minOccurs="0" maxOccurs="unbounded"/>
    </xsd:sequence>
    </xsd:complexType>
    </xsd:element>

    <xsd:complexType name="typTransB">
    <xsd:complexContent>
    <xsd:restriction base="typTrans">
    <xsd:sequence>
    <xsd:element name="Boîte" />
    <xsd:element name="TrainAV"/>
    <xsd:element name="TrainAR"/>
    </xsd:sequence>
    <xsd:attribute ref="type" fixed="manuelle"/>
    <xsd:attribute ref="nb_vitesses" fixed="4"/>
    </xsd:restriction>
    </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name ="typVoitureB">
    <xsd:complexContent>
    <xsd:restriction base="typVoiture">
    <xsd:sequence>
    <xsd:element ref="Carosserie" />
    <xsd:element ref="Moteur" />
    <xsd:element name="Transmission" type="typTransB" />
    </xsd:sequence>
    <xsd:attribute name="marque" type="xsd:string"/>
    <xsd:attribute name="modèle" type="xsd:string"/>
    </xsd:restriction>
    </xsd:complexContent>
    </xsd:complexType>

    <xsd:complexType name="typVoitureExt">
    <xsd:complexContent>
    <xsd:extension base="typVoiture">
    <xsd:sequence>
    <xsd:element ref="Genre"/>
    </xsd:sequence>
    <xsd:attribute name="nbPortes" type="xsd:integer"/>
    </xsd:extension>
    </xsd:complexContent>
    </xsd:complexType>

    <xsd:element name="Genre">
    <xsd:simpleType>
    <xsd:restriction base="xsd:string">
    <xsd:enumeration value="berline"/>
    <xsd:enumeration value="coupé"/>
    <xsd:enumeration value="cabriolet"/>
    </xsd:restriction>
    </xsd:simpleType>
    </xsd:element>

    </xsd:schema>

    jfp% java MyValid VoituresS/Voiture-3b.xml
    Le fichier VoituresS/Voiture-3b.xml est valide par rapport au schema /Users/jfp/Sites/EPITA/XML09/Cours3/XMLS/VoituresS/Voiture-3-2.xsd
    jfp%


  4. L'attribut nillable

    C'est un attribut qui apparaît dans les schémas, il relève de l'espace de noms xsd.
    Plus précisément, l'attribut xsd:nillable est un attribut possible, à valeur booléenne, d'une déclaration de xsd:element.
    S'il n'apparaît pas, sa valeur par défaut est "false".
    La déclaration nillable="true" signifie que l'élément peut être présent mais vide, ne contenant aucune valeur.
    Naturellement, elle n'a pas d'intérêt pour un élément optionnel, dont l'attribut minoccurs vaut 0.

    Dans le fichier-instance, pour être valable, la viduité de l'élément doit être explicitée par l'attribut xsi:nil,
    à valeur booléenne "true".

    Donc pour le schéma <xsd:element name="intonil" type="xsd:int" nillable="true" />
    les deux instances <intonil>777</intonil> et <intonil xsi:nil="true"/> sont également valables,
    la seconde manifestant que ne transporte aucune valeur utilisable.
    En l'absence de nillable="true",  pour communiquer la même information il aurait fallu recourir à une valeur
    par défaut comme <intonil>777</intonil> et compliquer l'interprétation (problème bien connu !).

    Pour en savoir plus : 
  5. Espaces de noms

    1. Principe
      Il y a une relation étroite entre schémas et espaces de noms :
      étant donné un vocabulaire délimité par un espace de noms, il est naturel qu'un schéma vienne matérialiser
      l'organisation de ce vocabulaire - mais la manière de le faire est complexe.
      À titre illustratif, supposons que le vocabulaire de nos descriptions de voitures relève d'un espace de noms
      identifié par "http://jf.perrot.epita/voitures/".
      Attention ! il faut que tous

      La relation entre le schéma et l'espace de noms qu'il décrit est indiquée par le mécanisme suivant.

      1. Elle est marquée dans le schéma par l'attribut targetNamespace, dont la valeur est l'URI du namespace.
        Attention ! il faut que tous les schémas de la chaîne d'inclusions aient le même !
        C'est bien naturel, mais il faut savoir déchiffrer un message d'erreur comme :
        Fichier XML invalide  ou Schema incorrect : src-include.2.1:
        The targetNamespace of the referenced schema, currently 'http://perrot_a.epita/voitures/',
        must be identical to that of the including schema, currently 'http://jf.perrot.epita/voitures/'.

      2. Ledit namespace doit en plus être déclaré (sauf si aucun terme de son vocabulaire n'apparaît dans le schéma,
        ce qui est peu probable).

      3. Il convient de préciser si on autorise certains termes du vocabulaire du schéma à s'échapper de l'espace de noms annoncé.
        Cette précision peut être apportée individuellement dans le schéma au moyen d'un attribut form qui peut prendre
        deux valeurs qualified (= doit faire partie de l'espace de noms) et unqualified (= peut ne pas en faire partie).
        On fixe commodément une politique par défaut avec les attributs de la racine elementFormDefault  et
        attributeFormDefault, qui prennent les mêmes valeurs.

        Le plus souvent, on demande qualified pour les éléments et unqualified pour les attributs,
        ce qui signifie que
        • tous les éléments définis dans le schéma font partie de l'espace de noms - cible (target)
        • les attributs définis comme fils directs de la racine <xsd:schema...> (dits top-level)
          font aussi partie de l'espace de noms target.
          (dans notre exemple ci-dessus, c'est le cas pour les deux attributs de Transmission : type et nb_vitesses)
        • mais les attributs définis à l'intérieur d'un élément du schéma (dits local) ne font partie
          d'aucun namespace (et par conséquent ne doivent point porter de préfixe dans le document XML
          instance du schéma)
          (dans notre exemple automobile, c'est le cas pour les attributs marque, modèle et couleur)


      On aboutit ainsi à l'ouverture suivante pour nos schémas
      (fichier Voiture-3-0.ns.xsd aussi bien que fichier Voiture-3-2.ns.xsd)

      <?xml version="1.0" encoding="utf-8"?>
      <xsd:schema targetNamespace="http://jf.perrot.epita/voitures/"
          xmlns:xsd="http://www.w3.org/2001/XMLSchema"
          xmlns="http://jf.perrot.epita/voitures/"
          elementFormDefault="qualified"
          attributeFormDefault="unqualified"
          >

    2. Premier exemple avec le type Voiture unique:
      fichier Voiture-3.ns.xml     

      <?xml version="1.0"?>

      <v:Voiture
          xmlns:v="http://jf.perrot.epita/voitures/"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation=
      "http://jf.perrot.epita/voitures/ /Users/jfp/Sites/EPITA/XML09/Cours3/XMLS/VoituresS/Voiture-3-0.ns.xsd"
          marque="Renault" modèle="Safrane">
         
        <v:Carosserie couleur="rouge">
          <v:Capot>Un peu cabossé</v:Capot>
        </v:Carosserie>
        <v:Moteur>
          <v:Cylindres/>
          <v:Allumage>Défectueux</v:Allumage>
        </v:Moteur>
        <v:Transmission v:type="automatique" v:nb_vitesses="6">
          <v:Boîte/>
          <v:TrainAV/>
          <v:TrainAR/>
        </v:Transmission>
      </v:Voiture>


      Essai :
      jfp% java MyValid VoituresX/Voiture-3.ns.xml
      Le fichier VoituresX/Voiture-3.ns.xml est valide par rapport au schema /Users/jfp/Sites/EPITA/XML09/Cours3/XMLS/VoituresS/Voiture-3-0.ns.xsd
      jfp%

    3. Deuxième exemple avec des types dérivés :
      fichier Voiture-3b.ns.xml


      <?xml version="1.0"?>
      <vpe:liste
          xmlns:vpe="http://jf.perrot.epita/voitures/"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://jf.perrot.epita/voitures/ /Users/jfp/Sites/EPITA/XML09/Cours3/XMLS/VoituresS/Voiture-3-2.ns.xsd"
          >
         
      <vpe:Voiture marque="Renault" modèle="Safrane">
        <vpe:Carosserie couleur="rouge">
          <vpe:Capot>Un peu cabossé</vpe:Capot>
        </vpe:Carosserie>
        <vpe:Moteur>
          <vpe:Cylindres/>
          <vpe:Allumage>Défectueux</vpe:Allumage>
        </vpe:Moteur>
        <vpe:Transmission vpe:type="automatique" vpe:nb_vitesses="6">
          <vpe:Boîte/>
          <vpe:TrainAV/>
          <vpe:TrainAR/>
        </vpe:Transmission>
      </vpe:Voiture>

      <vpe:Voiture marque="Renault" modèle="Safrane" nbPortes="5"  xsi:type="vpe:typVoitureExt">
        <vpe:Carosserie couleur="rouge">
          <vpe:Capot>Un peu cabossé</vpe:Capot>
        </vpe:Carosserie>
        <vpe:Moteur>
          <vpe:Cylindres/>
          <vpe:Allumage>Défectueux</vpe:Allumage>
        </vpe:Moteur>
        <vpe:Transmission vpe:type="automatique" vpe:nb_vitesses="6">
          <vpe:Boîte/>
          <vpe:TrainAV/>
          <vpe:TrainAR/>
        </vpe:Transmission>
        <vpe:Genre>berline</vpe:Genre>
      </vpe:Voiture>

      <vpe:Voiture marque="Renault" modèle="Twingo" xsi:type="vpe:typVoitureB">
        <vpe:Carosserie couleur="rouge">
          <vpe:Capot>Un peu cabossé</vpe:Capot>
        </vpe:Carosserie>
        <vpe:Moteur>
          <vpe:Cylindres/>
          <vpe:Allumage>Défectueux</vpe:Allumage>
        </vpe:Moteur>
        <vpe:Transmission vpe:type="manuelle" vpe:nb_vitesses="4">
          <vpe:Boîte/>
          <vpe:TrainAV/>
          <vpe:TrainAR/>
        </vpe:Transmission>
      </vpe:Voiture>

      </vpe:liste>



      Essai avec Java 1.5  (bug dans le JDK) :
      jfp% java MyValid VoituresX/Voiture-3b.ns.xml
      ERREUR :  'UndeclaredPrefix: Cannot resolve 'vpe:typVoitureExt' as a QName: the prefix 'vpe' is not declared.'
      Fichier XML invalide  ou Schema incorrect : UndeclaredPrefix: Cannot resolve 'vpe:typVoitureExt' as a QName: the prefix 'vpe' is not declared.


      Essai avec Java 1.6 :
      jfp% java -version
      java version "1.6.0_07"
      Java(TM) SE Runtime Environment (build 1.6.0_07-b06-153)
      Java HotSpot(TM) 64-Bit Server VM (build 1.6.0_07-b06-57, mixed mode)

      jfp% javac MyValid.java
      jfp% java MyValid VoituresX/Voiture-3b.ns.xml
      Le fichier VoituresX/Voiture-3b.ns.xml est valide par rapport au schema /Users/jfp/Sites/EPITA/XML09/Cours3/XMLS/VoituresS/Voiture-3-2.ns.xsd


    4. Conclusion
      Comme annoncé plus haut, on note la différence de traitement entre les attributs top-level type et nb_vitesses
      qui portent le préfixe de namespace "vpe:" et les attributs locaux  marque, modèle et couleur qui ne le portent pas.

      La nécessité de marquer cette différence rend indispensable l'emploi du préfixe.
      Si on essaie d'adopter notre namespace comme espace par défaut, avec la déclaration
      xmlns="http://jf.perrot.epita/voitures/"
      on s'attire les foudres du vérificateur :
      Attribute 'type' is not allowed to appear in element 'Transmission'.
  6. Inclusion, importation

    Les espaces de noms interviennent encore dans les instructions d'importation :

    Toute cette mécanique va se mettre en marche dans les fichiers WSDL que nous allons examiner dans la suite du cours.