Valider son document XML

grâce à une XSD

Niveau 1

YAO JY Aristide

Objectifs pédagogiques :
• Définir les types d’attribut XSD
• Définir les types d’élément XSD
• Créer un type complexe à partir d’un type simple
• Créer des restrictions sur les éléments et sur les attributs
• Ecrire le schéma de validation d’un document XML bien
formé avec une XSD
Table des matières
I. INTRODUCTION .............................................................................................................. 3
a. Rappel : Comparaison DTD et XSD ............................................................................... 3
b. GC : Structure de base ..................................................................................................... 3
c. lier un fichier XML à un schema. ................................................................................... 4
II. Déclaration d’éléments .................................................................................................... 4
a. Type simple prédéfini...................................................................................................... 4
b. Type complexe ................................................................................................................ 5
c. Création de type complexe à partir de types simples ...................................................... 5
d. Choix d’élément, <xs:choice> dans une séquence .......................................................... 6
e. L’élément all <xs:all> ..................................................................................................... 6
f. Elément ne contenant que du texte avec un (ou plusieurs) attribut(s)............................. 6
g. Cardinalité dans les XML Schéma .................................................................................. 7
h. Déclaration d'élément contenant texte et éléments enfants ............................................. 7
i. Déclaration et référencement........................................................................................... 7
III. Déclaration d’attributs ..................................................................................................... 8
a. Contraintes d’occurrences d’un attribut .......................................................................... 8
b. Comparaison entre le format DTD et le XML Schema .................................................. 8
c. Restriction de type ........................................................................................................... 9
 I. INTRODUCTION
Le but d'un schéma est de décrire les autorisations d'imbrication, l'ordre d'apparition des
éléments et de leurs attributs, tout comme une DTD. Mais il permet aussi d'aller au-delà.
Un schéma XML (XSD) est un document XML, ainsi un tel document peut être manipulé
comme un fichier XML ; c’est-à-dire qu’on peut y appliquer une feuille de style XSL (nous
verrons ce point dans la prochaine leçon).

a. Rappel : Comparaison DTD et XSD

• DTD :
o Essentiellement, définition de l’imbrication des éléments et définition des
attributs
o Typage pauvre
o Pas de gestion des espaces de nom, cela veut dire qu’il n’est pas possible
d’importer des balises définies dans un autre fichier XML valide.
o Pas beaucoup de contraintes sur le contenu d’un document
• XML Schema : Propose des nouveautés en plus des fonctionnalités fournies par les
DTD
o Notion de typage, ce qui permet la gestion des booléens, d’entiers, d’intervalles
de temps, etc.
o Il est possible de créer de nouveaux types à partir des types existants.
o Contraintes de cardinalité, dans une DTD, l’usage des cardinalités est limité à
0,1 ou un nombre infini d’occurrences pour un élément.
o Support des espaces de noms
o Support de la notion d’héritage. Les éléments peuvent hériter du contenu et des
attributs d’un autre élément.
o Format XML

b. GC : Structure de base

Comme tout document XML, un schema XML commence par un prologue, et a un élément
racine.
<?xml version="1.0" encoding="UTF-8"?>

<xs:schema xmlns:xs="[Link]
<!-- déclarations d'éléments, d'attributs et de types ici -->
</xs:schema>
< ?xml ?> représente le prologue et <xs:schema> est l’élément racine.
L’élément racine possède un attribut xmlns:xs qui prend comme paramètre le lien http qui
permet d’écrire un schéma valide.
Le préfixe xs est l’alias (défini par le programmeur) de l’espace de nom auquel font référence
les balises qui permettent de définir les règles du schéma.
NOTE: Cet alias peut prendre n’importe quel nom défini par le programmeur.

Exercice : serait il possible d’écrire l’élément racine de la sorte :

1. <xsd:schema xmlns:xsd="[Link]
2. <!-- déclarations d'éléments, d'attributs et de types ici -->
3. </xsd:schema>
4.
REPONSE : oui car l’alias de l’espace de nom est défini par le programmeur.
NOTE : xmlns signifie XML NameSpace
 c. lier un fichier XML à un schema.

Supposons qu’on veuille dans notre schéma précédent, faire usage d’un document bibliothèque
dont le schema est hébergé à l’adresse [Link]
On écrira :
1. <bib:biblio xmlns:bib="[Link]
2. < !—Ecriture du contenu ici -->
3. </bib:biblio>
Dans ce cas, tous les éléments, attributs et types de données préfixés par bib: seront ceux définis
à l’adresse [Link]
Un espace de nom permet de mélanger plusieurs vocabulaires au sein d’un même document.
C’est-à-dire qu’on peut utiliser les balises définies dans un quelconque schéma donné dans un
autre document XML.

II. Déclaration d’éléments

Pour déclarer un élément, on utilise la balise suivante :<xs:element>. Chaque élément déclaré
a un « nom » via l’attribut name et est associé à un type de données via l’attribut type
Par exemple :
1. <?xml version="1.0" encoding="ISO-8859-1"?>
2. <xs:schema xmlns:xs="[Link]
3. <xs:element name="contacts" type="typeContacts" />
4. <xs:element name="observation" type="xs:string" />
5. <!-- déclarations de types ici -->
6. </xs:schema>

Le schéma précédent déclare deux éléments : un élément contacts et un élément observation.

Chaque élément est « typé » ; c'est-à-dire qu'il doit respecter un certain format de données.
L'élément contacts est ainsi du type typeContacts, qui est un type complexe défini par le
programmeur. L'élément remarque quant à lui est du type xs:string qui est un type simple
prédéfini de XML Schema.

a. Type simple prédéfini

Un type prédéfini est utilisé seulement dans le contexte d’un texte. Ci-dessous quelque types
simples prédéfinis :
xs:integer, xs:boolean, xs:string, xs:date, xs:long
par exemple :
1. <xs:element name="telephone" type="xs:long" />
La figure suivante en donne la hiérarchie, et leur liste détaillée figure sur le site du W3C.
Les types de données les plus simples (string) que permettaient les DTDs sont conservés, mais
d'autres ont fait leur apparition. On pourra envisager, par exemple, dans un schéma décrivant la
quantité disponible de livre, la déclaration d'un attribut quantité :
1. <xs:attribute name="quantite" type="xs:positiveInteger" use="optional" value="1" />
Un élément de type simple ne peut contenir ni attribut, ni élément enfant.

b. Type complexe
Vu la limite des éléments de type simple, il est nécessaire pour construire un élément pouvant
contenir des sous éléments, de le déclarer de type complexe. Un type complexe est un conteneur
pour d'autres définitions d'éléments. Il vous permet de spécifier quelles éléments enfants un
élément peut contenir et de fournir une structure dans un document XML.
Par exemple :
1. <xs:element name = "addresse">
2. <xs:complexType>
3. <xs:sequence>
4. <xs:element name = "quartier" type = "xs:string" />
5. <xs:element name = "rue" type = "xs:string" />
6. <xs:element name = "numero_villa" type = "xs:int" />
7. </xs:sequence>
8. </xs:complexType>
9. </xs:element>

Dans l'exemple ci-dessus, l'élément Adresse se compose d'éléments enfants. La balise

<xs:sequence> permet de définir ces éléments enfants dans un ordre déterminé.

c. Création de type complexe à partir de types simples

Considérons l’écriture xml de l’élément taille :

1. <taille unite="cm">180</taille>
Question : cette élément xml est simple ou complexe ?
Réponse : Un élément simple ne possède ni attribut, ni élément enfant. Il a pour contenu
seulement du texte.
Cet élément est de type complexe car il possède un attribut ‘unite’. Il faut par conséquent
dériver un type complexe à partir du type simple xs:positiveInteger
1. <xs:complexType name="typeTaille">
2. <xs:simpleContent>
3. <xs:extension base="xs:positiveInteger">
4. <xs:attribute name="unite" type="xs:string" />
5. </xs:extension>
6. </xs:simpleContent>
7. </xs:complexType>

L’élément xs:simpleContent indique que le nouvel élément ne contient pas de sous-élément et

xs:extension est utilisé pour étendre le type

d. Choix d’élément, <xs:choice> dans une séquence

xs:choice permet de faire un choix d’élément parmi plusieurs. Par exemple pour
l’enregistrement d’une personne, il préfèrerait être joint par téléphone ou par mail. Pour cela on
crée le type complexe suivant :
1. <xs:complexType name="typePersonne">
2. <xs:sequence>
3. <xs:element name="nom" type="xs:string" />
4. <xs:element name="prenom" type="xs:string" />
5. <xs:choice>
6. <xs:element name="telephone" type="xs:int" />
7. <xs:element name="adresseElectronique" type="xs:string" />
8. </xs:choice>
9. </ xs:sequence>
10. <xs:element name="dateDeNaissance" type="xs:date" />
11. </xs:complexType>
<xs:choice> est l’équivalent de l’opérateur « | » dans la déclaration d’un DTD

e. L’élément all <xs:all>

Il indique que les éléments enfants doivent apparaître une fois ou pas du tout, dans
n’importe quel ordre. Cet élément doit être un enfant direct de l’élément <xs:complexType>.
1. <xs:complexType name=”typePersonne”>
2. <xs:all>
3. <xs:element name="nom" type="xs:string" />
4. <xs:element name="dateDeNaissance" type="xs:date" />
5. <xs:element name="adresseElectronique" type="xs:string" />
6. <xs:element name="téléphone" type="numéroDeTéléphone" />
7. </xs:all>
8. </xs:complexType>
<xs:all> est l’équivalent de l’opérateur ? dans la déclaration d’une DTD.

f. Elément ne contenant que du texte avec un (ou plusieurs) attribut(s)

Un tel élément est de type complexe, car il contient au moins un attribut. Pour spécifier qu'il
peut également contenir du texte, on utilise l'attribut mixed de l'élément xs:complexType. Par
défaut, mixed="false"; il faut donc changer la valeur de l’attribut mixed="true". Par exemple :
1. <xs:element name="elt">
2. <xs:complexType mixed="true">
3. <xs:attribute name="attr" type="xs:string" use="optional" />
4. </xs:complexType>
5. </xs:element>

g. Cardinalité dans les XML Schéma

XML Schema permet de déclarer directement le nombre de fois qu’un élément peut apparaître.
Pour déclarer qu’un élément peut être présent un nombre illimité de fois, on utilise la valeur
unbounded. Pour spécifier le nombre de fois maximal qu’il peut apparaitre, on utilise
maxOccurs et minOccurs pour le nombre de fois minimal.
Dans
Valeur de minOccurs Valeur de maxOccurs
une DTD
* 0 unbounded

+ 1 (pas nécessaire, valeur unbounded

par défaut)
1 (pas nécessaire, valeur par
? 0
défaut)
1 (pas nécessaire, valeur 1 (pas nécessaire, valeur par
rien
par défaut) défaut)
nombre entier n nombre entier m quelconque
impossible
quelconque supérieur ou égal à n

h. Déclaration d'élément contenant texte et éléments enfants

Un élément peut contenir du texte ainsi que des éléments enfants. Il doit dans ce cas être de
type complexe, et sa déclaration doit elle aussi utiliser l'attribut mixed :
1. <xs:element name="elt">
2. <xs:complexType mixed="true">
3. <xs:choice minOccurs="0" maxOccurs="unbounded">
4. <xs:element name="enfant" />
5. <xs:element name="kid" />
6. <xs:element name="Kind" />
7. </xs:choice>
8. </xs:complexType>
9. </xs:element

i. Déclaration et référencement

Lors de la mise en place d’une xsd, il est recommandé de commencer par déclarer les éléments
et attributs de type simple, puis ceux de type complexe. On peut en effet faire référence, dans
une déclaration de type complexe, à un élément de type simple préalablement défini. Par
exemple :

1. <xs:element name="livre">
2. <xs:complexType>
3. <xs:sequence>
4. <xs:element name="auteur" type="xs:string" />
5. <xs:element name="pages" type="xs:positiveInteger" />
6. </xs:sequence>
7. </xs:complexType>
8. </xs:element>
Le code précédent est plus difficile à maintenir que le code suivant :
 1. <xs:element name="pages" type="xs:positiveInteger" />
2. <xs:element name="auteur" type="xs:string" />
3. <xs:element name="livre">
4. <xs:complexType>
5. <xs:sequence>
6. <xs:element ref="auteur" />
7. <xs:element ref="pages" />
8. </xs:sequence>
9. </xs:complexType>
10. </xs:element>

III. Déclaration d’attributs

À la différence des éléments, un attribut ne peut qu’être de type simple ; c’est-à-dire que les
attributs ne peuvent contenir ni d’autres attributs ni d’autres éléments. Dans la structure d’un
XML Schema, les déclarations d’attributs se place juste avant la balise fermante
</xs:complexType>

2. <xs:complexType>
3. <xs:sequence>
4. <xs:element name="dateDeNaissance" type="xs:date" />
5. <xs:element name="adresse" type="xs:string" />
6. <xs:element name="adresseElectronique" type="xs:string" />
7. <xs:element name="téléphone" type="numéroDeTéléphone" />
8. </xs:sequence>
9. <xs:attribute name="nom" type="xs:string" />
10. <xs:attribute name="prenom" type="xs:string" />
11. </xs:complexType>

Exercice : Ecrire le document XML qui correspond à la déclaration de ce type complexe. Les
propositions de réponse doivent être renseignées sur le forum et discuté entre paires.
L’enseignant interviendra si besoin.

a. Contraintes d’occurrences d’un attribut

L'élément attribute dans un schéma XML peut avoir trois attributs optionnels : use (valeur par
défaut : optional), default, et fixed. Ces attributs permettent de définir ce qui est acceptable dans
le fichier XML final, comme un attribut obligatoire, optionnel, ou avec une valeur par défaut.
Par exemple, la ligne suivante rend l'attribut maj optionnel avec une valeur par défaut du 11
octobre 2023 si l'attribut n'apparaît pas :
1. <xs:attribute name="maj" type="xs:date" default="2023-10-11" />
Le format de date est standardisé selon la norme ISO 8601 (année-mois-jour), ce qui facilite le
classement des dates.
L'attribut `fixed` dans un schéma XML impose une valeur unique à l'attribut déclaré. Lorsque
`fixed` est renseigné, l'attribut ne peut prendre que la valeur spécifiée. Cet attribut est utile pour
« réserver » des noms d'attributs pour une utilisation future lors d'une mise à jour du schéma.

b. Comparaison entre le format DTD et le XML Schema

DTD Attribut use Attribut default Attribut fixed Commentaire

CDATA
required
#REQUIRED
CDATA
valeur
"valeur"
CDATA
#IMPLIED
CDATA
L'attribut default est
#FIXED valeur
interdit.
"valeur"
Il est important de noter que la valeur de l'attribut `default` doit être conforme au type déclaré.
Par exemple, si le type est une date, la valeur par défaut doit suivre le format de date approprié.
Si ce n'est pas le cas, cela entraînera une erreur lors de la validation du schéma.
1. <xs:attribute name="maj" type="xs:date" use="optional" default="-43" />
Un tel schema provoquera une erreur de validation du document.

c. Restriction de type

On peut appliquer une dérivation aussi bien à un type simple qu'à un type complexe. La
dérivation par restriction permet de créer de nouveaux types simples à partir des types simples
prédéfinis par le format XML Schema. On utilise pour ce faire des facettes, qui sont des
contraintes supplémentaires appliquées à un type simple particulier.
Une facette permet de placer une contrainte sur l'ensemble des valeurs que peut prendre un type
de base. Par exemple, on peut souhaiter créer un type simple, appelé MonEntier, limité aux
valeurs comprises entre 0 et 99 inclus. On dérive ce type à partir du type simple prédéfini
nonNegativeInteger, en utilisant la facette maxExclusive.
1. <xs:simpleType name="monEntier">
2. <xs:restriction base="nonNegativeInteger">
3. <xs:maxExclusive value="100" />
4. </xs:restriction>
5. </xs:simpleType>
Il existe un nombre important de facettes qui permettent de :
• Fixer, restreindre ou augmenter la longueur minimale ou maximale d'un type simple
• Énumérer toutes les valeurs possibles d'un type
• Prendre en compte des expressions rationnelles
• Fixer la valeur minimale ou maximale d'un type (voir l'exemple ci-dessus)
• Fixer la précision du type…
On peut utiliser cette fonctionnalité pour reproduire ce qui, dans les DTD, permettait de limiter
les valeurs de certains attributs.
1. <xs:attribute name="jour" type="typeJourSemaine" use="required" />
2. <xs:simpleType name="typeJourSemaine">
3. <xs:restriction base="xs:string">
4. <xs:enumeration value="lundi" />
5. <xs:enumeration value="mardi" />
6. <xs:enumeration value="mercredi" />
7. <xs:enumeration value="jeudi" />
8. <xs:enumeration value="vendredi" />
9. <xs:enumeration value="samedi" />
10. <xs:enumeration value="dimanche" />
11. </xs:restriction>
12. </xs:simpleType>