Un exemple de XSD

Cette section vous démontrera comment écrire un XML Schema. Vous apprendrez également différentes méthodes d'écriture de schémas.

Document XML

Voyons ce document XML nommé "shiporder.xml" :

<?xml version="1.0" encoding="ISO-8859-1"?>
<shiporder orderid="889923">


 <orderperson>George Bush</orderperson>
 <shipto>
  <name>John Adams</name>
  <address>Oxford Street</address>
  <city>London</city>
  <country>UK</country>
 </shipto>
 <item>
  <title>Empire Burlesque</title>
  <note>Édition spéciale</note>
  <quantity>1</quantity>
  <price>10.90</price>
 </item>
 <item>
  <title>Hide your heart</title>
  <quantity>1</quantity>
  <price>9.90</price>
 </item>
</shiporder>

Le document XML ci-dessus inclut l'élément racine "shiporder", qui contient une propriété obligatoire nommée "orderid". L'élément "shiporder" contient trois éléments enfants différents : "orderperson", "shipto" et "item". L'élément "item" apparaît deux fois, il contient un élément "title", un élément optionnel "note", un élément "quantity" et un élément "price".

La ligne ci-dessus xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" informe l'analyseur XML de valider ce document en fonction d'un certain schéma. Cette ligne : xsi:noNamespaceSchemaLocation="shiporder.xsd" spécifie l'emplacement du schéma (ici, il se trouve dans le même dossier que "shiporder.xml").

Créer un XML Schema

Maintenant, nous devons créer un schéma pour ce document XML .

Nous pouvons commencer par ouvrir un nouveau fichier et nommer ce fichier "shiporder.xsd" . Pour créer un schéma, nous devons simplement suivre la structure du document XML, définir chaque élément que nous trouvons . Tout d'abord, nous commençons par définir une déclaration XML standard :

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
...
...
</xs:schema>

Dans le schéma ci-dessus, nous avons utilisé l'espace de noms standard (xs), qui est associé à l'URI du langage de définition du schéma (Schema language definition), dont la valeur standard est http://www.w3.org/2001/XMLSchema .

Ensuite, nous devons définir l'élément "shiporder" . Cet élément possède un attribut contenant d'autres éléments, donc nous le considérons comme un type composé . Les éléments enfants de l'élément "shiporder" sont entourés de l'élément xs:sequence, définissant l'ordre des éléments :

<xs:element name="shiporder">
 <xs:complexType>
  <xs:sequence>
  ...
  ...
  </xs:sequence>
  ...
 </xs:complexType>
</xs:element>

Ensuite, nous devons définir l'élément "orderperson" comme un type simple (c'est parce qu'il ne contient aucune propriété ou autre élément) . Le préfixe du type (xs:string) est déterminé par le préfixe de l'espace de noms, qui est associé à l'XML schema indiquant les types de données de schéma prédéfinis :

<xs:element name="orderperson" type="xs:string"/>

Ensuite, j'ai besoin de définir deux éléments comme des types composés : "shipto" et "item" . Nous allons commencer par définir l'élément "shipto" :

<xs:element name="shipto">
 <xs:complexType>
  <xs:sequence>
   <xs:element name="name" type="xs:string"/>
   <xs:element name="address" type="xs:string"/>
   <xs:element name="city" type="xs:string"/>
   <xs:element name="country" type="xs:string"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>

Par le biais du schéma, nous pouvons utiliser les attributs maxOccurs et minOccurs pour définir le nombre d'apparitions possibles d'un élément . maxOccurs définit la valeur maximale du nombre d'apparitions d'un élément, tandis que minOccurs définit la valeur minimale du nombre d'apparitions d'un élément . Les valeurs par défaut de maxOccurs et minOccurs sont toutes deux 1 !

Maintenant, nous pouvons définir l'élément "item" . Cet élément peut apparaître plusieurs fois à l'intérieur de l'élément "shiporder" . Cela est réalisé en définissant la valeur de l'attribut maxOccurs de l'élément "item" à "unbounded" , de sorte que l'élément "item" peut apparaître aussi souvent que le créateur le souhaite . Veuillez noter que l'élément "note" est un élément optionnel . Nous avons déjà défini l'attribut minOccurs de cet élément à 0 :

<xs:element name="item" maxOccurs="unbounded">
 <xs:complexType>
  <xs:sequence>
   <xs:element name="title" type="xs:string"/>
   <xs:element name="note" type="xs:string" minOccurs="0"/>
   <xs:element name="quantity" type="xs:positiveInteger"/>
   <xs:element name="price" type="xs:decimal"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>

Maintenant, nous pouvons déclarer les attributs de l'élément "shiporder" . Comme c'est un attribut obligatoire, nous stipulons use="required" .

Remarque :La déclaration de cet attribut doit être placée en dernier :

<xs:attribute name="orderid" type="xs:string" use="required"/>

Voici la liste des documents de ce fichier de schéma nommé "shiporder.xsd" :

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="shiporder">
 <xs:complexType>
  <xs:sequence>
   <xs:element name="orderperson" type="xs:string"/>
   <xs:element name="shipto">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="name" type="xs:string"/>
      <xs:element name="address" type="xs:string"/>
      <xs:element name="city" type="xs:string"/>
      <xs:element name="country" type="xs:string"/>
     </xs:sequence>
    </xs:complexType>
   </xs:element>
   <xs:element name="item" maxOccurs="unbounded">
    <xs:complexType>
     <xs:sequence>
      <xs:element name="title" type="xs:string"/>
      <xs:element name="note" type="xs:string" minOccurs="0"/>
      <xs:element name="quantity" type="xs:positiveInteger"/>
      <xs:element name="price" type="xs:decimal"/>
     </xs:sequence>
    </xs:complexType>
   </xs:element>
  </xs:sequence>
  <xs:attribute name="orderid" type="xs:string" use="required"/>
 </xs:complexType>
</xs:element>
</xs:schema>

Diviser le Schema

La méthode de conception précédente est très simple, mais elle est difficile à lire et à maintenir lorsque le document est complexe.

La méthode de conception présentée ici est basée sur la définition initiale de tous les éléments et attributs, puis sur l'utilisation de l'attribut ref pour les référer.

Ceci est un fichier de schéma conçu avec une nouvelle méthode :

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- Définition simple des éléments -->
<xs:element name="orderperson" type="xs:string"/>
<xs:element name="name" type="xs:string"/>
<xs:element name="address" type="xs:string"/>
<xs:element name="city" type="xs:string"/>
<xs:element name="country" type="xs:string"/>
<xs:element name="title" type="xs:string"/>
<xs:element name="note" type="xs:string"/>
<xs:element name="quantity" type="xs:positiveInteger"/>
<xs:element name="price" type="xs:decimal"/>
<!-- Définition des attributs -->
<xs:attribute name="orderid" type="xs:string"/>
<!-- Définition de l'élément composé -->
<xs:element name="shipto">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="name"/>
   <xs:element ref="address"/>
   <xs:element ref="city"/>
   <xs:element ref="country"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>
<xs:element name="item">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="title"/>
   <xs:element ref="note" minOccurs="0"/>
   <xs:element ref="quantity"/>
   <xs:element ref="price"/>
  </xs:sequence>
 </xs:complexType>
</xs:element>
<xs:element name="shiporder">
 <xs:complexType>
  <xs:sequence>
   <xs:element ref="orderperson"/>
   <xs:element ref="shipto"/>
   <xs:element ref="item" maxOccurs="unbounded"/>
  </xs:sequence>
  <xs:attribute ref="orderid" use="required"/>
 </xs:complexType>
</xs:element>
</xs:schema>

Utilisation des types spécifiés (Types nommés)

La troisième méthode de conception définit des classes ou des types, ce qui nous permet de réutiliser les définitions des éléments. Le mode spécifique est : d'abord nommer les éléments simples et complexes, puis pointer vers eux à l'aide de l'attribut type de l'élément.

C'est un fichier schema ("shiporder.xsd") conçu en utilisant la troisième méthode :

<?xml version="1.0" encoding="ISO-8859-1" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:simpleType name="stringtype">
 <xs:restriction base="xs:string"/>
</xs:simpleType>
<xs:simpleType name="inttype">
 <xs:restriction base="xs:positiveInteger"/>
</xs:simpleType>
<xs:simpleType name="dectype">
 <xs:restriction base="xs:decimal"/>
</xs:simpleType>
<xs:simpleType name="orderidtype">
 <xs:restriction base="xs:string">
  <xs:pattern value="[0-9]{6}"/>
 </xs:restriction>
</xs:simpleType>
<xs:complexType name="shiptotype">
 <xs:sequence>
  <xs:element name="name" type="stringtype"/>
  <xs:element name="address" type="stringtype"/>
  <xs:element name="city" type="stringtype"/>
  <xs:element name="country" type="stringtype"/>
 </xs:sequence>
</xs:complexType>
<xs:complexType name="itemtype">
 <xs:sequence>
  <xs:element name="title" type="stringtype"/>
  <xs:element name="note" type="stringtype" minOccurs="0"/>
  <xs:element name="quantity" type="inttype"/>
  <xs:element name="price" type="dectype"/>
 </xs:sequence>
</xs:complexType>
<xs:complexType name="shipordertype">
 <xs:sequence>
  <xs:element name="orderperson" type="stringtype"/>
  <xs:element name="shipto" type="shiptotype"/>
  <xs:element name="item" maxOccurs="unbounded" type="itemtype"/>
 </xs:sequence>
 <xs:attribute name="orderid" type="orderidtype" use="required"/>
</xs:complexType>
<xs:element name="shiporder" type="shipordertype"/>
</xs:schema>

L'élément "restriction" indique que le type de données de l'élément provient de l'espace de noms de type de données W3C XML Schema. Par conséquent, le fragment suivant signifie que la valeur de l'élément ou de l'attribut doit être une valeur de type chaîne :

<xs:restriction base="xs:string">

L'élément restriction est souvent utilisé pour appliquer des limitations aux éléments. Voir ci-dessous des fragments de schema mentionnés précédemment:

<xs:simpleType name="orderidtype">
 <xs:restriction base="xs:string">
  <xs:pattern value="[0-9]{6}"/>
 </xs:restriction>
</xs:simpleType>

Ce code indique que la valeur de l'élément ou de l'attribut doit être une chaîne de caractères et doit être continue sur six caractères, et ces caractères doivent être des chiffres de 0 à 9.