XSD Exemple
Cette section montrera comment écrire un schéma XML. Vous apprendrez également différentes méthodes d'écriture d'un schéma.
Document XML
Regardons ce document XML nommé "shiporder.xml" :
<shiporder orderid="889923"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="shiporder.xsd">
<orderperson>John Smith</orderperson>
<shipto>
<name>Ola Nordmann</name>
<address>Langgt 23</address>
<city>4000 Stavanger</city>
<country>Norvège</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 comprend l'élément racine "shiporder", qui contient un attribut obligatoire nommé "orderid". L'élément "shiporder" contient trois éléments enfants différents : "orderperson", "shipto" et "item". L'élément "item" apparaît deux fois, et il contient un "title", un élément "note" facultatif, un "quantity" et un élément "price".
La ligne ci-dessus, xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance", indique à l'analyseur XML de valider ce document par rapport à un 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 schéma XML
Maintenant, nous devons créer un schéma pour le document XML ci-dessus.
Nous pouvons commencer par ouvrir un nouveau fichier et le nommer "shiporder.xsd". Pour créer le schéma, nous devons simplement suivre la structure du document XML et définir chaque élément que nous trouvons. Tout d'abord, nous commençons par définir une déclaration XML standard :
<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). L'URI associé à cet espace de noms est la définition du langage de schéma, et sa 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 et contient d'autres éléments, donc nous l'identifions comme un type complexe. Les éléments enfants de l'élément "shiporder" sont entourés par l'élément xs:sequence, qui définit l'ordre des éléments enfants :
<xs:complexType>
<xs:sequence>
...
</xs:sequence>
</xs:complexType>
</xs:element>
Ensuite, nous devons définir l'élément "orderperson" comme un type simple (car il ne contient aucun attribut ni aucun autre élément). Le préfixe du type (xs:string) est spécifié par le préfixe d'espace de noms, qui est associé au schéma XML qui indique les types de données de schéma prédéfinis :
Ensuite, je dois définir deux éléments comme types complexes : "shipto" et "item". Nous commençons par définir l'élément "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>
Grâce à un schéma, nous pouvons utiliser les attributs maxOccurs et minOccurs pour définir combien de fois un élément particulier peut apparaître. maxOccurs définit le nombre maximal de fois qu'un élément peut apparaître, tandis que minOccurs définit le nombre minimal de fois qu'un élément peut apparaître. La valeur par défaut pour maxOccurs et minOccurs est 1 !
Maintenant, nous pouvons définir l'élément "item". Cet élément peut apparaître plusieurs fois dans l'élément "shiporder". Cela est accompli en définissant la valeur de l'attribut maxOccurs de l'élément "item" sur "unbounded", afin que l'élément "item" puisse apparaître autant de fois que l'auteur le souhaite. Notez que l'élément "note" est un élément facultatif. Nous avons défini son attribut minOccurs sur 0 :
<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 l'attribut de l'élément "shiporder". Comme il s'agit d'un attribut obligatoire, nous spécifions use="required".
Remarque :La déclaration de cet attribut doit être placée à la fin :
Voici la liste du document du fichier de schéma nommé "shiporder.xsd" :
<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 schéma
La méthode de conception précédente est très simple, mais lorsque le document est complexe, il est difficile à lire et à maintenir.
La méthode de conception présentée ensuite repose sur la définition préalable de tous les éléments et attributs, puis sur l'utilisation de l'attribut ref pour les référencer.
Voici le fichier de schéma ("shiporder.xsd") conçu à l'aide de la nouvelle méthode :
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- définition des éléments simples -->
<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 des éléments complexes -->
<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 de types nommés
La troisième méthode de conception définit des classes ou des types, ce qui nous donne la possibilité de réutiliser les définitions d'éléments. L'approche spécifique est la suivante : d'abord nommer les éléments simples et les éléments complexes, puis y faire référence via l'attribut type de l'élément.
Voici le fichier de schéma ("shiporder.xsd") conçu à l'aide de la troisième méthode :
<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 est dérivé d'un type de données dans l'espace de noms 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 :
L'élément restriction est souvent utilisé pour imposer des restrictions sur des éléments. Regardez les fragments suivants du schéma ci-dessus :
<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, et doit comporter six caractères consécutifs, et ces caractères doivent être des chiffres de 0 à 9.
Autres extensions