🧩 Cours Complet et Illustré : XML Schema (XSD)

Formation complète avec mini-projets pratiques

📑 Table des matières

1️⃣ Introduction à XML Schema (XSD)
2️⃣ Structure d'un schéma XSD
3️⃣ Les types simples
4️⃣ Les contraintes sur les types simples (facettes)
5️⃣ Les types complexes
6️⃣ Les attributs
7️⃣ Namespaces (espaces de noms)
8️⃣ Validation pratique
9️⃣ Exercices de base
🔟 minOccurs et maxOccurs
1️⃣1️⃣ Import et Include de schémas
1️⃣2️⃣ Extension et restriction de types
1️⃣3️⃣ Éléments flexibles (xs:any)
1️⃣4️⃣ Outils de validation
🎯 MINI-PROJETS PRATIQUES
📚 Annexe et Ressources

1️⃣ Introduction à XML Schema (XSD)

📘 Définition
XML Schema Definition (XSD) est un langage basé sur XML servant à décrire la structure et le contenu d'un document XML. Il joue le
même rôle qu'une DTD, mais avec beaucoup plus de puissance et de précision.

🎯 Objectifs
Garantir qu'un document XML respecte une structure prédéfinie
Vérifier les types de données (entiers, dates, booléens…)
Définir des contraintes de valeur (longueur, format, plage numérique…)
Gérer les espaces de noms pour combiner plusieurs schémas

🧩 Exemple concret : Validation d'un XML simple

[Link]

<personne>
<nom>Dupont</nom>
<prenom>Paul</prenom>
</personne>

[Link]

<?xml version="1.0" encoding="UTF-8"?>

<xs:schema xmlns:xs="[Link]
<xs:element name="personne">
<xs:complexType>
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="prenom" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

✅ Validation réussie si :
Il contient un élément racine <personne>
Et cet élément contient exactement deux sous-éléments : <nom> et <prenom>

2️⃣ Structure d'un schéma XSD

Tout schéma commence par :

<xs:schema xmlns:xs="[Link]

xmlns:xs indique l'espace de noms du langage XML Schema

L'élément racine du schéma est toujours <xs:schema>

Exemple minimal

<xs:schema xmlns:xs="[Link]
<xs:element name="message" type="xs:string"/>
</xs:schema>

➡️ Le document XML ne peut contenir qu'un seul élément racine <message> avec une valeur texte.
Exemple XML associé

<message>Bonjour le monde</message>

✅ Valide
❌ Non valide : <message><texte>Bonjour</texte></message>

3️⃣ Les types simples

Un type simple correspond à une donnée textuelle (pas de sous-éléments).

Type Description Exemple

xs:string Texte libre <nom>Paul</nom>

xs:integer Entier <age>25</age>

xs:decimal Décimal <prix>19.99</prix>

xs:boolean Booléen <actif>true</actif>

xs:date Date ISO <naissance>1998-07-23</naissance>

Exemple complet

[Link]

<xs:schema xmlns:xs="[Link]
<xs:element name="etudiant">
<xs:complexType>
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="age" type="xs:integer"/>
<xs:element name="inscrit" type="xs:boolean"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>

[Link]

<etudiant>
<nom>Sow</nom>
<age>22</age>
<inscrit>true</inscrit>
</etudiant>

4️⃣ Les contraintes sur les types simples (facettes)

Les facettes permettent de limiter la valeur autorisée d'un élément.

a) Limite de longueur

<xs:simpleType name="NomType">
<xs:restriction base="xs:string">
<xs:minLength value="2"/>
<xs:maxLength value="30"/>
</xs:restriction>
</xs:simpleType>

✅ Valide : <nom>Awa</nom>
❌ Non valide : <nom>A</nom> (trop court)
b) Liste de valeurs possibles (énumération)

<xs:simpleType name="SexeType">
<xs:restriction base="xs:string">
<xs:enumeration value="Homme"/>
<xs:enumeration value="Femme"/>
</xs:restriction>
</xs:simpleType>

✅ Valide : <sexe>Femme</sexe>
❌ Non valide : <sexe>Autre</sexe>
c) Contrainte de format (pattern)

<xs:simpleType name="EmailType">
<xs:restriction base="xs:string">
<xs:pattern value="[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,4}"/>
</xs:restriction>
</xs:simpleType>

✅ Valide : <email>test@[Link]</email>
❌ Non valide : <email>[Link]</email>
d) Valeurs numériques bornées

<xs:simpleType name="AgeType">
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>

5️⃣ Les types complexes

Les types complexes contiennent des sous-éléments et/ou des attributs.

a) <xs:sequence> : ordre imposé

<xs:complexType name="PersonneType">
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="prenom" type="xs:string"/>
<xs:element name="age" type="xs:integer" minOccurs="0"/>
</xs:sequence>
</xs:complexType>

✅ Valide :
<personne>
<nom>Diallo</nom>
<prenom>Amadou</prenom>
<age>25</age>
</personne>

❌ Non valide : (ordre incorrect)

<personne>
<prenom>Amadou</prenom>
<nom>Diallo</nom>
</personne>

b) <xs:choice> : choix exclusif

<xs:complexType name="ContactType">
<xs:choice>
<xs:element name="telephone" type="xs:string"/>
<xs:element name="email" type="xs:string"/>
</xs:choice>
</xs:complexType>

✅ Valide : <contact><telephone>77 000 0000</telephone></contact>

❌ Non valide : Les deux éléments présents (un seul choix autorisé)
c) <xs:all> : tous les éléments présents, ordre libre

<xs:complexType name="AdresseType">
<xs:all>
<xs:element name="rue" type="xs:string"/>
<xs:element name="ville" type="xs:string"/>
<xs:element name="codePostal" type="xs:string"/>
</xs:all>
</xs:complexType>

📌 Note importante : Avec <xs:all> , tous les éléments doivent être présents mais peuvent apparaître dans n'importe quel ordre.
Limitation : on ne peut pas utiliser maxOccurs > 1 dans un <xs:all> .

6️⃣ Les attributs

Les attributs sont définis dans une complexType avec <xs:attribute> .

<xs:complexType name="LivreType">
<xs:sequence>
<xs:element name="titre" type="xs:string"/>
<xs:element name="auteur" type="xs:string"/>
</xs:sequence>
<xs:attribute name="lang" type="xs:string" use="required"/>
</xs:complexType>

XML valide :

<livre lang="fr">
<titre>Les Misérables</titre>
<auteur>Victor Hugo</auteur>
</livre>

Valeurs de l'attribut use :

use="required" : attribut obligatoire

use="optional" : attribut optionnel (par défaut)
use="prohibited" : attribut interdit

7️⃣ Namespaces (espaces de noms)

Les namespaces évitent les collisions de noms entre schémas différents.

Définition d'un namespace

<xs:schema
xmlns:xs="[Link]
xmlns:pers="[Link]
targetNamespace="[Link]
elementFormDefault="qualified">

<xs:element name="personne" type="pers:PersonneType"/>

<xs:complexType name="PersonneType">
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="prenom" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:schema>

Utilisation dans le XML

<pers:personne xmlns:pers="[Link]
<pers:nom>Diop</pers:nom>
<pers:prenom>Aminata</pers:prenom>
</pers:personne>

📌 Attributs importants :
targetNamespace : définit l'espace de noms du schéma
elementFormDefault="qualified" : tous les éléments doivent utiliser le préfixe
elementFormDefault="unqualified" : seul l'élément racine nécessite le préfixe

8️⃣ Validation pratique

Lier un XML à son schéma

<personne xmlns:xsi="[Link]
xsi:noNamespaceSchemaLocation="[Link]">
<nom>Diop</nom>
<prenom>Aminata</prenom>
<age>28</age>
</personne>

Attributs de validation :

xmlns:xsi : déclare l'espace de noms pour XML Schema Instance

xsi:noNamespaceSchemaLocation : chemin vers le fichier XSD (sans namespace)
xsi:schemaLocation : pour les schémas avec namespace

9️⃣ Exercices de base

🧠 Exercice 1 : Livre
Facile

Créer un schéma [Link] décrivant un livre avec :

titre (string, obligatoire)

auteur (string)
prix (decimal, min 0)
un attribut lang obligatoire

🧠 Exercice 2 : Étudiant
Facile

Créer un schéma [Link] contenant :

nom, prenom, dateNaissance, filiere

sexe limité à "H" ou "F"
email validé par un pattern

🧠 Exercice 3 : Commande
Moyen

Créer un schéma [Link] où :

une commande contient un ou plusieurs produits

chaque produit a un nom, quantite, et prix
l'élément racine a un attribut date de type xs:date

🔟 minOccurs et maxOccurs
Ces attributs contrôlent le nombre d'occurrences d'un élément.

Attribut Description Valeur par défaut

minOccurs Nombre minimum d'occurrences 1

maxOccurs Nombre maximum d'occurrences 1

Exemples pratiques

1. Élément optionnel

<xs:element name="telephone" type="xs:string" minOccurs="0"/>

L'élément peut être absent ou présent une seule fois.

2. Élément répétable

<xs:element name="hobby" type="xs:string" maxOccurs="unbounded"/>

L'élément peut apparaître un nombre illimité de fois.

3. Élément optionnel et répétable

<xs:element name="enfant" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>

L'élément peut être absent ou apparaître plusieurs fois.

4. Plage spécifique

<xs:element name="matiere" type="xs:string" minOccurs="3" maxOccurs="8"/>

Entre 3 et 8 occurrences requises.

Exemple complet : Famille

<xs:element name="famille">
<xs:complexType>
<xs:sequence>
<xs:element name="parent" type="xs:string" minOccurs="1" maxOccurs="2"/>
<xs:element name="enfant" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>

XML valide :

<famille>
<parent>Marie Sow</parent>
<parent>Ibrahima Sow</parent>
<enfant>Fatou</enfant>
<enfant>Moussa</enfant>
<enfant>Aissatou</enfant>
</famille>

1️⃣1️⃣ Import et Include de schémas

a) <xs:include> : même namespace

Permet de diviser un schéma en plusieurs fichiers partageant le même namespace.

[Link]

<xs:schema xmlns:xs="[Link]
targetNamespace="[Link]

<xs:simpleType name="EmailType">
<xs:restriction base="xs:string">
<xs:pattern value="[^@]+@[^@]+\.[^@]+"/>
</xs:restriction>
</xs:simpleType>

</xs:schema>

[Link]

<xs:schema xmlns:xs="[Link]
targetNamespace="[Link]

<xs:include schemaLocation="[Link]"/>

<xs:element name="personne">
<xs:complexType>
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="email" type="EmailType"/>
</xs:sequence>
</xs:complexType>
</xs:element>

</xs:schema>

b) <xs:import> : namespaces différents

Permet d'utiliser des types définis dans un autre namespace.

[Link]

<xs:schema xmlns:xs="[Link]
targetNamespace="[Link]

<xs:complexType name="AdresseType">
<xs:sequence>
<xs:element name="rue" type="xs:string"/>
<xs:element name="ville" type="xs:string"/>
<xs:element name="codePostal" type="xs:string"/>
</xs:sequence>
</xs:complexType>

</xs:schema>

[Link]

<xs:schema xmlns:xs="[Link]
xmlns:adr="[Link]
targetNamespace="[Link]

<xs:import namespace="[Link]
schemaLocation="[Link]"/>

<xs:element name="entreprise">
<xs:complexType>
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="siege" type="adr:AdresseType"/>
</xs:sequence>
</xs:complexType>
</xs:element>

</xs:schema>

1️⃣2️⃣ Extension et restriction de types

a) Extension (<xs:extension>)

Permet d'ajouter des éléments ou attributs à un type existant.

<xs:complexType name="PersonneType">
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="prenom" type="xs:string"/>
</xs:sequence>
</xs:complexType>

<xs:complexType name="EmployeType">
<xs:complexContent>
<xs:extension base="PersonneType">
<xs:sequence>
<xs:element name="matricule" type="xs:string"/>
<xs:element name="poste" type="xs:string"/>
<xs:element name="salaire" type="xs:decimal"/>
</xs:sequence>
</xs:extension>
</xs:complexContent>
</xs:complexType>

XML valide :

<employe>
<nom>Ba</nom>
<prenom>Mamadou</prenom>
<matricule>EMP001</matricule>
<poste>Développeur</poste>
<salaire>450000</salaire>
</employe>

b) Restriction (<xs:restriction>)

Permet de restreindre un type existant.

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

<xs:simpleType name="CodePostalDakar">
<xs:restriction base="CodePostalSenegal">
<xs:pattern value="1[0-9]{4}"/>
</xs:restriction>
</xs:simpleType>

1️⃣3️⃣ Éléments flexibles (xs:any)

<xs:any> permet d'accepter n'importe quel élément à un emplacement donné.

Exemple : Métadonnées extensibles

<xs:element name="document">
<xs:complexType>
<xs:sequence>
<xs:element name="titre" type="xs:string"/>
<xs:element name="auteur" type="xs:string"/>
<xs:any minOccurs="0" maxOccurs="unbounded" processContents="lax"/>
</xs:sequence>
</xs:complexType>
</xs:element>

XML valide avec éléments personnalisés :

<document>
<titre>Rapport annuel</titre>
<auteur>Fatou Diagne</auteur>
<metadonnee1>Valeur personnalisée</metadonnee1>
<tags>finance, 2025</tags>
</document>

Attribut processContents :

strict : les éléments doivent être validés par un schéma

lax : validation si un schéma est trouvé, sinon ignoré
skip : aucune validation

xs:anyAttribute

Similaire à xs:any mais pour les attributs.

<xs:complexType name="ElementFlexible">
<xs:sequence>
<xs:element name="contenu" type="xs:string"/>
</xs:sequence>
<xs:anyAttribute processContents="lax"/>
</xs:complexType>

1️⃣4️⃣ Outils de validation

🔧 Outils en ligne de commande
1. xmllint (Linux/Mac)

xmllint --noout --schema [Link] [Link]

2. xmlstarlet

xmlstarlet val -e -s [Link] [Link]

🌐 Outils en ligne
[Link] : [Link]
Code Beautify : [Link]
XML Grid : [Link]

💻 Éditeurs recommandés
VS Code avec extension "XML Tools"
Oxygen XML Editor (professionnel)
Notepad++ avec plugin XML Tools
IntelliJ IDEA / PyCharm (validation intégrée)

🐍 Validation avec Python

from lxml import etree

# Charger le schéma
schema_doc = [Link]("[Link]")
schema = [Link](schema_doc)

# Valider le XML
xml_doc = [Link]("[Link]")
is_valid = [Link](xml_doc)

if is_valid:
print("✅ Document valide")
else:
print("❌ Document invalide")
print(schema.error_log)

🎯 MINI-PROJETS PRATIQUES
📚 Projet 1 : Gestion de Bibliothèque Universitaire
Difficulté : Moyenne Durée : 2-3h

📋 Cahier des charges

Créer un système XML/XSD pour gérer une bibliothèque universitaire avec les fonctionnalités suivantes :

Exigences fonctionnelles :

1. Catalogue de livres
ISBN (format : XXX-X-XXXX-XXXX-X)
Titre (3 à 200 caractères)
Auteur(s) (1 à 5 auteurs maximum)
Éditeur
Année de publication (entre 1500 et année courante)
Catégorie : Informatique, Mathématiques, Physique, Littérature, Histoire
Nombre d'exemplaires disponibles (0 à 100)
Attribut langue (fr, en, ar)
2. Gestion des emprunts
Numéro d'emprunt (format : EMP-XXXXXX)
ISBN du livre emprunté
Matricule étudiant (format : ETU-XXXXX)
Date d'emprunt (xs:date)
Date de retour prévue (xs:date)
Statut : EnCours, Retourné, EnRetard
3. Étudiants
Matricule (format : ETU-XXXXX)
Nom et prénom (2-50 caractères)
Email (validation pattern)
Filière
Niveau : L1, L2, L3, M1, M2

📝 Fichiers à créer
1. [Link] - Schéma principal
2. [Link] - Types réutilisables (ISBN, Email, etc.)
3. [Link] - 5 livres minimum
4. [Link] - 3 emprunts minimum
5. [Link] - 4 étudiants minimum

🎓 Compétences évaluées
Types simples avec restrictions
Patterns (regex)
Énumérations
minOccurs / maxOccurs
Include de schémas
Attributs obligatoires

💡 Conseils
Commencez par définir les types simples réutilisables
Testez la validation après chaque ajout
Utilisez des données réalistes (noms sénégalais, livres réels)

🏆 Bonus (optionnel)
Ajouter une gestion des amendes pour retards
Créer un historique complet des emprunts par étudiant
Implémenter des réservations de livres

🛒 Projet 2 : Système de Commandes E-commerce

Difficulté : Moyenne Durée : 2-3h

📋 Description
Développer un système XML/XSD pour une boutique en ligne vendant des produits électroniques.

Structure du système :

1. Produits
Référence produit (format : PROD-XXXXX)
Nom (5-100 caractères)
Description (optionnelle, max 500 caractères)
Prix en FCFA (decimal, min 100, max 10000000)
Stock disponible (integer, 0-1000)
Catégorie : Smartphone, Ordinateur, Tablette, Accessoire
Marque
Attribut promo (booléen)
Attribut nouveaute (booléen)
2. Clients
ID Client (format : CLI-XXXXXX)
Nom complet
Email (validation)
Téléphone (format : +221 XX XXX XX XX)
Adresse (rue, ville, quartier, code postal optionnel)
Type : Particulier, Entreprise
3. Commandes
Numéro commande (format : CMD-YYYYMMDD-XXXX)
ID Client
Date commande (xs:dateTime)
Liste de lignes de commande (1 à 20 produits)
Référence produit
Quantité (1-10)
Prix unitaire
Mode de paiement : CarteBancaire, MobileMoney, Especes
Statut : EnAttente, Validee, Expedie, Livree, Annulee
Adresse de livraison (peut être différente)
Frais de livraison (decimal)
Total (calculé automatiquement si possible)

📝 Livrables
1. [Link] - Schéma principal avec imports
2. [Link] - Schéma des produits
3. [Link] - Schéma des clients
4. [Link] - Schéma des commandes
5. [Link] - 10 produits
6. [Link] - 5 clients
7. [Link] - 3 commandes complètes

🎓 Compétences évaluées
Import de schémas multiples
Namespaces différents
Types complexes imbriqués
Contraintes de valeurs
Patterns avancés (téléphone, références)
Extension de types

🏆 Bonus
Ajouter un système d'évaluation des produits (1-5 étoiles)
Gérer les codes promo avec validation
Créer un schéma pour les factures

🏥 Projet 3 : Dossier Médical Électronique

Difficulté : Avancée Durée : 4-5h

📋 Contexte
Concevoir un système XML/XSD pour la gestion des dossiers médicaux dans un hôpital.

Composants du système :

1. Patients
Numéro patient (format : PAT-XXXXXXXX)
État civil (nom, prénom, date de naissance, sexe)
CNI ou passeport
Groupe sanguin : A+, A-, B+, B-, AB+, AB-, O+, O-
Personne à contacter en cas d'urgence
Nom, relation, téléphone
Allergies connues (0 à plusieurs, optionnel)
Maladies chroniques (0 à plusieurs)
2. Personnel médical
Matricule (format : MED-XXXXX pour médecins, INF-XXXXX pour infirmiers)
Nom complet
Spécialité (pour médecins) : Généraliste, Cardiologue, Pédiatre, Chirurgien, etc.
Service
Téléphone professionnel
3. Consultations
ID consultation (format : CONS-YYYYMMDD-XXXX)
Date et heure (xs:dateTime)
Numéro patient
Matricule médecin
Motif de consultation
Symptômes (1 à 10)
Diagnostic
Prescriptions (0 à plusieurs)
Nom médicament
Dosage
Posologie
Durée traitement (en jours)
Examens demandés (optionnel)
Prochain rendez-vous (optionnel)
4. Examens médicaux
ID examen (format : EXAM-XXXXXXXX)
Type : Analyse de sang, Radiographie, IRM, Scanner, Échographie
Date réalisation
Numéro patient
Résultats (texte libre ou valeurs structurées)
Commentaires technicien
Urgent (booléen)
5. Hospitalisations
Numéro d'admission
Numéro patient
Date admission (xs:dateTime)
Date sortie prévue/effective (optionnelle)
Service/Chambre
Médecin responsable
Motif hospitalisation
Notes quotidiennes (0 à plusieurs)

📝 Livrables attendus
1. [Link] - Schéma principal
2. [Link] - Types liés aux patients
3. [Link] - Types du personnel médical
4. [Link] - Consultations, examens, hospitalisations
5. [Link] - Types communs (groupe sanguin, spécialités, etc.)
6. [Link] - 5 patients
7. [Link] - 4 consultations avec prescriptions
8. [Link] - 3 examens
9. [Link] - 2 hospitalisations

🎓 Compétences évaluées
Architecture multi-schémas complexe
Import/Include avancés
Namespaces multiples
Types dérivés (extension/restriction)
Contraintes métier complexes
Éléments optionnels et répétables
Validation de formats médicaux

⚠️ Contraintes importantes
Respecter la confidentialité : pas de vraies données personnelles
Assurer la cohérence des dates (admission avant sortie)
Valider les formats professionnels (matricules, références)

🏆 Bonus avancés
Ajouter un système de rendez-vous
Gérer les antécédents médicaux familiaux
Créer un schéma pour les opérations chirurgicales
Implémenter un suivi des vaccinations

🎓 Projet 4 : Système de Gestion Scolaire

Difficulté : Facile Durée : 1-2h

📋 Description
Créer un système simple pour gérer les notes et bulletins d'un établissement scolaire.

Éléments du système :

1. Élèves
Matricule (format : ELEVE-XXXX)
Nom et prénom
Date de naissance
Classe : 6ème, 5ème, 4ème, 3ème, 2nde, 1ère, Terminale
Sexe : M, F
2. Matières
Code matière (format : MAT-XXX)
Nom : Mathématiques, Français, Anglais, SVT, Physique-Chimie, Histoire-Géo, EPS
Coefficient (1 à 5)
Professeur
3. Notes
Matricule élève
Code matière
Trimestre : 1, 2, 3
Note (decimal, 0 à 20)
Type : Devoir, Interrogation, Examen
Date
Appréciation (optionnelle)
4. Bulletin
Matricule élève
Trimestre
Année scolaire (format : 2024-2025)
Moyennes par matière
Moyenne générale
Rang dans la classe
Appréciation générale
Décision : Admis, Ajourné, Redouble

📝 Fichiers à produire
1. [Link]
2. [Link] - 6 élèves
3. [Link] - 7 matières
4. [Link] - 15 notes minimum
5. [Link] - 2 bulletins complets

🎓 Compétences évaluées
Types simples avec énumérations
Contraintes de valeurs (notes entre 0 et 20)
Formats de dates
Relations entre entités

💡 Idées d'amélioration
Ajouter les absences et retards
Gérer les parents/tuteurs avec contacts
Créer un calendrier des évaluations

📚 Annexe : Ressources complémentaires

📖 Documentation officielle
W3C XML Schema : [Link]
W3Schools XSD Tutorial : [Link]
XML Schema Primer : [Link]

🎥 Tutoriels vidéo recommandés

YouTube : "XML Schema Tutorial" par tutorialspoint
Cours OpenClassrooms : "Structurez vos données avec XML"

📝 Antisèches (Cheat Sheets)

Types de données courants

Type Utilisation Exemple

xs:string Texte "Bonjour"

xs:integer Entier 42

xs:decimal Décimal 19.99

xs:boolean Booléen true/false

xs:date Date 2025-10-08

xs:time Heure [Link]

xs:dateTime Date et heure 2025-10-08T[Link]

Facettes principales

Facette Description

minLength / maxLength Longueur minimale/maximale

length Longueur exacte

pattern Expression régulière

enumeration Liste de valeurs autorisées

minInclusive / maxInclusive Valeur min/max (incluse)

minExclusive / maxExclusive Valeur min/max (exclue)

🔍 Patterns utiles
Cas d'usage Pattern

Email [a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,4}

Téléphone SN \+221 [37][0-9] [0-9]{3} [0-9]{2} [0-9]{2}

Code postal [0-9]{5}

URL https?://[^\s]+

Date (JJ/MM/AAAA) [0-3][0-9]/[0-1][0-9]/[0-9]{4}

✅ Checklist de validation
Avant de soumettre votre projet :

☐ Tous les fichiers XSD sont bien formés

☐ Les namespaces sont correctement définis
☐ Chaque fichier XML valide contre son schéma
☐ Les patterns fonctionnent avec les données test
☐ Les contraintes métier sont respectées
☐ La documentation est complète
☐ Les noms de fichiers respectent les conventions

💬 Glossaire
Terme Définition

XSD XML Schema Definition - langage de définition de schéma XML

Facette Contrainte appliquée à un type simple

Namespace Espace de noms permettant d'éviter les collisions

Type complexe Type contenant des éléments enfants ou attributs

Type simple Type contenant uniquement du texte

Cardinalité Nombre d'occurrences autorisées (minOccurs/maxOccurs)

🚀 Concepts avancés non couverts (pour aller plus loin)

⚠️ Avertissement : Ce cours couvre les fondamentaux (70-75% des cas d'usage). Voici les concepts avancés qui ne sont PAS traités
dans ce document :

1️⃣ Concepts XSD avancés omis

a) Groupes (xs:group)

Permet de réutiliser des ensembles d'éléments.

<xs:group name="AdresseGroup">
<xs:sequence>
<xs:element name="rue" type="xs:string"/>
<xs:element name="ville" type="xs:string"/>
</xs:sequence>
</xs:group>

<xs:element name="client">
<xs:complexType>
<xs:group ref="AdresseGroup"/>
</xs:complexType>
</xs:element>

b) Groupes d'attributs (xs:attributeGroup)

<xs:attributeGroup name="AttributsCommuns">
<xs:attribute name="id" type="xs:ID" use="required"/>
<xs:attribute name="version" type="xs:string"/>
</xs:attributeGroup>

c) Substitution d'éléments

Permet de remplacer un élément par un autre compatible.

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

<xs:element name="chien" substitutionGroup="animal"/>
<xs:element name="chat" substitutionGroup="animal"/>

d) Types abstraits

<xs:complexType name="VehiculeType" abstract="true">

<xs:sequence>
<xs:element name="marque" type="xs:string"/>
</xs:sequence>
</xs:complexType>

e) Clés et références (xs:key, xs:keyref, xs:unique)

Équivalent des clés primaires et étrangères en base de données.

<xs:key name="studentKey">
<xs:selector xpath="students/student"/>
<xs:field xpath="@id"/>
</xs:key>

<xs:keyref name="enrollmentKeyref" refer="studentKey">

<xs:selector xpath="enrollments/enrollment"/>
<xs:field xpath="@studentId"/>
</xs:keyref>

f) Assertions (XSD 1.1)

<xs:complexType name="PersonneType">
<xs:sequence>
<xs:element name="age" type="xs:integer"/>
<xs:element name="permis" type="xs:boolean"/>
</xs:sequence>
<xs:assert test="if (age < 18) then not(permis) else true()"/>
</xs:complexType>

g) Types d'union (xs:union)

<xs:simpleType name="CodeOuNom">
<xs:union memberTypes="xs:integer xs:string"/>
</xs:simpleType>

h) Types de liste (xs:list)

<xs:simpleType name="ListeNombres">
<xs:list itemType="xs:integer"/>
</xs:simpleType>
<!-- XML: <nombres>1 5 10 42</nombres> -->

i) Notation et Entities

Pour gérer des références externes et formats non-XML.

j) Redéfinition (xs:redefine)

Modifier un schéma existant en le redéfinissant (déprécié en XSD 1.1, remplacé par xs:override).

k) XSD 1.1 spécifiques

xs:alternative - types conditionnels

xs:override - remplace redefine
xs:openContent - contenu extensible
Expressions XPath 2.0 dans les assertions

2️⃣ Bonnes pratiques omises

🏗️ Architecture en couches : schémas de base, métier, présentation
📦 Versionning : gérer l'évolution des schémas
🔒 Sécurité : éviter les attaques XXE (XML External Entity)
⚡ Performance : optimisation de la validation
📝 Documentation : annotations avec xs:annotation, xs:documentation
🔄 Interopérabilité : compatibilité entre parseurs
🧪 Tests : stratégies de test des schémas
3️⃣ Outils professionnels non mentionnés
Altova XMLSpy - IDE professionnel pour XML/XSD
Oxygen XML Editor - éditeur avancé
Xerces - parseur XML robuste
Saxon - processeur XSLT/XQuery/XSD
XJC - génération de classes Java depuis XSD (JAXB)
[Link] - génération de classes C# depuis XSD

4️⃣ Cas d'usage spécialisés

🌐 Web Services (SOAP) : WSDL utilise XSD
📄 Office Open XML : formats .docx, .xlsx utilisent XSD
🏦 Finance : FpML, XBRL basés sur XSD
📊 Échanges B2B : EDI XML avec schémas complexes
🏛️ Archives : TEI (Text Encoding Initiative) pour textes littéraires
5️⃣ Standards connexes
Schematron - validation complémentaire basée sur règles
RelaxNG - alternative à XSD, plus simple
XSLT - transformation de documents XML
XPath/XQuery - requêtes sur documents XML

🤔 Faut-il passer à JSON et YAML maintenant ?

✅ OUI, vous pouvez passer à JSON/YAML si :
Vous comprenez les concepts de base de XML, DTD et XSD
Vous savez créer un schéma XSD simple avec types et contraintes
Vous comprenez les namespaces et la validation
Votre objectif est d'avoir une culture générale sur les formats de données
Vous travaillez sur des APIs REST modernes (où JSON domine)
Vous faites du DevOps (où YAML est omniprésent)

📊 Comparaison rapide : Quand utiliser quoi ?

Format Cas d'usage principal Complexité Popularité 2025

XML + XSD Systèmes legacy, B2B, documents structurés, SOAP 🔴 Élevée 📉 En déclin
JSON + JSON Schema APIs REST, web moderne, NoSQL, JavaScript 🟢 Faible 📈 Dominante
YAML Config (Docker, K8s, CI/CD), Ansible 🟡 Moyenne 🚀 En croissance
🎯 Recommandation personnalisée selon votre profil
👨‍💻 Si vous êtes développeur web moderne
✅ PASSEZ à JSON/YAML immédiatement
Le niveau actuel de XSD est largement suffisant
JSON est 10x plus utilisé que XML en 2025
YAML est indispensable pour DevOps
Vous pourrez toujours revenir à XSD si besoin

🏦 Si vous êtes en finance/assurance/administration

⚠️ Approfondissez XSD avant de partir
Ces secteurs utilisent massivement XML/XSD
Étudiez au moins les clés/références (xs:key, xs:keyref)
Comprenez les groupes et la réutilisation
Puis passez à JSON pour la modernisation

🎓 Si vous êtes étudiant

📚 Vision équilibrée recommandée
Le cours actuel donne une base solide pour les examens
Faites 2-3 mini-projets pour consolider
Passez à JSON/YAML pour avoir une vision complète
XML + DTD + XSD + JSON + YAML = profil complet en structuration de données

📋 Plan d'apprentissage suggéré

Semaine 1-2 : XML Schema (ce document)

✅ Lire et comprendre le cours

✅ Réaliser 2 mini-projets (Bibliothèque + E-commerce)
✅ Pratiquer la validation
Semaine 3 : JSON

📦 Syntaxe JSON
📦 JSON Schema (équivalent de XSD)
📦 Manipulation avec JavaScript/Python
📦 APIs REST
Semaine 4 : YAML

📦 Syntaxe YAML
📦 Différences avec JSON
📦 Cas d'usage DevOps (Docker Compose, Kubernetes, GitLab CI)
📦 Bonnes pratiques
Semaine 5 : Projet intégrateur

🎯 API REST avec JSON

🎯 Configuration en YAML
🎯 Import de données depuis XML
🎯 Comparaison des 3 formats

💡 Réponse finale à votre question

🎯 OUI, vous pouvez passer à JSON et YAML maintenant !
Le document actuel couvre l'essentiel de XSD pour 90% des cas pratiques. Les concepts avancés listés ci-dessus sont
utiles seulement dans des contextes très spécialisés.

Conseil : Faites 1-2 mini-projets du document pour consolider, puis passez à JSON/YAML. Vous reviendrez à XSD plus
tard si votre travail le nécessite.

🎓 Bonne chance dans vos projets !

Document créé pour la formation XML Schema (XSD)
Version 2.0 - Octobre 2025 - Complété avec concepts avancés et recommandations