📜 XML – Le Guide Ultime

XML signifie eXtensible Markup Language (Langage de balisage extensible). C'est un langage de balisage, tout comme HTML, mais sa finalité est radicalement différente.

La Différence Fondamentale : HTML vs XML

C'est la chose la plus importante à comprendre pour un débutant.

• HTML (HyperText Markup Language) : Son but est de décrire la présentation des données. Il dit au navigateur *comment afficher* l'information. Ses balises (<h1>, <p>, <div>) sont prédéfinies.
  Ex: <h1>Titre</h1><p>Ceci est un paragraphe.</p> (Dit "Affiche ceci en gros" et "Affiche ceci comme un paragraphe").


• XML (eXtensible Markup Language) : Son but est de décrire la structure et la signification des données. Il n'a aucune idée de *comment afficher* l'information. Ses balises sont inventées par vous (extensibles).
  Ex: <personne><nom>Dupont</nom><email>jean.dupont@mail.com</email></personne> (Dit "Ceci est une personne", "Ceci est son nom", "Ceci est son email").

Pourquoi XML ? (Les 3 Piliers)

Un fichier XML qui respecte ces règles est dit "Bien Formé" (Well-Formed). S'il manque une seule de ces règles, un parseur (lecteur) plantera avec une erreur.

1. Le Prologue (Optionnel, mais recommandé)
   Toujours la première ligne. Il définit la version XML et l'encodage (crucial pour les accents).
   <?xml version="1.0" encoding="UTF-8"?>
2. Un Élément Racine (Root) Unique
   Un document XML doit avoir une et une seule balise qui englobe toutes les autres. C'est "l'ancêtre" de l'arbre.
   Exemple : <bibliotheque> ... (tous les livres ici) ... </bibliotheque>
3. Toutes les Balises doivent être Fermées
   Contrairement au HTML (où <br> est OK), chaque balise XML doit être fermée.
   - Soit avec une balise fermante : <nom>Dupont</nom>
   - Soit en s'auto-fermant (pour les balises vides) : <image source="logo.png" /> (notez le />)
4. Sensible à la Casse (Case-Sensitive)
   <Nom> n'est PAS la même chose que <nom>. <nom>Dupont</Nom> est une erreur.
5. Imbrication Correcte (Nesting)
   Les balises doivent être fermées dans l'ordre inverse de leur ouverture.
   - Correct : <b><i>Texte</i></b>
   - Incorrect : <b><i>Texte</b></i> (Erreur "d'chevauchement")
6. Les Attributs doivent avoir des Guillemets
   Toujours. Simples (') ou doubles (").
   - Correct : <personne id="123">
   - Incorrect : <personne id=123>
7. Caractères Spéciaux (Entités) & CDATA
   Si votre texte contient < ou &, le parseur va croire que c'est une nouvelle balise.
   - Entités : Il faut les "échapper".
   < devient < (less than)
   > devient > (greater than)
   & devient & (ampersand)
   " devient "
' devient '
   - CDATA : Si vous avez un gros bloc de code (JavaScript, SQL) à insérer, utilisez une section "CDATA" ("Character Data"). Le parseur ignorera tout ce qui est à l'intérieur.

   <script>
     <![CDATA[
       if (a < b && b > 5) {
         console.log("OK");
       }
     ]]>
   </script>

Un document XML est fondamentalement un arbre généalogique. C'est sa structure hiérarchique. Quand un programme (Java, Python) lit un XML, il le charge en mémoire sous forme d'objet appelé le DOM (Document Object Model), qui *représente* cet arbre.

Exemple de XML

<?xml version="1.0" encoding="UTF-8"?>
<bibliotheque>
  <!-- Premier livre -->
  <livre categorie="Roman">
    <titre>Les Misérables</titre>
    <auteur>Victor Hugo</auteur>
  </livre>
  <livre categorie="Science">
    <titre>Une brève histoire du temps</titre>
    <auteur>Stephen Hawking</auteur>
  </livre>
</bibliotheque>

Terminologie de l'Arbre (DOM)

En se basant sur l'exemple ci-dessus :

C'est le concept le plus confus pour les débutants, mais le plus important pour travailler en entreprise.

1. Bien Formé (Well-Formed)

Un document XML est "bien formé" s'il respecte les règles de syntaxe (voir Modale 2).
C'est-à-dire : une seule racine, balises fermées, sensible à la casse, guillemets aux attributs, etc.

Analogie : C'est une phrase grammaticalement correcte.
Ex: "Le chat mange la souris." (Grammaire OK).
Ex (Non "bien formé"): "Chat le souris mange." (Le parseur syntaxique (votre cerveau) plante).

Un parseur XML plantera toujours si le fichier n'est pas "bien formé".

2. Valide (Valid)

Un document XML est "valide" s'il est bien formé ET s'il respecte les règles métier définies dans un "contrat" externe.
Ce "contrat" est un fichier DTD (ancien) ou XSD (moderne).

Analogie : C'est une phrase grammaticalement correcte ET qui respecte le formulaire que vous remplissez.
Le formulaire (le XSD) dit : "Le champ 'Nom' est obligatoire", "Le champ 'Âge' doit être un nombre".
- Phrase : "Mon nom est Jean" (Grammaire OK, donc "bien formé").
- Validation : Le formulaire (XSD) dit que le champ "Âge" est obligatoire. Votre phrase ne le contient pas.
- Résultat : Votre document est Bien Formé, mais Non Valide.

Exemple Concret

<personne id="1">
  <nom>Dupont</nom>
  <email>jean@mail.com</email>
</personne>
<personne id="2">
  <nom>Durand</nom>
  <age>30</age> </personne>
<personne id=3> <nom>Martin
</personne> 

La DTD est "l'ancêtre" de la validation. C'est la première façon qui a existé pour définir le "contrat" (la grammaire) d'un fichier XML.

Point clé : La syntaxe d'une DTD n'est PAS du XML. C'est un format propriétaire (hérité de SGML).

Liaison (Comment lier un XML à une DTD)

La liaison se fait via une balise <!DOCTYPE ...> juste après le prologue.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE bibliotheque SYSTEM "biblio.dtd">
<bibliotheque>
  ...
</bibliotheque>

Exemple de Syntaxe (fichier biblio.dtd)

<!-- Définit l'élément "bibliotheque" :
     Il doit contenir UN OU PLUSIEURS (+) "livre" -->
<!ELEMENT bibliotheque (livre+)>

<!-- Définit l'élément "livre" :
     Il doit contenir "titre" PUIS "auteur", dans cet ordre.
     "resume" est optionnel (?) -->
<!ELEMENT livre (titre, auteur, resume?)>

<!-- Définit les éléments "titre", "auteur", "resume" :
     Ils contiennent du texte analysable (#PCDATA) -->
<!ELEMENT titre (#PCDATA)>
<!ELEMENT auteur (#PCDATA)>
<!ELEMENT resume (#PCDATA)>

<!-- Définit les attributs de "livre" :
     "categorie" est du texte (CDATA) et est REQUIS (#REQUIRED)
     "annee" est du texte (CDATA) et est OPTIONNEL (#IMPLIED) -->
<!ATTLIST livre
    categorie CDATA #REQUIRED
    annee     CDATA #IMPLIED
>

Limites (Pourquoi on utilise XSD maintenant)

• Pas de Typage de Données : Tout est du texte (CDATA ou #PCDATA). annee="abc" est valide pour la DTD, car elle ne peut pas forcer un "nombre". C'est le plus gros problème.
• Syntaxe Non-XML : Vous devez apprendre un langage différent (le <!ELEMENT ...>) et les outils XML (parseurs, XPath) ne peuvent pas lire la DTD.
• Pas de Namespaces : Ne gère pas les namespaces (voir Modale 7).

Le XSD (aussi appelé "XML Schema") est le successeur moderne et surpuissant de la DTD. Il résout toutes ses limitations.

Les Avantages du XSD

• C'est du XML : Un fichier .xsd est lui-même un fichier XML. On peut le lire, le valider, et le requêter (XPath) avec les outils standards.
• Typage de Données Fort : C'est sa plus grande force. Il supporte xs:string, xs:integer, xs:decimal, xs:date, xs:boolean, etc. Vous pouvez forcer annee à être un nombre.
• Restrictions (Patterns) : Vous pouvez définir des règles complexes (ex: "ce string doit matcher ce Regex", "ce nombre doit être entre 18 et 65").
• Support des Namespaces : Gère parfaitement les espaces de noms.

Liaison (Comment lier un XML à un XSD)

<?xml version="1.0" encoding="UTF-8"?>
<bibliotheque xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:noNamespaceSchemaLocation="biblio.xsd">
  ...
</bibliotheque>

Exemple de Syntaxe (fichier biblio.xsd)

C'est plus verbeux que la DTD, mais 1000x plus puissant.

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

  <!-- 1. Définir l'élément racine "bibliotheque" -->
  <xs:element name="bibliotheque">
    <xs:complexType>
      <xs:sequence>
        <!-- 2. Il contient des "livre", de 1 (minOccurs) à plusieurs (unbounded) -->
        <xs:element name="livre" type="LivreType" minOccurs="1" maxOccurs="unbounded" />
      </xs:sequence>
    </xs:complexType>
  </xs:element>

  <!-- 3. Définir un type réutilisable "LivreType" (comme une "classe") -->
  <xs:complexType name="LivreType">
    <!-- 4. Dans un ordre fixe (sequence) -->
    <xs:sequence>
      <xs:element name="titre" type="xs:string" />
      <xs:element name="auteur" type="xs:string" />
      <xs:element name="resume" type="xs:string" minOccurs="0" /> <!-- Optionnel -->
    </xs:sequence>
    
    <!-- 5. Définir les attributs -->
    <xs:attribute name="categorie" type="xs:string" use="required" />
    
    <!-- 6. Typage fort + Restriction ! -->
    <xs:attribute name="annee" use="optional">
      <xs:simpleType>
        <xs:restriction base="xs:integer">
          <xs:minInclusive value="1400" /> <!-- Doit être >= 1400 -->
        </xs:restriction>
      </xs:simpleType>
    </xs:attribute>
  </xs:complexType>

</xs:schema>

Le Problème : L'XML est "extensible", n'importe qui peut inventer des balises. Que se passe-t-il si j'inclus (j'importe) deux fichiers XML dans un seul document, et que les deux définissent une balise <table> ?

• Le premier <table> vient du HTML, et signifie "tableau d'affichage".
• Le second <table> vient d'un XML de mobilier, et signifie "meuble à 4 pieds".

Le parseur est perdu. C'est une collision de noms.

La Solution : Les Namespaces (Espaces de Noms)

Un namespace est un identifiant unique (une URI, qui ressemble à une URL mais n'a pas besoin de pointer vers un site web) qui donne un "contexte" à vos balises.

On l'utilise avec un préfixe (ex: html:) que l'on déclare avec l'attribut xmlns (XML NameSpace).

Exemple de Syntaxe

<?xml version="1.0" encoding="UTF-8"?>
<!-- 1. Déclaration des préfixes sur l'élément racine -->
<rapport xmlns:h="http://www.w3.org/1999/xhtml"
         xmlns:f="http://www.example.com/mobilier/schema">

  <description>Mon rapport de stock.</description>

  <!-- 2. Utilisation : Ce 'table' est différent... -->
  <h:table>
    <h:tr>
      <h:td>Cellule HTML</h:td>
    <h:tr>
  </h:table>

  <!-- 3. ...de ce 'table'. -->
  <f:table>
    <f:pieds>4</f:pieds>
    <f:materiau>Chêne</f:materiau>
  </f:table>

</rapport>

Désormais, le parseur sait que <h:table> et <f:table> sont deux concepts totalement différents. Il n'y a plus d'ambiguïté.

Namespace par Défaut

Si on omet le préfixe (xmlns="..." au lieu de xmlns:f="..."), ce namespace s'applique à l'élément et à tous ses enfants qui n'ont pas de préfixe. C'est très courant dans les XSD.

XPath signifie XML Path Language. C'est un langage de requêtes pour naviguer dans l'arbre DOM (Modale 3) et sélectionner des nœuds.

Pensez-y comme aux adresses de fichiers sur votre PC (C:/Dossier/Fichier.txt), mais pour XML.

Syntaxe de Base (Les Sélecteurs)

Exemples (basés sur notre XML de bibliothèque)

<bibliotheque>
  <livre categorie="Roman" annee="1862">
    <titre>Les Misérables</titre>
    <auteur>Victor Hugo</auteur>
  </livre>
  <livre categorie="Science" annee="1988">
    <titre>Une brève histoire du temps</titre>
    <auteur>Stephen Hawking</auteur>
  </livre>
</bibliotheque>

Requêtes XPath et leurs résultats :

• /bibliotheque/livre
  Résultat : Sélectionne les deux éléments <livre> (enfants directs de la racine).
• //livre
  Résultat : Sélectionne les deux éléments <livre> (où qu'ils soient).
• //livre/titre
  Résultat : Sélectionne les deux éléments <titre>.
• //livre[1]
  Résultat : Sélectionne le *premier* <livre> (celui de Victor Hugo).
• //livre[last()]
  Résultat : Sélectionne le *dernier* <livre> (celui de Stephen Hawking).
• //livre/titre/text()
  Résultat : Sélectionne les nœuds texte : "Les Misérables" et "Une brève histoire du temps".
• //@categorie
  Résultat : Sélectionne les deux attributs categorie ("Roman", "Science").
• //livre[@categorie="Science"]
  Résultat : Sélectionne le <livre> de Stephen Hawking (filtre sur attribut).
• //livre[auteur="Victor Hugo"]
  Résultat : Sélectionne le <livre> des Misérables (filtre sur texte d'un enfant).
• //livre[@annee > 1900]
  Résultat : Sélectionne le <livre> de Stephen Hawking (XPath peut comparer des nombres !).
• //livre[contains(titre, "histoire")]
  Résultat : Sélectionne le <livre> de Stephen Hawking (utilisation de fonctions).

XSLT est un langage (lui-même en XML) pour transformer un document XML en... autre chose.
Le cas d'usage le plus courant est XML -> HTML (pour l'afficher dans un navigateur). Mais il peut aussi transformer du XML en XML (restructuration) ou du XML en Texte (CSV).

Il utilise massivement XPath (Modale 8) pour sélectionner les données à transformer.

Exemple : Transformer notre XML de bibliothèque en page HTML

1. Fichier d'Entrée (biblio.xml)

<bibliotheque>
  <livre categorie="Roman">
    <titre>Les Misérables</titre>
    <auteur>Victor Hugo</auteur>
  </livre>
  <livre categorie="Science">
    <titre>Une brève histoire du temps</titre>
    <auteur>Stephen Hawking</auteur>
  </livre>
</bibliotheque>

2. Fichier de Transformation (style.xsl)

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:output method="html" /> <!-- On veut générer du HTML -->

  <!-- Règle n°1 : Quand tu rencontres la racine (match="/"), fais ceci : -->
  <xsl:template match="/">
    <html>
      <body>
        <h1>Ma Bibliothèque</h1>
        <table border="1">
          <tr><th>Titre</th><th>Auteur</th><th>Catégorie</th></tr>
          <!-- Applique maintenant les templates pour tous les 'livre' -->
          <xsl:apply-templates select="//livre" />
        </table>
      </body>
    </html>
  </xsl:template>
  
  <!-- Règle n°2 : Quand tu rencontres un "livre" (match="livre"), fais ceci : -->
  <xsl:template match="livre">
    <tr>
      <!-- Prend la valeur (value-of) du 'titre' enfant -->
      <td><xsl:value-of select="titre" /></td>
      <td><xsl:value-of select="auteur" /></td>
      <!-- Prend la valeur de l'attribut 'categorie' -->
      <td><xsl:value-of select="@categorie" /></td>
    </tr>
  </xsl:template>

</xsl:stylesheet>

3. Fichier de Sortie (Résultat)

<html>
  <body>
    <h1>Ma Bibliothèque</h1>
    <table border="1">
      <tr><th>Titre</th><th>Auteur</th><th>Catégorie</th></tr>
      <tr>
        <td>Les Misérables</td>
        <td>Victor Hugo</td>
        <td>Roman</td>
      </tr>
      <tr>
        <td>Une brève histoire du temps</td>
        <td>Stephen Hawking</td>
        <td>Science</td>
      </tr>
    </table>
  </body>
</html>

Le "Parsing" est l'acte, pour un programme (Java, Python, C#), de lire un fichier XML. Il existe deux philosophies radicalement opposées pour le faire.

1. DOM (Document Object Model) Parser

Comment il fonctionne : Le parseur lit l'intégralité du fichier XML, du début à la fin, et construit l'arbre hiérarchique (Modale 3) entièrement en mémoire RAM.
Il ne vous donne la main que lorsque l'arbre *entier* est chargé.

Cas d'usage : Petits fichiers de configuration (pom.xml, web.xml), petits fichiers de données (< 10 Mo).

2. SAX (Simple API for XML) Parser

Comment il fonctionne : C'est un parseur "événementiel" (streaming). Il lit le fichier XML ligne par ligne (ou plutôt, balise par balise) et ne stocke rien en mémoire.
Il vous "appelle" (via des callbacks) à chaque fois qu'il rencontre quelque chose :
1. startDocument() : "OK, je commence."
2. startElement() : "Hé, je viens de trouver une balise ouvrante <livre>."
3. characters() : "Hé, j'ai trouvé du texte : 'Victor Hugo'."
4. endElement() : "Hé, je viens de trouver une balise fermante </livre>."
5. endDocument() : "OK, j'ai fini."

Cas d'usage : Fichiers de logs très volumineux, flux de données (streaming), import/export de masse (ex: Talend utilise SAX en interne).

Le JSON a gagné la guerre des "API web légères", mais l'XML reste le pilier indétrônable de l'informatique d'entreprise "sérieuse" et des formats de documents.