XML signifie eXtensible Markup Language (Langage de Balisage Extensible). Il a été créé en 1998 par le W3C (World Wide Web Consortium) comme standard universel pour représenter des données de façon structurée, lisible par l'humain et par les machines.
Contrairement au HTML qui se concentre sur l'affichage des données, XML se concentre sur leur signification et leur transport. XML ne fait rien tout seul : c'est un conteneur neutre qui permet à deux systèmes différents de s'échanger des informations sans se soucier du langage, du système d'exploitation ou de la plateforme utilisés.
XML est dit extensible parce que vous inventez vous-même vos propres balises selon vos besoins — il n'existe pas de liste figée de balises prédéfinies (sauf dans les sous-formats basés sur XML comme HTML, SVG, etc.).
<nom>Ali</nom>
<personne> <nom>Ali</nom> <ville>Dakar</ville> <age>28</age> </personne>
La déclaration XML est la toute première ligne d'un fichier XML bien formé. Elle commence par <?xml et se termine par ?>. Cette ligne n'est pas un élément XML ordinaire — c'est une instruction de traitement destinée au parseur.
Elle contient généralement deux informations importantes :
— version : indique quelle version de la spécification XML est utilisée. Aujourd'hui on utilise presque toujours "1.0". XML 1.1 existe mais est rarement utilisé.
— encoding : indique l'encodage des caractères du fichier. UTF-8 est le standard universel et est recommandé car il supporte tous les caractères du monde (accents, caractères arabes, chinois, emoji, etc.).
<?xml version="1.0" encoding="UTF-8"?> <message>Bonjour le monde !</message>
Les balises (ou tags) sont les marqueurs fondamentaux de XML. Elles délimitent les données et leur donnent un nom, donc une signification. Une balise s'écrit entre chevrons < et >.
Il existe deux types de balises :
— La balise ouvrante : <ville> — elle marque le début de l'élément.
— La balise fermante : </ville> — elle marque la fin. Elle est identique à la balise ouvrante mais avec un slash / avant le nom.
Le nom de la balise peut contenir des lettres, des chiffres, des tirets, des underscores et des points. Il doit commencer par une lettre ou un underscore, jamais par un chiffre ni un tiret.
<nom-client>, <_id>, <adresse2> sont valides. <2adresse> ou <-item> ne le sont pas.<ville>Dakar</ville> <code-postal>10000</code-postal> <pays_iso>SN</pays_iso>
Chaque document XML doit avoir exactement un seul élément racine (root element) qui englobe tous les autres éléments. Si vous imaginez votre document XML comme un arbre, la racine est le tronc : tout le reste en découle.
Cette règle est absolue. Un document XML avec plusieurs éléments de premier niveau n'est pas bien formé et un parseur strict refusera de le traiter.
<user>…</user> suivi directement de <produit>…</produit> au même niveau n'est pas valide.<user>Ali</user> <produit>Laptop</produit>
<data> <user>Ali</user> <produit>Laptop</produit> </data>
Un élément XML est l'unité de base du document. Il est composé d'une balise ouvrante, d'un contenu, et d'une balise fermante. Le contenu peut être du texte brut, d'autres éléments imbriqués, ou les deux (contenu mixte).
Les éléments structurent vos données de façon hiérarchique. Chaque élément a un nom (le nom de la balise) et une valeur (ce qu'il contient). Ils peuvent aussi porter des attributs (voir leçon 6).
Un élément vide (sans contenu) peut s'écrire soit <tag></tag> soit en version auto-fermante <tag/>.
<!-- Contenu textuel --> <age>20</age> <prix>29.99</prix> <!-- Contenu mixte : texte + sous-éléments --> <description> Ce produit contient <marque>Samsung</marque> </description> <!-- Élément vide --> <separateur/>
Les attributs permettent d'ajouter des métadonnées ou des propriétés supplémentaires à un élément, directement dans sa balise ouvrante. Ils se présentent sous la forme nom="valeur".
Un élément peut avoir plusieurs attributs, séparés par des espaces. L'ordre des attributs n'a pas d'importance pour XML. La valeur d'un attribut doit toujours être entre guillemets (doubles " ou simples ').
Attributs vs éléments enfants : un attribut convient bien aux données courtes et non répétables (un identifiant, une date, un statut). Les données complexes ou répétables sont mieux représentées par des éléments enfants.
<user id="1" role="admin" actif="true"> <nom>Ali</nom> <email>ali@mail.com</email> </user> <produit ref="SKU-42" categorie="electronique"> <nom>Laptop</nom> <prix devise="XOF">350000</prix> </produit>
Les commentaires permettent d'annoter un document XML avec des notes lisibles par les développeurs, mais ignorées par le parseur XML. Ils commencent par <!-- et se terminent par -->.
Les commentaires peuvent s'étendre sur plusieurs lignes et contenir n'importe quel texte, sauf la séquence -- (deux tirets consécutifs) à l'intérieur, car elle marquerait la fin du commentaire de façon ambiguë.
On les utilise pour documenter la structure du fichier, expliquer des choix techniques, ou temporairement désactiver une partie du contenu XML lors de tests.
<tag <!-- attr --> id="1"> est interdit. Ils doivent être entre les éléments ou autour d'eux.<?xml version="1.0" encoding="UTF-8"?>
<!-- Fichier de configuration principale
Mis à jour le : 2025-01-01
Auteur : Équipe tech -->
<config>
<!-- URL du serveur de production -->
<serveur>https://api.exemple.com</serveur>
<!-- <debug>true</debug> désactivé en prod -->
<debug>false</debug>
</config>
L'imbrication consiste à placer des éléments XML à l'intérieur d'autres éléments. C'est le mécanisme fondamental qui permet de représenter des données hiérarchiques et des relations complexes entre informations.
La règle d'imbrication est stricte : les balises doivent être correctement fermées dans l'ordre inverse de leur ouverture. Si vous ouvrez A puis B, vous devez fermer B avant de fermer A. On dit que les éléments doivent être correctement emboîtés (bien formés).
<a><b></a></b> est une erreur fatale. Les éléments ne peuvent pas se chevaucher, contrairement à du HTML tolérant.<a><b>texte</a></b>
<entreprise>
<departement nom="Ingénierie">
<employe>
<nom>Fatou</nom>
<poste>Développeuse</poste>
</employe>
<employe>
<nom>Mamadou</nom>
<poste>Architecte</poste>
</employe>
</departement>
</entreprise>
Un document XML est dit bien formé (well-formed) lorsqu'il respecte toutes les règles syntaxiques définies par la spécification XML. C'est la condition minimale pour qu'un parseur XML accepte de le traiter.
Les principales règles d'un XML bien formé :
1. Il possède une seule balise racine.
2. Toutes les balises ouvrantes ont une balise fermante correspondante.
3. Les balises sont correctement imbriquées, sans chevauchement.
4. Les noms de balises sont sensibles à la casse (voir leçon 10).
5. Les valeurs d'attributs sont entre guillemets.
6. Un attribut ne peut pas apparaître deux fois dans la même balise.
7. Les caractères spéciaux (<, &) sont correctement escapés (voir leçon 14).
<?xml version="1.0" encoding="UTF-8"?> <note priorite="haute"> <de>Directeur</de> <a>Équipe</a> <corps>Réunion lundi à 9h00</corps> </note>
XML est strictement sensible à la casse (case-sensitive). Cela signifie que <Nom>, <NOM>, <nom> et <noM> sont quatre éléments totalement distincts pour un parseur XML.
De même pour les attributs : id, Id et ID sont trois attributs différents. Il est obligatoire que la balise ouvrante et la balise fermante aient exactement la même casse.
La convention la plus répandue est d'utiliser le camelCase (nomClient), le kebab-case (nom-client) ou le snake_case (nom_client) — en tout cas de rester cohérent dans tout le document.
<Nom>Ali</nom> provoque une erreur de parsing car la casse de l'ouverture et de la fermeture ne correspond pas.<contact> <Nom>Ali</Nom> <!-- valide --> <nom>Fatou</nom> <!-- valide, autre élément --> <NOM>Ibra</NOM> <!-- valide, encore un autre --> <!-- ❌ Interdit : casse incohérente --> <!-- <Email>test@mail.com</email> --> </contact>
En XML, chaque balise ouverte doit être fermée, sans exception. C'est l'une des différences majeures avec HTML, où certaines balises comme <br>, <img> ou <input> peuvent rester ouvertes (les navigateurs comblent les oublis).
Un parseur XML est sans tolérance : un seul oubli de fermeture est une erreur fatale qui arrête le traitement. Il n'essaie pas de "deviner" l'intention du développeur.
Pour les éléments sans contenu, vous avez le choix entre la syntaxe longue <tag></tag> et la syntaxe auto-fermante <tag/> — les deux sont strictement équivalentes.
<!-- HTML permissif (navigateur tolère) --> <br> <img src="photo.jpg"> <input type="text"> <!-- XML strict (toutes les balises fermées) --> <separateur/> <image src="photo.jpg"/> <champ type="texte"></champ>
En XML, les valeurs des attributs doivent toujours être entourées de guillemets — soit des guillemets doubles "valeur", soit des guillemets simples 'valeur'. Oublier les guillemets rend le document invalide, contrairement à HTML5 qui parfois l'accepte.
Vous pouvez utiliser les guillemets simples quand la valeur contient elle-même des guillemets doubles, et vice versa. Cela évite de recourir aux entités.
Un attribut ne peut apparaître qu'une seule fois dans une même balise. Écrire <tag id="1" id="2"> est une erreur XML.
<livre id="5" langue="fr" disponible="true"/>
<message texte='Il a dit "Bonjour" hier'/>
<message texte="Il a dit "Bonjour""/>
Une section CDATA (Character DATA) permet d'inclure un bloc de texte brut dans un document XML sans que le parseur l'interprète. Tout ce qui se trouve à l'intérieur est traité comme du texte littéral, y compris les chevrons <, > et les esperluettes &.
La syntaxe est : <![CDATA[ … texte brut … ]]>. C'est particulièrement utile pour intégrer du code HTML, du JavaScript, du SQL ou toute autre données contenant des caractères qui causeraient des erreurs s'ils étaient interprétés comme du XML.
La seule séquence interdite à l'intérieur d'un CDATA est ]]> car elle marquerait la fin de la section.
<article>
<titre>Tutoriel XML</titre>
<corps><![CDATA[
<h1>Bienvenue</h1>
<p>Voici du <strong>HTML</strong>
inséré sans conflit dans XML.</p>
<script>if(a < b && c > 0){};</script>
]]></corps>
</article>
Certains caractères ont une signification spéciale en XML (<, >, &, etc.) et ne peuvent donc pas apparaître tels quels dans du texte ou des valeurs d'attributs. Pour les représenter, on utilise des entités — des codes de substitution commençant par & et finissant par ;.
XML définit cinq entités prédéfinies que tout parseur doit comprendre :
— < → < (less than / inférieur à)
— > → > (greater than / supérieur à)
— & → & (ampersand / esperluette)
— ' → ' (apostrophe / guillemet simple)
— " → " (guillemet double)
Vous pouvez aussi définir vos propres entités personnalisées dans une DTD (voir leçon 25).
<formule>Si a < b && b > 0</formule> <!-- Résultat lu : Si a < b && b > 0 -->
<lien url="https://exemple.com?a=1&b=2"/> <note texte="L'XML est puissant"/>
XML est avant tout un format d'échange de données. Son grand atout est son universalité : un fichier XML produit par un programme Java sur Linux peut être lu par un programme Python sur Windows ou un service PHP dans le cloud — sans aucun problème de compatibilité.
XML est utilisé dans de nombreux contextes réels : services web (SOAP), fichiers de configuration (Maven, Spring, Android), flux de syndication (RSS, Atom), formats de documents (OOXML pour Word/Excel, ODF pour LibreOffice), et bien d'autres.
La clé de son succès est qu'il sépare clairement les données (le XML) de leur traitement (l'application qui les lit). Deux équipes peuvent travailler sur les mêmes données XML avec des technologies entièrement différentes.
<catalogue>
<produit ref="P001" categorie="electronique">
<nom>Smartphone</nom>
<prix devise="XOF">250000</prix>
<stock>42</stock>
<disponible>true</disponible>
</produit>
<produit ref="P002" categorie="accessoire">
<nom>Écouteurs Bluetooth</nom>
<prix devise="XOF">35000</prix>
<stock>150</stock>
<disponible>true</disponible>
</produit>
</catalogue>
XML organise naturellement les données en arborescence (comme un arbre généalogique inversé). Cette structure parent-enfant correspond très bien à la façon dont les humains organisent l'information dans la vie réelle.
Chaque nœud de l'arbre est un élément. Les éléments au même niveau partagent le même parent. Cette hiérarchie permet de représenter des données d'une complexité illimitée — des simples paires clé-valeur jusqu'à des structures organisationnelles complètes.
Les parseurs XML exploitent cette arborescence pour créer un DOM (Document Object Model) — un arbre d'objets navigable en mémoire. Un programme peut ainsi "descendre" dans l'arbre pour trouver exactement les données dont il a besoin.
<universite nom="UCAD">
<faculte nom="Sciences&Tech">
<departement nom="Informatique">
<etudiant matricule="2024-001">
<nom>Ali Diallo</nom>
<niveau>Licence 3</niveau>
<notes>
<note matiere="Algo">16</note>
<note matiere="XML">18</note>
</notes>
</etudiant>
</departement>
</faculte>
</universite>
HTML (HyperText Markup Language) et XML partagent la même syntaxe de balises (héritage de SGML), mais leurs objectifs sont fondamentalement différents.
HTML est conçu pour la présentation : ses balises ont une signification visuelle prédéfinie (<p> = paragraphe, <h1> = titre, <img> = image). Un navigateur sait comment afficher du HTML. HTML est aussi permissif : il corrige les erreurs de syntaxe, les balises non fermées, etc.
XML est conçu pour les données : ses balises n'ont aucune signification visuelle prédéfinie — vous inventez leur sens. XML est strict : la moindre erreur de syntaxe provoque une erreur fatale. XML ne sait pas s'afficher tout seul, il a besoin d'une feuille de style (CSS/XSLT) ou d'une application pour exploiter ses données.
<h1>Produits en vente</h1> <p>Prix : <strong>29.99 €</strong></p>
<produit> <titre>Produits en vente</titre> <prix devise="EUR">29.99</prix> </produit>
JSON (JavaScript Object Notation) est aujourd'hui le format dominant pour les APIs web, surtout les APIs REST. Il est plus compact, plus facile à lire, et nativement intégré à JavaScript. La plupart des langages modernes le supportent nativement.
XML, lui, reste omniprésent dans les systèmes plus anciens (legacy), les services SOAP, les fichiers de configuration d'entreprise, et partout où la validation formelle (via XSD), les namespaces et les transformations (XSLT) sont importants.
Les deux formats ont leurs forces : XML est plus expressif et validable, JSON est plus léger et rapide à parser. Beaucoup d'entreprises utilisent les deux selon le contexte.
<commande id="101">
<client>Ali Diallo</client>
<articles>
<article qte="2">Stylo</article>
<article qte="1">Cahier</article>
</articles>
<total>2500</total>
</commande>
{
"commande": {
"id": 101,
"client": "Ali Diallo",
"articles": [
{"nom":"Stylo","qte":2},
{"nom":"Cahier","qte":1}
],
"total": 2500
}
}
XML ne possède pas de type "tableau" natif comme JSON ([]). Pour représenter une liste d'éléments, on utilise la convention de répéter des éléments du même nom à l'intérieur d'un élément conteneur parent.
Le nom du parent est généralement au pluriel (ex: <fruits>) et le nom des enfants au singulier (<fruit>). Cette convention n'est pas imposée par la syntaxe XML mais elle est très courante et améliore la lisibilité.
Chaque élément de la liste peut être aussi simple (juste du texte) ou aussi complexe (avec des sous-éléments et attributs) que nécessaire.
<fruits> <fruit>Pomme</fruit> <fruit>Mangue</fruit> <fruit>Banane</fruit> <fruit>Papaye</fruit> </fruits>
<employes>
<employe id="1">
<nom>Fatou Ndiaye</nom>
<salaire>450000</salaire>
</employe>
<employe id="2">
<nom>Ibra Sow</nom>
<salaire>380000</salaire>
</employe>
</employes>
Une balise vide (ou élément vide) est un élément qui ne contient aucun texte et aucun sous-élément. Elle peut toutefois porter des attributs. Il y a deux façons syntaxiquement équivalentes de l'écrire.
La forme longue : <balise></balise> — balise ouverte immédiatement fermée.
La forme courte (auto-fermante) : <balise/> — slash avant le chevron fermant. C'est la notation préférée car elle est plus concise. Notez qu'en XML strict il y a un espace avant le /> par convention (<balise />), bien que ce ne soit pas obligatoire.
Les éléments vides sont utiles pour des marqueurs, des séparateurs, ou des éléments dont toutes les données sont portées par des attributs.
<configuration> <!-- Séparateur visuel --> <separateur/> <!-- Image avec toutes ses données en attributs --> <image src="logo.png" largeur="200" hauteur="50"/> <!-- Indicateur booléen --> <activer-notifications/> <!-- Équivalent forme longue --> <placeholder></placeholder> </configuration>
Les namespaces (espaces de noms) résolvent les conflits de noms lorsqu'un document XML combine des vocabulaires issus de sources différentes. Imaginez que vous fusionnez un document XML décrivant des tables HTML (<table>) avec un document XML décrivant des tables de restaurant (<table>) — comment distinguer les deux ?
La solution est de préfixer chaque nom de balise avec un identifiant unique lié à un namespace. Un namespace est déclaré avec l'attribut xmlns:prefix="URI". L'URI n'est pas nécessairement une vraie URL accessible — c'est juste un identifiant unique.
Si un namespace par défaut est déclaré avec xmlns="URI" (sans préfixe), il s'applique à tous les éléments non préfixés du document.
<document
xmlns:html="http://www.w3.org/1999/xhtml"
xmlns:resto="http://api.restaurant.com/schema">
<!-- Table HTML -->
<html:table>
<html:tr><html:td>Cellule</html:td></html:tr>
</html:table>
<!-- Table de restaurant -->
<resto:table numero="12" places="4">
<resto:statut>disponible</resto:statut>
</resto:table>
</document>
L'encodage de caractères définit comment les caractères textuels sont représentés en octets dans le fichier. XML supporte plusieurs encodages, mais UTF-8 est de loin le plus recommandé et le plus universel.
UTF-8 est une implémentation d'Unicode qui peut représenter plus de 1,1 million de caractères : toutes les lettres latines, accentuées, cyrilliques, arabes, chinoises, japonaises, les symboles mathématiques, les emoji… Pour les caractères courants (ASCII), UTF-8 utilise un seul octet, ce qui le rend aussi compact qu'ASCII.
D'autres encodages existent (ISO-8859-1, UTF-16, etc.) mais ils sont moins portables. Un fichier XML sans déclaration d'encodage est supposé être UTF-8 ou UTF-16 selon la présence d'une marque d'ordre des octets (BOM).
encoding="UTF-8" dans la déclaration XML. Ainsi les accents, caractères arabes et toute écriture fonctionneront partout.<?xml version="1.0" encoding="UTF-8"?> <localisations> <ville langue="fr">Dakar — Sénégal</ville> <ville langue="ar">الدار البيضاء</ville> <ville langue="zh">北京</ville> <ville langue="ja">東京</ville> <emoji>🌍 🌏 🌎</emoji> </localisations>
XPath (XML Path Language) est un langage de requête standardisé permettant de naviguer dans la structure d'un document XML et d'en extraire des parties précises. C'est l'équivalent de SQL pour les bases de données relationnelles, mais pour XML.
XPath représente les chemins dans l'arbre XML avec une syntaxe proche des chemins de fichiers Unix. Les principales syntaxes :
— / : racine absolue ou séparateur d'éléments.
— // : n'importe où dans le document (descendant).
— @ : préfixe pour accéder aux attributs.
— [condition] : filtre/prédicat pour affiner la sélection.
— * : joker correspondant à n'importe quel élément.
— text() : sélectionne le nœud texte d'un élément.
XPath est utilisé par XSLT, XQuery et les APIs de parsing XML dans la plupart des langages.
<!-- Avec ce document XML --> <librairie> <livre id="1"><titre>XML Master</titre><auteur>Ali</auteur></livre> <livre id="2"><titre>XPath Guide</titre><auteur>Fatou</auteur></livre> </librairie> <!-- Expressions XPath --> /librairie/livre/titre → tous les titres //auteur → tous les auteurs partout /librairie/livre[@id='1'] → livre avec id=1 //livre[auteur='Fatou'] → livres de Fatou //livre/@id → tous les attributs id count(//livre) → nombre de livres
XSLT (eXtensible Stylesheet Language Transformations) est un langage de transformation XML. Il permet de convertir un document XML source en un autre format : HTML pour affichage, texte simple, CSV, PDF, ou un autre XML de structure différente.
Une feuille de style XSLT est elle-même un document XML. Elle définit des templates qui correspondent à des nœuds XPath du document source et décrivent ce qu'il faut générer en sortie. Le moteur XSLT applique les templates correspondants au fur et à mesure qu'il parcourt le document XML.
XSLT est très puissant pour la séparation des préoccupations : vos données restent dans le XML, et la présentation est gérée par la feuille XSLT. Vous pouvez ainsi générer plusieurs vues différentes du même XML.
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html>
<body>
<h1>Liste des utilisateurs</h1>
<xsl:for-each select="//user">
<p>
<xsl:value-of select="nom"/>
</p>
</xsl:for-each>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
La DTD (Document Type Definition) est la plus ancienne façon de définir la structure autorisée d'un document XML. Elle spécifie quels éléments peuvent exister, dans quel ordre, avec quels attributs, et leur caractère obligatoire ou optionnel.
La DTD peut être interne (directement dans le fichier XML via <!DOCTYPE ... [ ]>) ou externe (dans un fichier .dtd séparé). Les déclarations DTD utilisent une syntaxe spéciale :
— <!ELEMENT> : définit un élément et son contenu autorisé.
— <!ATTLIST> : définit les attributs d'un élément.
— <!ENTITY> : définit des entités réutilisables.
— #PCDATA : texte analysé (Parsed Character Data).
— *, +, ? : qualificateurs de répétition (0+, 1+, 0 ou 1).
<?xml version="1.0"?>
<!DOCTYPE carnet [
<!ELEMENT carnet (contact+)>
<!ELEMENT contact (nom, email, tel?)>
<!ELEMENT nom (#PCDATA)>
<!ELEMENT email (#PCDATA)>
<!ELEMENT tel (#PCDATA)>
<!ATTLIST contact id ID #REQUIRED>
]>
<carnet>
<contact id="c1">
<nom>Ali Diallo</nom>
<email>ali@mail.com</email>
</contact>
</carnet>
La validation XML est le processus de vérification qu'un document XML respecte non seulement les règles de base du XML (bien formé) mais aussi un contrat de structure défini (valide). Un document peut être bien formé sans être valide.
On distingue deux niveaux :
— Bien formé : le document respecte les règles syntaxiques XML (balises fermées, imbrication correcte, etc.).
— Valide : le document est bien formé ET conforme à une DTD ou un schéma XSD.
La validation est cruciale dans les échanges inter-systèmes : avant de traiter les données XML reçues d'un partenaire, vous validez d'abord que leur structure correspond bien à ce qui est attendu. Cela prévient les bugs et les failles de sécurité.
<?xml version="1.0" encoding="UTF-8"?>
<!-- Validation contre un XSD externe -->
<catalogue
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="catalogue.xsd">
<produit id="1">
<nom>Ordinateur</nom>
<prix>599.00</prix>
</produit>
</catalogue>
Le XML Schema (XSD pour XML Schema Definition) est le standard moderne de définition de la structure d'un document XML. Il surpasse la DTD en offrant :
— Des types de données riches : entier, décimal, booléen, date, heure, URI, email…
— La prise en charge des namespaces.
— Des contraintes avancées : valeur min/max, longueur de chaîne, expressions régulières, valeurs autorisées (énumérations).
— La réutilisabilité via les types complexes et simples réutilisables.
— Une syntaxe XML elle-même — le XSD est un document XML valide.
Un XSD est défini dans un fichier séparé (extension .xsd) et référencé depuis le document XML à valider.
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="personne">
<xs:complexType>
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="age" type="xs:integer"/>
<xs:element name="email" type="xs:string"/>
<xs:element name="salaire" type="xs:decimal"
minOccurs="0"/>
</xs:sequence>
<xs:attribute name="id" type="xs:integer"
use="required"/>
</xs:complexType>
</xs:element>
</xs:schema>
Dans la terminologie XSD, un élément complexe est un élément qui contient d'autres éléments enfants et/ou des attributs. Par opposition à l'élément simple (leçon 29) qui ne contient que du texte.
Les éléments complexes peuvent être de différents types :
— Séquence (xs:sequence) : les enfants apparaissent dans un ordre strict.
— Tout (xs:all) : les enfants peuvent apparaître dans n'importe quel ordre.
— Choix (xs:choice) : exactement un parmi plusieurs enfants possibles.
— Contenu mixte : mélange texte et éléments (moins courant, utile pour des docs balisés).
<!-- Définition XSD -->
<xs:complexType name="typeAdresse">
<xs:sequence>
<xs:element name="rue" type="xs:string"/>
<xs:element name="ville" type="xs:string"/>
<xs:element name="codePostal" type="xs:string"/>
<xs:element name="pays" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<!-- Utilisation dans le XML -->
<adresse>
<rue>12 rue des Almadies</rue>
<ville>Dakar</ville>
<codePostal>10000</codePostal>
<pays>Sénégal</pays>
</adresse>
Un élément simple en XSD est un élément qui ne contient que du texte (ni sous-éléments, ni attributs). Il correspond à une valeur atomique comme un nom, un nombre, une date, etc.
En XSD, on peut contraindre finement le contenu des éléments simples grâce aux types de base de XML Schema. On peut aussi créer des types simples dérivés avec des restrictions : valeur minimale, maximale, longueur, pattern d'expression régulière, liste de valeurs autorisées (xs:enumeration).
<!-- Définitions XSD -->
<xs:element name="nom" type="xs:string"/>
<xs:element name="age" type="xs:integer"/>
<xs:element name="prix" type="xs:decimal"/>
<xs:element name="actif" type="xs:boolean"/>
<xs:element name="dateNais" type="xs:date"/>
<!-- Restriction (valeur entre 0 et 120) -->
<xs:simpleType name="typeAge">
<xs:restriction base="xs:integer">
<xs:minInclusive value="0"/>
<xs:maxInclusive value="120"/>
</xs:restriction>
</xs:simpleType>
<personne> <nom>Fatou Ndiaye</nom> <age>29</age> <prix>29.99</prix> <actif>true</actif> <dateNais>1996-03-15</dateNais> </personne>
XML joue un rôle important dans les échanges de données avec les bases de données. La plupart des SGBD modernes (Oracle, SQL Server, MySQL, PostgreSQL) supportent nativement la lecture et l'écriture de données XML.
Voici les principaux usages :
— Import/Export : exporter des tables relationnelles en XML pour les transférer vers un autre système, ou importer des données XML dans une base.
— Type XML : SQL Server et PostgreSQL proposent un type de colonne XML pour stocker directement du XML dans une table.
— XQuery : langage de requête pour interroger des données XML stockées en base, comme SQL mais pour XML.
— APIs REST/SOAP : les bases de données exposent souvent des données via des services web qui retournent du XML.
<?xml version="1.0" encoding="UTF-8"?>
<clients>
<client id="001">
<nom>Fatou Badiane</nom>
<email>fatou@mail.sn</email>
<adresse>
<ville>Dakar</ville>
<quartier>Almadies</quartier>
</adresse>
<commandes>
<commande ref="CMD-101" montant="75000"/>
<commande ref="CMD-205" montant="32000"/>
</commandes>
</client>
</clients>
RSS (Really Simple Syndication) est un format XML standardisé permettant de distribuer automatiquement des mises à jour de contenu web. C'est l'une des utilisations les plus connues de XML dans la vie quotidienne.
Les sites d'actualités, blogs, podcasts et chaînes YouTube proposent des flux RSS. Les applications de lecture RSS (Feedly, Inoreader, etc.) lisent ces fichiers XML et affichent les nouveaux articles à l'utilisateur sans qu'il ait besoin de visiter chaque site.
La structure d'un flux RSS comprend toujours :
— Un élément racine <rss> avec la version.
— Un <channel> décrivant la source (titre, lien, description).
— Des éléments <item> pour chaque article avec titre, lien, date et description.
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
<channel>
<title>Tech Dakar</title>
<link>https://techdakar.sn</link>
<description>Actualités tech au Sénégal</description>
<language>fr-SN</language>
<item>
<title>XML est toujours pertinent en 2025</title>
<link>https://techdakar.sn/xml-2025</link>
<pubDate>Mon, 01 Jan 2025 09:00:00 GMT</pubDate>
<description>Pourquoi XML reste incontournable...</description>
</item>
</channel>
</rss>
Un sitemap XML est un fichier XML standardisé (sitemap.xml, placé à la racine d'un site) qui liste toutes les URLs d'un site web. Il aide les robots des moteurs de recherche (Googlebot, Bingbot…) à découvrir et indexer efficacement les pages du site.
Sans sitemap, un moteur de recherche doit parcourir le site lien par lien, ce qui peut mener à des oublis. Avec un sitemap, vous lui donnez directement la carte complète, avec des informations supplémentaires :
— <loc> : URL de la page.
— <lastmod> : date de dernière modification.
— <changefreq> : fréquence de mise à jour estimée (daily, weekly…).
— <priority> : priorité relative de la page (0.0 à 1.0).
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url>
<loc>https://monsite.sn/</loc>
<lastmod>2025-01-01</lastmod>
<changefreq>daily</changefreq>
<priority>1.0</priority>
</url>
<url>
<loc>https://monsite.sn/blog</loc>
<lastmod>2025-01-10</lastmod>
<changefreq>weekly</changefreq>
<priority>0.8</priority>
</url>
</urlset>
SOAP (Simple Object Access Protocol) est un protocole de communication pour les services web qui utilise XML comme format de message. Bien que REST/JSON soit dominant aujourd'hui, SOAP est encore très présent dans les systèmes bancaires, d'assurance, d'administration et dans les grandes entreprises.
Un message SOAP est un document XML structuré en trois parties :
— Envelope : l'enveloppe, racine obligatoire qui déclare le message comme SOAP.
— Header (optionnel) : métadonnées de transport (authentification, transaction, traçabilité).
— Body : le contenu réel du message — la requête ou la réponse de service.
SOAP fonctionne généralement avec WSDL (Web Services Description Language) — un fichier XML qui décrit l'interface complète d'un service web : méthodes disponibles, paramètres, types de données.
<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:tns="http://api.banque.sn/services">
<soap:Header>
<tns:Auth>
<tns:token>eyJhbGciOiJIUzI1NiJ9</tns:token>
</tns:Auth>
</soap:Header>
<soap:Body>
<tns:getCompte>
<tns:numeroCompte>SN28 0001 0010 1234</tns:numeroCompte>
</tns:getCompte>
</soap:Body>
</soap:Envelope>
Android utilise XML massivement pour tout ce qui concerne les ressources de l'application. L'intégralité de l'interface utilisateur, des styles, des dimensions, des chaînes de texte et des configurations est définie dans des fichiers XML.
Dans un projet Android, le dossier res/ contient plusieurs sous-dossiers de ressources XML :
— res/layout/ : fichiers XML définissant les interfaces (Activity, Fragment).
— res/values/strings.xml : toutes les chaînes de texte localisables.
— res/values/colors.xml : palette de couleurs.
— res/values/styles.xml : thèmes et styles.
— res/drawable/ : icônes et formes vectorielles en XML (Vector Drawable).
— AndroidManifest.xml : configuration globale de l'app (permissions, activités, etc.).
<!-- res/layout/activity_main.xml -->
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:padding="16dp">
<TextView
android:id="@+id/titre"
android:text="@string/app_name"
android:textSize="24sp"
android:textStyle="bold"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
<Button
android:id="@+id/btnValider"
android:text="@string/valider"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>
</LinearLayout>
Java est l'un des langages où XML est le plus utilisé. Il propose deux grandes approches pour traiter XML :
— DOM (Document Object Model) : charge tout le document XML en mémoire sous forme d'arbre d'objets. Pratique pour naviguer et modifier le document, mais consomme beaucoup de mémoire pour les gros fichiers.
— SAX (Simple API for XML) : lit le XML séquentiellement et émet des événements (début de balise, texte, fin de balise). Très efficace en mémoire mais plus complexe à programmer.
Des frameworks Java populaires comme Spring, Maven et Hibernate utilisent XML pour la configuration. JAXB (Java Architecture for XML Binding) permet de convertir automatiquement des objets Java en XML (marshalling) et vice versa (unmarshalling).
// Lecture XML avec DOM en Java
import javax.xml.parsers.*;
import org.w3c.dom.*;
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder =
factory.newDocumentBuilder();
// Charger le fichier
Document doc = builder.parse("data.xml");
doc.getDocumentElement().normalize();
// Récupérer les éléments
NodeList liste =
doc.getElementsByTagName("employe");
for (int i = 0; i < liste.getLength(); i++) {
Element emp = (Element) liste.item(i);
String nom = emp.getElementsByTagName("nom")
.item(0).getTextContent();
System.out.println("Employé : " + nom);
}
PHP offre plusieurs extensions natives pour travailler avec XML, rendant sa manipulation très accessible :
— SimpleXML : l'approche la plus simple et intuitive. Charge un fichier XML et le convertit en objet PHP navigable avec la notation objet standard (->). Parfait pour lire et interroger des XML de structure connue.
— DOMDocument : plus puissant, suit le standard DOM W3C, permet de créer et modifier du XML de façon programmatique.
— XMLReader/XMLWriter : pour les gros fichiers XML, lisent/écrivent en flux sans charger tout en mémoire.
<?php
// Charger et lire avec SimpleXML
$xml = simplexml_load_file('catalogue.xml');
foreach ($xml->produit as $produit) {
echo "Produit : " . $produit->nom . "\n";
echo "Prix : " . $produit->prix . " XOF\n";
echo "ID : " . $produit['id'] . "\n\n";
}
// Créer du XML avec DOMDocument
$doc = new DOMDocument('1.0', 'UTF-8');
$doc->formatOutput = true;
$root = $doc->createElement('utilisateurs');
$doc->appendChild($root);
$user = $doc->createElement('user');
$user->setAttribute('id', '1');
$user->appendChild($doc->createElement('nom', 'Ali'));
$root->appendChild($user);
echo $doc->saveXML();
?>
Python propose plusieurs bibliothèques pour traiter XML, adaptées selon les besoins :
— xml.etree.ElementTree : bibliothèque standard, légère et facile d'utilisation. Idéale pour la majorité des cas.
— lxml : bibliothèque externe très performante, supporte XPath avancé et la validation XSD. À installer via pip.
— xml.dom.minidom : implémentation DOM standard dans la bibliothèque Python.
— BeautifulSoup : idéal pour parser du XML/HTML mal formé (web scraping).
xml.etree.ElementTree est vulnérable aux attaques XXE (voir leçon 46). Pour du XML non fiable (venant d'internet), préférez defusedxml — une bibliothèque sécurisée facile à installer.import xml.etree.ElementTree as ET
# Charger et analyser
tree = ET.parse('catalogue.xml')
root = tree.getroot()
# Lire les éléments
for produit in root.findall('produit'):
nom = produit.find('nom').text
prix = produit.find('prix').text
pid = produit.get('id') # attribut
print(f"ID:{pid} | {nom} → {prix} XOF")
# Créer du XML
catalogue = ET.Element('catalogue')
p = ET.SubElement(catalogue, 'produit', id="1")
ET.SubElement(p, 'nom').text = 'Laptop'
ET.SubElement(p, 'prix').text = '599000'
# Écrire dans un fichier
tree = ET.ElementTree(catalogue)
ET.indent(tree) # Indentation (Python 3.9+)
tree.write('nouveau.xml', encoding='UTF-8',
xml_declaration=True)
Dans les navigateurs web, l'objet DOMParser permet de transformer une chaîne de caractères XML en un arbre DOM navigable. Côté serveur (Node.js), des bibliothèques comme fast-xml-parser ou xml2js remplissent ce rôle.
Le processus de parsing implique plusieurs étapes :
1. Obtenir le texte XML (depuis un fetch(), un champ de formulaire, un fichier uploadé…).
2. Créer une instance de DOMParser.
3. Appeler .parseFromString(texte, "text/xml").
4. Vérifier les erreurs de parsing (la méthode renvoie un document avec un élément parsererror si le XML est invalide).
5. Naviguer dans l'arbre résultant avec les méthodes DOM.
// Texte XML à parser
const xmlString = `
<?xml version="1.0"?>
<employes>
<employe id="1">
<nom>Fatou Diallo</nom>
<poste>Développeuse</poste>
</employe>
</employes>`;
// Créer le parseur
const parser = new DOMParser();
const xmlDoc = parser.parseFromString(
xmlString, "text/xml"
);
// Vérifier les erreurs
const erreur = xmlDoc.querySelector('parsererror');
if (erreur) {
console.error("XML invalide :", erreur.textContent);
} else {
// Récupérer les données
const employes = xmlDoc.querySelectorAll('employe');
employes.forEach(emp => {
const nom = emp.querySelector('nom').textContent;
const poste = emp.querySelector('poste').textContent;
const id = emp.getAttribute('id');
console.log(`#${id} ${nom} — ${poste}`);
});
}
Le DOM (Document Object Model) est une représentation en mémoire d'un document XML sous forme d'arbre de nœuds (nodes). C'est le standard W3C qui définit comment les programmes peuvent accéder et manipuler les documents XML (et HTML) de façon uniforme, quel que soit le langage utilisé.
Les types de nœuds principaux dans le DOM XML :
— Document : la racine de l'arbre, représente le document entier.
— Element : un élément XML (une balise).
— Text : le contenu textuel d'un élément.
— Attr : un attribut d'un élément.
— Comment : un commentaire XML.
— ProcessingInstruction : une instruction de traitement (<?xml...?>).
// DOM JavaScript — navigation et manipulation
const xmlString = `<users>
<user id="1"><nom>Ali</nom></user>
<user id="2"><nom>Fatou</nom></user>
</users>`;
const xmlDoc = new DOMParser()
.parseFromString(xmlString, "text/xml");
// Méthodes DOM
const racine = xmlDoc.documentElement; // <users>
console.log(racine.tagName); // "users"
const noms = xmlDoc.getElementsByTagName("nom");
console.log(noms[0].textContent); // "Ali"
console.log(noms[1].textContent); // "Fatou"
// Récupérer un attribut
const users = xmlDoc.querySelectorAll("user");
users.forEach(u =>
console.log(u.getAttribute("id"))
);
// childNodes, parentNode, firstChild…
const enfants = racine.childNodes;
console.log(enfants.length); // 2
Le SAX parser (Simple API for XML) adopte une approche radicalement différente du DOM : au lieu de charger tout le document en mémoire, il le lit séquentiellement de haut en bas et émet des événements pour chaque élément rencontré.
Le programmeur définit des gestionnaires d'événements (callbacks) qui sont appelés à chaque étape :
— startElement : déclenché à l'ouverture de chaque balise.
— endElement : déclenché à la fermeture de chaque balise.
— characters : déclenché pour le contenu textuel.
— startDocument / endDocument : début/fin du document.
Avantages SAX : consomme très peu de mémoire (idéal pour des fichiers XML de plusieurs GB), très rapide en lecture. Inconvénients : plus complexe à programmer, pas de navigation en arrière ni d'accès aléatoire.
// SAX en Java
import org.xml.sax.*;
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParserFactory;
public class MonHandler extends DefaultHandler {
private String elementCourant = "";
@Override
public void startElement(String uri,
String localName, String qName,
Attributes attrs) {
elementCourant = qName;
if (qName.equals("employe")) {
System.out.println("ID: " + attrs.getValue("id"));
}
}
@Override
public void characters(char[] ch,
int start, int length) {
if (elementCourant.equals("nom")) {
System.out.println("Nom: " +
new String(ch, start, length).trim());
}
}
@Override
public void endElement(String uri,
String localName, String qName) {
elementCourant = "";
}
}
Dans un schéma XSD, la contrainte use="required" sur un attribut signifie que cet attribut est obligatoire dans le document XML. Sans lui, le document échouera à la validation. Inversement, use="optional" est la valeur par défaut.
Il est aussi possible de définir une valeur par défaut (default="valeur") qui est utilisée si l'attribut est absent, ou une valeur fixe (fixed="valeur") que l'attribut doit avoir obligatoirement.
La combinaison de type et use permet un contrôle très précis de la qualité des données dans le document XML.
<!-- Définition XSD -->
<xs:complexType name="typeProduit">
<xs:sequence>
<xs:element name="nom" type="xs:string"/>
<xs:element name="prix" type="xs:decimal"/>
</xs:sequence>
<!-- Attributs -->
<xs:attribute name="id"
type="xs:integer" use="required"/>
<xs:attribute name="devise"
type="xs:string" default="XOF"/>
<xs:attribute name="version"
type="xs:string" fixed="2.0"/>
</xs:complexType>
<!-- XML valide -->
<produit id="42" devise="EUR">
<nom>Laptop</nom>
<prix>599.00</prix>
</produit>
L'élément XSD xs:sequence est l'un des trois compositors (groupements) disponibles pour définir l'ordre et la composition des éléments enfants d'un élément complexe.
Avec xs:sequence, les éléments enfants doivent apparaître exactement dans l'ordre spécifié. C'est la contrainte la plus courante et la plus stricte.
Les trois compositors XSD :
— xs:sequence : ordre strict, tous les éléments doivent apparaître dans l'ordre.
— xs:all : tous les éléments doivent apparaître, mais dans n'importe quel ordre (chacun 0 ou 1 fois).
— xs:choice : exactement un parmi plusieurs éléments alternatifs.
<!-- Séquence : ordre strict -->
<xs:complexType name="typePersonne">
<xs:sequence>
<xs:element name="prenom" type="xs:string"/>
<xs:element name="nom" type="xs:string"/>
<xs:element name="email" type="xs:string"/>
<xs:element name="tel" type="xs:string"
minOccurs="0"/>
</xs:sequence>
</xs:complexType>
<!-- xs:choice : un parmi plusieurs -->
<xs:complexType name="typeContact">
<xs:choice>
<xs:element name="email" type="xs:string"/>
<xs:element name="tel" type="xs:string"/>
<xs:element name="fax" type="xs:string"/>
</xs:choice>
</xs:complexType>
L'attribut XSD minOccurs définit le nombre minimum de fois qu'un élément doit apparaître dans son contexte. C'est un contrôle fondamental pour définir les champs obligatoires et optionnels.
Valeurs courantes :
— minOccurs="0" : l'élément est optionnel — il peut être absent.
— minOccurs="1" : l'élément est obligatoire — doit apparaître au moins une fois (valeur par défaut).
— minOccurs="2" : l'élément doit apparaître au minimum 2 fois.
Combiné avec maxOccurs (leçon 44), on peut définir précisément les cardinalités, comme dans un modèle de base de données : 1..1, 0..1, 1..N, 0..N.
<xs:complexType name="typeCommande">
<xs:sequence>
<!-- Obligatoire (1 exactement) -->
<xs:element name="reference"
type="xs:string"
minOccurs="1" maxOccurs="1"/>
<!-- Optionnel (0 ou 1) -->
<xs:element name="commentaire"
type="xs:string"
minOccurs="0" maxOccurs="1"/>
<!-- Au moins 1 article -->
<xs:element name="article"
type="xs:string"
minOccurs="1" maxOccurs="unbounded"/>
<!-- Exactement 2 à 5 témoins -->
<xs:element name="temoin"
type="xs:string"
minOccurs="2" maxOccurs="5"/>
</xs:sequence>
</xs:complexType>
L'attribut XSD maxOccurs définit le nombre maximum de fois qu'un élément peut apparaître. Il complète minOccurs pour définir des cardinalités précises.
La valeur spéciale unbounded signifie "sans limite supérieure" — l'élément peut apparaître autant de fois que nécessaire. C'est la valeur utilisée pour les listes de taille variable.
Combinaisons courantes :
— min=0, max=1 : optionnel unique (0..1).
— min=1, max=1 : obligatoire unique (exactement 1).
— min=0, max=unbounded : liste optionnelle (0..∞).
— min=1, max=unbounded : liste obligatoire (1..∞).
— min=2, max=4 : entre 2 et 4 occurrences.
<xs:complexType name="typeFacture">
<xs:sequence>
<!-- Un seul client (obligatoire) -->
<xs:element name="client"
minOccurs="1" maxOccurs="1"
type="xs:string"/>
<!-- Une ou plusieurs lignes -->
<xs:element name="ligne"
minOccurs="1" maxOccurs="unbounded"
type="typeLigne"/>
<!-- Zéro ou plusieurs remises -->
<xs:element name="remise"
minOccurs="0" maxOccurs="unbounded"
type="xs:decimal"/>
</xs:sequence>
</xs:complexType>
XSD permet d'intégrer de la documentation directement dans le schéma, à l'aide des éléments <xs:annotation> et <xs:documentation>. Cette documentation en ligne est précieuse pour les équipes qui travaillent avec le schéma.
On peut documenter les éléments, les attributs et les types complexes ou simples. Certains outils de génération de documentation comme Oxygen XML Editor ou xs3p exploitent ces annotations pour générer automatiquement des pages HTML de documentation de schéma.
Il existe aussi <xs:appinfo>, frère de xs:documentation, qui contient des informations destinées aux applications (métadonnées machines, directives de traitement) plutôt qu'aux développeurs.
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:annotation>
<xs:documentation>
Schéma de gestion clients v2.1
Auteur : Équipe data — Mis à jour : 2025-01-10
</xs:documentation>
</xs:annotation>
<xs:element name="client">
<xs:annotation>
<xs:documentation>
Représente un client enregistré.
Chaque client est identifié par un ID unique.
</xs:documentation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
<xs:element name="nom">
<xs:annotation>
<xs:documentation>
Nom complet (prénom + nom de famille).
Max 100 caractères.
</xs:documentation>
</xs:annotation>
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:maxLength value="100"/>
</xs:restriction>
</xs:simpleType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
XML peut être vecteur de plusieurs vulnérabilités de sécurité. La plus connue est l'attaque XXE (XML External Entity Injection). Elle exploite la fonctionnalité d'entités externes de XML pour lire des fichiers arbitraires du serveur, effectuer des SSRF (Server-Side Request Forgery) ou provoquer des dénis de service.
Une attaque XXE classique définit une entité externe qui pointe vers un fichier sensible du système (/etc/passwd, des fichiers de configuration, des clés privées) et insère cette entité dans le contenu XML. Quand le serveur parse ce XML, il lit le fichier et l'inclut dans sa réponse.
Autres vulnérabilités XML :
— Billion Laughs (XML Bomb) : entités récursives qui s'expansent exponentiellement et épuisent la mémoire du serveur.
— XPath Injection : similaire à l'injection SQL, manipulation malveillante de requêtes XPath.
— XSLT Injection : exécution de code via des transformations XSLT malicieuses.
factory.setFeature("http://xml.org/sax/features/external-general-entities", false). En PHP : libxml_disable_entity_loader(true). En Python : utiliser la bibliothèque defusedxml.<!-- Attaque XXE (NE JAMAIS AUTORISER) --> <?xml version="1.0"?> <!DOCTYPE attaque [ <!ENTITY xxe SYSTEM "file:///etc/passwd"> <!ENTITY bomb "&b1;&b1;&b1;&b1;&b1;&b1;"> ]> <data>&xxe;</data> <!-- Protection en Java --> // factory.setFeature( // XMLConstants.FEATURE_SECURE_PROCESSING, // true // ); // factory.setFeature( // "http://apache.org/xml/features/ // disallow-doctype-decl", true // );
Bien que JSON domine aujourd'hui les APIs REST modernes, XML reste très présent dans le monde des APIs, en particulier dans :
— Les services SOAP (bancaires, gouvernementaux, assurances, télécoms) qui définissent leurs contrats via WSDL.
— Les systèmes d'entreprise (ERP, SAP, Salesforce, Jira) dont les APIs historiques retournent du XML.
— Les APIs de paiement et de facturation (PayPal, certains services fiscaux).
— Les flux de données (Reuters, Bloomberg, flux boursiers, météo).
— Les formats de configuration (Maven, Ant, Struts, Spring XML config).
Consommer une API XML est similaire à JSON : on effectue une requête HTTP, on récupère la réponse et on la parse. La différence est dans le parseur utilisé.
<!-- Réponse typique d'une API XML -->
<?xml version="1.0" encoding="UTF-8"?>
<response>
<status code="200">OK</status>
<timestamp>2025-01-15T10:30:00Z</timestamp>
<data>
<transactions total="3" page="1">
<transaction id="TXN-001">
<montant devise="XOF">50000</montant>
<date>2025-01-15</date>
<type>depot</type>
<statut>confirme</statut>
</transaction>
</transactions>
</data>
</response>
XML possède des atouts concrets qui expliquent sa longévité après plus de 25 ans d'existence :
1. Lisibilité humaine : contrairement aux formats binaires, le XML est du texte lisible. Un développeur peut ouvrir un fichier XML dans n'importe quel éditeur texte et comprendre la structure.
2. Extensibilité : vous définissez vos propres balises. Le format s'adapte à n'importe quel domaine métier sans limitations.
3. Indépendance technologique : XML est un standard ouvert W3C, supporté par tous les langages, OS et plateformes. Il garantit l'interopérabilité à long terme.
4. Validation formelle : grâce aux DTD et XSD, vous pouvez définir des contrats de données précis et les faire respecter automatiquement — impossible en JSON sans bibliothèques tierces.
5. Écosystème riche : XPath, XSLT, XQuery, XSD, SOAP, WSDL — un écosystème complet de standards interopérables pour tous les besoins.
6. Pérennité : les données en XML restent lisibles et exploitables des décennies plus tard, sans dépendance à un logiciel propriétaire spécifique.
<avantages-xml>
<avantage priorite="haute">
<nom>Lisibilité humaine</nom>
<detail>Texte brut, aucun outil requis</detail>
</avantage>
<avantage priorite="haute">
<nom>Validation formelle</nom>
<detail>XSD et DTD garantissent la qualité</detail>
</avantage>
<avantage priorite="moyenne">
<nom>Écosystème mature</nom>
<detail>XPath, XSLT, XQuery, SOAP…</detail>
</avantage>
</avantages-xml>
Malgré ses qualités, XML présente des limitations réelles qu'il faut connaître pour choisir le bon outil :
1. Verbosité : chaque donnée nécessite une balise ouvrante et une fermante. Pour les données simples, cela représente beaucoup de bruit par rapport à la quantité d'information utile. Un JSON équivalent est souvent 30 à 50 % plus compact.
2. Poids et bande passante : la verbosité impacte directement la taille des fichiers et donc les coûts de stockage et de transfert réseau — problématique pour les applications mobiles ou à grand volume.
3. Vitesse de parsing : parser du XML est généralement plus lent que parser du JSON, surtout pour les très grands volumes de données ou les systèmes à haute performance.
4. Complexité : la richesse de l'écosystème XML (XSD, XSLT, namespaces…) a une contrepartie — une courbe d'apprentissage plus raide que JSON.
5. Pas de types natifs : en XML de base, tout est texte. La notion de nombre, booléen, date n'existe qu'avec XSD — en JSON, les types numériques et booléens sont natifs.
<!-- Verbosité XML -->
<utilisateur>
<id>1</id>
<nom>Ali</nom>
<age>28</age>
<actif>true</actif>
</utilisateur>
<!-- 97 caractères pour 4 champs -->
<!-- Équivalent JSON -->
<!-- {"id":1,"nom":"Ali","age":28,"actif":true} -->
<!-- 44 caractères — 55% plus compact -->
Ce projet final rassemble toutes les notions vues dans ce guide : déclaration, racine unique, éléments imbriqués, attributs, commentaires, listes, éléments vides, entités et données structurées. C'est une base de données XML complète modélisant un système de e-commerce minimaliste.
Ce type de structure XML pourrait servir de :
— Fichier d'initialisation de base de données de développement.
— Format d'export/import entre deux systèmes.
— Source de données pour une transformation XSLT vers HTML.
— Fichier validé par un schéma XSD définissant les contraintes métier.
<?xml version="1.0" encoding="UTF-8"?>
<!-- Base de données e-commerce — v1.0 -->
<database version="1.0" date="2025-01-01">
<!-- === UTILISATEURS === -->
<users>
<user id="1" role="admin" actif="true">
<nom>Ali Diallo</nom>
<email>ali@techstore.sn</email>
<adresse>
<rue>12 Av. Cheikh Anta Diop</rue>
<ville>Dakar</ville>
<pays>SN</pays>
</adresse>
</user>
<user id="2" role="client" actif="true">
<nom>Fatou Ndiaye</nom>
<email>fatou@mail.com</email>
</user>
</users>
<!-- === PRODUITS === -->
<produits>
<produit id="P01" categorie="electronique">
<nom>Laptop Pro</nom>
<prix devise="XOF">599000</prix>
<stock>15</stock>
<description><![CDATA[
Laptop haute performance : 16Go RAM,
512Go SSD, écran 15" Full HD.
]]></description>
</produit>
<produit id="P02" categorie="accessoire">
<nom>Souris Sans Fil</nom>
<prix devise="XOF">18000</prix>
<stock>87</stock>
</produit>
</produits>
<!-- === COMMANDES === -->
<commandes>
<commande id="CMD-001"
userId="2" date="2025-01-10"
statut="livre">
<lignes>
<ligne produitId="P01" qte="1"
prixUnit="599000"/>
<ligne produitId="P02" qte="2"
prixUnit="18000"/>
</lignes>
<total devise="XOF">635000</total>
</commande>
</commandes>
</database>