Les schémas XML

ATTENTION : Tutorial en cours d'écriture ! N'hésiter pas à nous signaler toute erreur ou suggestion.

Dans le chapitre précédent, nous avons étudié la notion de DTD (Document Type Definition) qui permet de valider la cohérence d'un fichier XML. Il existe un autre formalisme permettant d'arriver au même résultat : la notion de "XML Schema" (schéma XML en français). C'est précisément ce formalisme sur lequel pour allons porter notre attention dans ce chapitre.

XML Schema est donc un langage permettant de décrire le format d'un langage XML, comme l'est le langage DTD. A la base, c'est la société Microsoft qui a commencé à travailler sur les bases de ce langage. Il a ensuite proposé ces travaux pour standardisation au sein du W3C (le World Wide Web Consortium). Ceci explique en partie qu'il existe plusieurs variantes de la notion de schéma XML. Nous nous focaliserons, dans ce tutorial, uniquement sur la version spécifiée par le W3C.

La première version officiel proposée par le W3C date du 2 mai 2001. Une révision a été proposée le 28 octobre 2004 : il s'agit de la version 1.1. Vous pourrez trouver toute information complémentaire à l'adresse suivante : W3C XML Schema.

En fait, ce formalisme est lui même un langage XML. Un schéma XML se définit donc a partir d'un certain nombre de tags XML, contrairement à une définition de DTD.

Comme on vient de l'indiquer, la première différence réside dans la syntaxe utilisée. Il faut reconnaître que le formalisme DTD est relativement simple et compact. Au contraire, le langage XML Schema est basé sur des tags XML ce qui le rend parfois un peu fastidieux à définir. A ce sujet, sachez qu'il existe des outils de conversions qui permettent de passer d'un formalisme à un autre (et vis-versa).

La deuxième différence est très importante : le formalisme de DTD est très limité et notamment quand à la définition des types de données pour les valeurs d'attributs. En simplifiant les chose, les DTD ne supportent que les chaînes de caractères ou des types énumérés. Les schéma XML enrichissent ce point en permettant de définir des attributs de types numériques, booléens, ... Cela permet donc de mieux contrôler la cohérence des documents validés.

Enfin, notez qu'avec les schémas XML, il est possible de mixer plusieurs langages XML au sein d'un même document. C'est exactement ce qui se passe lorsque vous définissez une feuille de style XSL : elle contient des tags provenant du langage XSL ainsi que d'autres tags, provenant eux, du langage HTML.

Vous avez principalement deux solutions pour associer un schéma XML à un document XML : soit vous utilisez la notion de targetNamespace (au niveau de la définition de votre grammaire), soit vous n'en utilisez pas. Si vous choisissez de ne pas utiliser de targetNamespace, alors il ne vous sera pas possible de mixer plusieurs langages XML dans le même document (en contre partie, les différentes définitions utilisées pour l'association seront plus simples). Regardons ces deux possibilités en détails : nous utiliserons dans les exemples qui suivent un langage XML très simpliste qui permettra de définir le contenu d'un email.

Commençons par mettre en oeuvre notre grammaire de définition d'un langage XML d'email.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 

<?xml version="1.0" encoding="utf-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
           
    <xs:element name="email">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="to" type="xs:string" />
                <xs:element name="from" type="xs:string" />
                <xs:element name="subject" type="xs:string" />
                <xs:element name="body" type="xs:string" />
            </xs:sequence>
       </xs:complexType>
    </xs:element>
    
</xs:schema>

Le contenu de ce fichier est assez simple : l'élément (le tag) racine est email. Celui à un contenu complexe, car constitué de la séquence de sous-tags suivante : to, from, subject et body. Ces quatre éléments contiennent tous une chaîne de caractères et qui plus est, ces éléments doivent être placés très exactement dans cet ordre. Notez aussi qu'un fichier de type XML Schema a fréquemment l'extension .xsd.

La grammaire de notre langage étant définie, il nous faut maintenant produire un premier fichier XML se basant sur cette grammaire. Voici un exemple possible. Notez qui si vous utilisez un éditeur évolué (par exemple Eclipse) pour éditer ce fichier XML, une assistance à la saisie vous sera proposée en fonction des tags définis par notre langage.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 

<?xml version="1.0" encoding="UTF-8" ?>
<email xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:noNamespaceSchemaLocation="email.xsd">
       
    <to>toto@societe.com</to>
    <from>titi@autre.com</from>
    <subject>Ceci est le sujet de ce mail</subject>
    <body>Cette partie defini le corps de ce mail</body>    
    
</email>

L'attribut xmlns permet de définir un espace de noms (un NameSpace). Un espace de noms est associé à une grammaire de type schéma XML. Comme l'URI(Uniform Resource Locator) d'un espace de nom peut être relativement long, en général, on lui associe aussi un alias. Dans l'exemple ci dessus, on charge la grammaire associée à l'espace de nom http://www.w3.org/2001/XMLSchema-instance : son alias sera dans ce document xsi. Cette grammaire définie les attributs XML nécessaire à la spécification de la DTD à charger. Sans xsi, le document XML ne pourra pas être associé à votre fichier XSD.

L'attribut xsi:noNamespaceSchemaLocation permet de spécifier que l'on cherche à charger un schéma XML non associé à un targetNamespace particulier : ici, le fichier email.xsd défini dans l'extrait de code précédent. Une fois cet attribut défini, votre éventuel éditeur XML pourra alors vérifier la cohérence de votre document XML. Si vous utilisez l'IDE(Integrated Development Environment) Eclipse, vous pourrez alors cliquer avec le bouton droit de votre souris en plein milieu du fichier XML et sélectionner l'élément de menu "Validate" pour réaliser la vérification.

L'intérêt de cette technique est de forcer l'association de votre grammaire à son URI. L'URI de la grammaire doit être définie dans le fichier XSD via l'attribut targetNamespace : il doit être placé sur le tag racine <xs:schema>. Voici un exemple de définition de targetNamespace pour notre langage de définition d'email.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 

<?xml version="1.0" encoding="utf-8" ?>
<xs:schema xmlns="http://www.infini-software.com/email"
           xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.infini-software.com/email">
           
    <xs:element name="email">
        <xs:complexType>
            <xs:sequence>
                <xs:element name="to" type="xs:string" />
                <xs:element name="from" type="xs:string" />
                <xs:element name="subject" type="xs:string" />
                <xs:element name="body" type="xs:string" />
            </xs:sequence>
       </xs:complexType>
    </xs:element>
    
</xs:schema>

Ensuite, il faut indiquer que nous utilisons cette URI dans notre document (il vous est possible d'associer cette URI à un alias). Voici un exemple d'association, sans utilisation d'alias.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 

<?xml version="1.0" encoding="utf-8" ?>
<m:email xmlns:m="http://www.infini-software.com/email"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.infini-software.com/email email.xsd">

    <to>toto@societe.com</to>
    <from>titi@autre.com</from>
    <subject>Ceci est le sujet de ce mail</subject>
    <body>Cette partie defini le corps de ce mail</body>   
    
</m:email>

Nous allons maintenant voir comment définir son schéma XML. Pour ce faire, nous allons considérer un nouveau besoins. Imaginons que nous ayons besoin d'un langage XML permettant de définir des figures géométriques (des cercles et des carrés). Voici à titre d'exemple un exemple de fichier que nous souhaitons valider par un schéma XML.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 
 22 
 23 
 24 
 25 
 26 
 27 
 28 
 29 
 30 
 31 
 32 
 33 
 34 
 35 
 36 
 37 

<?xml version="1.0" encoding="ISO-8859-1" ?>
<Shapes xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="Shapes.xsd"
        width="400" height="400">

    <Circle color="red" isFill="true">
        <Position x="100" y="200" />
        <Radius length="50" />
    </Circle>
    
    <Circle color="green" isFill="true">
        <Position x="250" y="150" />
        <Radius length="100" />
    </Circle>

    <Circle color="blue" isFill="true">
        <Position x="350" y="50" />
        <Radius length="20" />
    </Circle>


    <Square color="blue" isFill="false">
        <Position x="300" y="300" />
        <Size length="50" />
    </Square>

    <Square color="white" isFill="true">
        <Position x="100" y="100" />
        <Size length="30" />
    </Square>
    
    <Square color="pink" isFill="true">
        <Position x="100" y="320" />
        <Size length="80" />
    </Square>
    
</Shapes>

Commencez par définir un fichier Shapes.xsd vide, mais associé à l'espace de noms de votre langage XML. Voici un exemple d'un tel fichier : notez que j'ai choisi de simplifier les choses en considérant un schéma XML non associé à un targetNamespace.

 1 
 2 
 3 
 4 
 5 
 6 

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

    <!-- TODO -->

</xs:schema>

to be continued ...