Skip to content

XML Aide-mémoire

Extensible Markup Language pour l'échange de données structurées.

01

Premiers pas

Structure de document XML

Les documents XML commencent par une déclaration XML. Les éléments doivent être correctement imbriqués et fermés. Les attributs fournissent des métadonnées supplémentaires. xmlns déclare les namespaces XML pour éviter les conflits de noms.

xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- This is a comment -->
<bookstore xmlns="https://example.com/books">
  <book id="b1" category="fiction">
    <title lang="en">The Great Gatsby</title>
    <author>F. Scott Fitzgerald</author>
    <price currency="USD">12.99</price>
  </book>
  <book id="b2" category="programming">
    <title lang="en">XML Guide</title>
    <author>John Doe</author>
    <price currency="USD">29.99</price>
  </book>
</bookstore>

Déclaration XML

La déclaration XML est la première ligne du prologue. 'version' est requise (1.0 ou 1.1). 'encoding' passe par défaut à UTF-8. 'standalone' dit aux parseurs si des déclarations DTD externes sont nécessaires.

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

<!-- version is required; encoding and standalone are optional -->
<!-- encoding defaults to UTF-8 -->
<!-- standalone="yes" means no external markup declarations -->

<root>
  <child>text</child>
</root>

Commentaires et instructions de traitement

Les commentaires utilisent <!-- --> et ne peuvent ni s'imbriquer ni contenir '--' à l'intérieur. Les instructions de traitement (PI) comme xml-stylesheet passent des infos propres à l'app au parseur. Les PI utilisent <?cible donnees?>.

xml
<?xml version="1.0"?>
<!-- a comment: ignored by the parser, cannot contain -- -->

<?xml-stylesheet type="text/xsl" href="style.xsl"?>

<root>
  <!-- comments can span
       multiple lines -->
  <item>data</item>
</root>

XML bien formé

Bien formé signifie : un élément racine unique, un bon imbriquement, tous les tags fermés, attributs quotés, pas d'attributs dupliqués. Un document DOIT être bien formé pour être parseable ; la validité (face à une DTD/Schema) est optionnelle.

xml
<!-- WELL-FORMED: single root, properly nested, closed -->
<root>
  <a>
    <b>text</b>
  </a>
</root>

<!-- NOT well-formed: two roots, overlapping tags -->
<!-- <a><b></a></b> -->
<!-- <x></x><y></y>   (no single root) -->

<!-- All attributes must be quoted -->
<item id='1' type="x"/>

Prologue XML et espaces

Le prologue inclut la déclaration XML et un DOCTYPE optionnel. xml:space='preserve' dit aux parseurs de garder les espaces ; 'default' autorise le traitement normal. Les espaces entre éléments sont généralement non significatifs.

xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE root SYSTEM "root.dtd">
<root xml:space="preserve">
  <item>  spaced  text  </item>
  <item xml:space="default">  trimmed  </item>
</root>

Aperçu de CDATA

Les sections CDATA marquent du texte que le parseur ne doit pas interpréter comme balisage. À l'intérieur de CDATA, des caractères comme <, > et & n'exigent pas d'échappement. CDATA ne peut pas s'imbriquer et ne peut pas contenir le littéral ']]>'.

xml
<?xml version="1.0"?>
<root>
  <code><![CDATA[
    if (a < b && c > d) {
      console.log("no escaping needed: < > & ");
    }
  ]]></code>
</root>
02

Éléments et attributs

Éléments vs attributs

Les attributs conviennent aux métadonnées (ids, types, flags) ; les éléments aux données avec structure ou valeurs répétées. Un attribut apparaît une fois par élément et ne peut pas tenir de structure imbriquée. Pas de règle stricte — la cohérence compte le plus.

xml
<!-- Attributes: metadata/identifiers; Elements: data -->
<person id="p1">
  <name>Alice</name>
  <age>30</age>
</person>

<!-- vs. putting everything in attributes -->
<person id="p1" name="Alice" age="30"/>

<!-- Rule of thumb: use elements for data you display,
     attributes for IDs, types, and metadata -->

Éléments vides

Un élément vide n'a pas de contenu. La forme auto-fermante <tag/> est un raccourci de <tag></tag>. L'espace avant '/>' est une convention de style pour la lisibilité et la compatibilité XHTML.

xml
<!-- Three equivalent empty-element forms -->
<br></br>
<br/>
<br />

<!-- empty element with attributes -->
<img src="logo.png" alt="Logo" width="200" height="100"/>

<!-- self-closing with namespace -->
<xlink:link xmlns:xlink="http://www.w3.org/1999/xlink" href="#sec1"/>

Éléments imbriqués

Les éléments s'imbriquent hiérarchiquement et doivent se fermer en ordre inverse — ils ne peuvent pas se chevaucher. L'imbrication exprime la structure. Les arbres profondément imbriqués sont valides mais peuvent nuire à la lisibilité et à la performance de parsing.

xml
<library>
  <section name="fiction">
    <book>
      <title>Book A</title>
      <authors>
        <author>Author 1</author>
        <author>Author 2</author>
      </authors>
    </book>
  </section>
</library>

<!-- WRONG: tags must not overlap -->
<!-- <a><b></a></b> -->

Valeurs d'attributs et guillemets

Les valeurs d'attributs doivent être quotées avec guillemets simples ou doubles. Les doubles guillemets dans des valeurs double-quotées doivent s'échapper en &quot;. Un attribut ne peut apparaître qu'une fois par élément — utilisez des éléments enfants pour les valeurs répétées.

xml
<!-- Both single and double quotes are allowed -->
<item id="q1" name='quick'/>
<msg text="He said &quot;hi&quot;"/>
<msg text='She said &apos;hi&apos;'/>

<!-- attribute values MUST be quoted -->
<!-- <item id=q1/>  is NOT well-formed -->

<!-- an attribute can appear at most once per element -->
<point x="1" y="2" z="3"/>

Attributs par défaut et fixes

Les déclarations d'attributs DTD supportent #REQUIRED (doit apparaître), #IMPLIED (optionnel), #FIXED (valeur constante) et un défaut littéral. Un attribut #FIXED doit toujours égaler sa valeur déclarée sinon le document est invalide.

xml
<!-- In a DTD, attributes can have defaults -->
<!ATTLIST item
    type    CDATA     "standard"
    status  CDATA     #REQUIRED
    version CDATA     #FIXED "1.0"
    note    CDATA     #IMPLIED>

<item status="active"/>
<!-- 'type' defaults to "standard", 'version' is fixed,
     'note' is optional (#IMPLIED) -->

Règles de nommage des éléments

Les noms d'éléments doivent commencer par une lettre ou underscore et peuvent contenir lettres, chiffres, tirets, underscores et points. Les noms ne peuvent pas commencer par 'xml' (toute casse). XML est sensible à la casse, donc <Tag> et <tag> diffèrent.

xml
<!-- Names: start with a letter or underscore,
     continue with letters, digits, hyphens, underscores, dots -->
<my-element>ok</my-element>
<my.element>ok</my.element>
<my_element>ok</my_element>
<_private>ok</_private>
<x-1>ok</x-1>

<!-- NOT allowed: starting with a digit or 'xml', containing spaces -->
<!-- <2way/> -->
<!-- <my element/> -->
<!-- <XmlTag/>  (names are case-sensitive; 'xml' prefix is reserved) -->
03

Namespaces

Namespace par défaut

Un namespace par défaut (xmlns=URI) s'applique à l'élément où il se déclare et à tous les descendants sans préfixe. Les éléments enfants l'héritent sauf surcharge. Les attributs n'utilisent jamais le namespace par défaut.

xml
<?xml version="1.0"?>
<table xmlns="http://www.w3.org/1999/xhtml">
  <tr>
    <td>Cell content</td>
    <td>More content</td>
  </tr>
</table>
<!-- All elements without a prefix use the default namespace -->

Préfixe de namespace

Un préfixe de namespace se déclare avec xmlns:prefixe=URI et s'utilise comme prefixe:element. Le préfixe n'est qu'un alias — seul l'URI compte pour l'identité. Les préfixes sont sensibles à la casse.

xml
<?xml version="1.0"?>
<root xmlns:bk="https://example.com/books"
      xmlns:au="https://example.com/authors">
  <bk:book bk:id="b1">
    <au:author au:name="Jane Doe"/>
    <bk:title>XML Guide</bk:title>
  </bk:book>
</root>

Namespaces multiples

Un seul document peut mêler beaucoup de namespaces. Déclarez chaque préfixe une fois (généralement à la racine) et réutilisez-le. Déclarer un namespace sur un élément s'applique à cet élément et ses descendants.

xml
<?xml version="1.0"?>
<soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <soap:Body>
    <m:GetPrice xsi:type="xsd:string"
                xmlns:m="https://example.com/pricing">
      <m:Item>Apples</m:Item>
    </m:GetPrice>
  </soap:Body>
</soap:Envelope>

Portée de namespace

Les déclarations de namespace se délimitent à l'élément où elles apparaissent et ses descendants. Une redéclaration dans un enfant surcharge le mapping de préfixe du parent pour ce sous-arbre. Le mapping d'origine se restaure après fermeture de l'enfant.

xml
<?xml version="1.0"?>
<root xmlns:a="http://a.example">
  <a:item>A</a:item>
  <child xmlns:a="http://b.example">
    <!-- here 'a' is REBOUND to the b.example URI -->
    <a:item>B</a:item>
  </child>
  <!-- outside child, 'a' is back to a.example -->
  <a:item>A again</a:item>
</root>

Namespaces courants

Ces URIs sont des identifiants bien connus, pas des URLs à fetcher. Le namespace xsi fournit les attributs schema-instance (type, nil, schemaLocation). XSD, XSL, SVG, SOAP, Atom et Dublin Core (dc) ont chacun des URIs standard.

xml
<!-- Frequently used namespace URIs -->
xmlns:xsi  = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:xsd  = "http://www.w3.org/2001/XMLSchema"
xmlns:xsl  = "http://www.w3.org/1999/XSL/Transform"
xmlns:svg  = "http://www.w3.org/2000/svg"
xmlns:html = "http://www.w3.org/1999/xhtml"
xmlns:soap = "http://schemas.xmlsoap.org/soap/envelope/"
xmlns:atom = "http://www.w3.org/2005/Atom"
xmlns:dc   = "http://purl.org/dc/elements/1.1/"

Target namespace en XSD

Le targetNamespace d'un schéma est le namespace des éléments qu'il définit. elementFormDefault='qualified' signifie que les éléments localement déclarés sont dans le namespace cible. Le préfixe tns est une convention pour « ce namespace ».

xml
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="https://example.com/orders"
           xmlns:tns="https://example.com/orders"
           elementFormDefault="qualified">
  <xs:element name="order" type="tns:OrderType"/>
  <xs:complexType name="OrderType">
    <xs:sequence>
      <xs:element name="item" type="xs:string"/>
    </xs:sequence>
  </xs:complexType>
</xs:schema>
04

CDATA et entités

Entités prédéfinies

XML prédéfinit cinq entités : &lt; (<), &gt; (>), &amp; (&), &apos; ('), &quot; ("). & doit TOUJOURS s'échapper (même dans du texte sans CDATA) ; < doit s'échapper sauf comme début de tag ; les guillemets comptent surtout dans les attributs.

xml
<?xml version="1.0"?>
<root>
  <lt>less than: &lt;</lt>
  <gt>greater than: &gt;</gt>
  <amp>ampersand: &amp;</amp>
  <apos>apostrophe: &apos;</apos>
  <quot>quote: &quot;</quot>
  <!-- &lt; &gt; &amp; &apos; &quot; are the 5 built-in entities -->
</root>

Références de caractères

Les références de caractères utilisent un point de code Unicode : &#169; (décimal) ou &#xA9; (hex) pour ©. Elles marchent dans le texte d'élément et les valeurs d'attributs et ne sont pas affectées par l'encodage. Elles peuvent représenter tout caractère Unicode.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <decimal>&#169; 2024 Company</decimal>
  <hex>&#xA9; 2024 Company</hex>
  <euro>Price: &#x20AC;10</euro>
  <emoji>Smile: &#x1F600;</emoji>
</root>
<!-- &#NNN;  decimal code point -->
<!-- &#xHHH; hexadecimal code point -->

Sections CDATA

Les sections CDATA permettent d'inclure <, > et & sans échappement — utiles pour code et balisage. CDATA ne peut pas contenir ']]>' littéralement ; pour l'embarquer, scindez la section comme montré. CDATA est de la donnée caractère, pas parsée en éléments.

xml
<?xml version="1.0"?>
<root>
  <script><![CDATA[
    function check(a, b) {
      if (a < b && b > 0) {
        return a & b;
      }
    }
  ]]></script>
  <!-- to include ]]> inside CDATA, split it -->
  <data><![CDATA[foo]]]]><![CDATA[>bar]]></data>
</root>

Entités personnalisées (DTD)

Les entités internes se déclarent dans une DTD et s'expansent là où elles sont référencées. Elles agissent comme des macros de texte et peuvent référencer d'autres entités. Utiles pour du boilerplate répété. Attention : les entités externes/générales peuvent être un risque de sécurité XXE.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!ENTITY company "Acme Corp.">
  <!ENTITY version "2.0">
  <!ENTITY copyright "Copyright © 2024 &company;">
]>
<root>
  <product>&company; Toolkit v&version;</product>
  <footer>&copyright;</footer>
</root>
<!-- Entities are expanded during parsing -->

Échappement dans les attributs

Dans les valeurs d'attributs, il faut échapper & en &amp;, et échapper le caractère de guillemet utilisé pour délimiter la valeur (&quot; ou &apos;). < devrait aussi s'échapper. Les retours à la ligne et tabulations dans les attributs se normalisent en espaces par le parseur.

xml
<?xml version="1.0"?>
<root>
  <link url="https://example.com?a=1&amp;b=2"/>
  <msg text="Say &quot;hello&quot; &amp; smile"/>
  <path value='C:\Users\name'/>
  <data value="&lt;tagged&gt;"/>
</root>

Entités paramètres

Les entités paramètres (déclarées avec %) servent seulement dans les DTD à bâtir des modèles de contenu réutilisables. Elles se référencent %nom; (avec point-virgule). Les entités générales (&nom;) s'utilisent dans le contenu du document.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!ENTITY % inline " (#PCDATA | em | strong)* ">
  <!ELEMENT p %inline;>
  <!ELEMENT em %inline;>
  <!ELEMENT strong %inline;>
  <!ELEMENT root (p)*>
]>
<root>
  <p>Hello <em>world</em> and <strong>XML</strong>.</p>
</root>
05

DTD (Document Type Definition)

DTD interne

Une DTD interne se déclare en ligne dans le DOCTYPE entre crochets. Elle définit la structure : quels éléments existent, leurs modèles de contenu et attributs. Les DTD internes sont autonomes mais ne s'appliquent qu'à ce seul document.

xml
<?xml version="1.0"?>
<!DOCTYPE note [
  <!ELEMENT note (to, from, heading, body)>
  <!ELEMENT to (#PCDATA)>
  <!ELEMENT from (#PCDATA)>
  <!ELEMENT heading (#PCDATA)>
  <!ELEMENT body (#PCDATA)>
]>
<note>
  <to>Alice</to>
  <from>Bob</from>
  <heading>Reminder</heading>
  <body>Don't forget the meeting</body>
</note>

DTD externe

Une DTD externe vit dans un fichier .dtd séparé référencé par SYSTEM (privé) ou PUBLIC (identifiant public + URI). Les DTD externes laissent beaucoup de documents partager une définition. SYSTEM 'fichier.dtd' est la forme la plus courante.

xml
<!-- File: note.dtd -->
<!ELEMENT note (to, from, body)>
<!ELEMENT to (#PCDATA)>
<!ELEMENT from (#PCDATA)>
<!ELEMENT body (#PCDATA)>

<!-- File: note.xml -->
<?xml version="1.0"?>
<!DOCTYPE note SYSTEM "note.dtd">
<note>
  <to>Alice</to>
  <from>Bob</from>
  <body>Hello</body>
</note>

Déclarations d'éléments

Les modèles de contenu utilisent , (séquence), | (choix), ? (0-1), * (0+), + (1+). #PCDATA est du texte ; le contenu mixte autorise du texte entrecoupé d'éléments. EMPTY signifie pas de contenu ; ANY désactive la vérification (à éviter en production).

xml
<!ELEMENT root (child1, child2*)>
<!-- content model operators -->
<!ELEMENT list (item+)>            <!-- one or more item -->
<!ELEMENT opt (item?)>             <!-- zero or one item   -->
<!ELEMENT any (item1 | item2)*>    <!-- choice, any number  -->
<!ELEMENT text (#PCDATA)>          <!-- parsed character data -->
<!ELEMENT mixed (#PCDATA | em)*>   <!-- mixed content -->
<!ELEMENT empty EMPTY>             <!-- no content -->
<!ELEMENT any ANY>                 <!-- any content -->

Déclarations d'attributs

ATTLIST déclare le type et le défaut d'un attribut. ID est un identifiant unique ; IDREF/IDREFS référencent des IDs (pour les liens croisés). NMTOKEN est un token de nom. Les types énumérés listent les valeurs autorisées. Défauts : #REQUIRED, #IMPLIED, #FIXED, ou un littéral.

xml
<!ATTLIST book
    id      ID         #REQUIRED
    category CDATA     #IMPLIED
    lang    NMTOKEN    "en"
    status  (draft|final) "draft"
    version CDATA      #FIXED "1.0">

<!-- Types: CDATA, ID, IDREF, IDREFS, NMTOKEN, NMTOKENS,
     NOTATION, enumerated (a|b|c) -->
<!ATTLIST link ref IDREF #REQUIRED>

Déclarations d'entités

Les entités générales (&nom;) s'expansent dans le contenu ; les entités paramètres (%nom;) dans la DTD. Les entités parsées externes incluent d'autres XML ; les entités non parsées (avec NDATA) pointent vers des données non XML référencées via NOTATION. Les entités externes peuvent causer l'injection XXE.

xml
<!DOCTYPE root [
  <!-- internal general entity -->
  <!ENTITY name "Alice">
  <!-- external parsed entity -->
  <!ENTITY chap1 SYSTEM "chapter1.xml">
  <!-- unparsed entity (binary, e.g. image) -->
  <!ENTITY logo SYSTEM "logo.png" NDATA image>
  <!-- notation declaration for unparsed entities -->
  <!NOTATION image SYSTEM "image/png">
  <!-- parameter entity (DTD-only) -->
  <!ENTITY % block "(p | list)+">
]>
<root>&name;</root>

Validation DTD

La validation vérifie qu'un document matche sa DTD (ordre des éléments, attributs autorisés, unicité des IDs). Les parseurs DOM standard comme minidom ne valident PAS par défaut — utilisez lxml (Python), xmllint (ligne de commande) ou un parseur validant.

xml
<?xml version="1.0"?>
<!DOCTYPE root SYSTEM "schema.dtd">
<root>
  <item id="x1">valid</item>
</root>

<!-- Validate with Python: -->
<!-- import xml.dom.minidom as m
dom = m.parse("file.xml")
# minidom does NOT validate; use lxml: -->
<!-- from lxml import etree
dtd = etree.DTD("schema.dtd")
tree = etree.parse("file.xml")
print(dtd.validate(tree)) -->
06

XML Schema (XSD)

Structure de schéma

Un XSD est lui-même un document XML. La racine <schema> déclare le namespace XSD et un namespace cible pour les éléments qu'il définit. elementFormDefault='qualified' met les éléments locaux dans le namespace cible.

xml
<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="https://example.com/order"
           xmlns:tns="https://example.com/order"
           elementFormDefault="qualified">

  <xs:element name="order" type="tns:OrderType"/>

  <xs:complexType name="OrderType">
    <xs:sequence>
      <xs:element name="customer" type="xs:string"/>
      <xs:element name="total" type="xs:decimal"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:ID" use="required"/>
  </xs:complexType>
</xs:schema>

Types simples

Un simpleType restreint un type de base avec des facets (pattern, minInclusive, enumeration, length, etc.). Les types simples n'ont que du contenu texte et des attributs — pas d'éléments enfants. Ils sont réutilisables dans tout le schéma.

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

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

<xs:element name="email" type="tns:emailType"/>
<xs:element name="age" type="tns:ageType"/>

Types complexes

Un complexType peut tenir des éléments enfants et attributs. sequence impose l'ordre ; choice autorise un parmi plusieurs ; all autorise n'importe quel ordre (chacun au plus une fois). Les compositors peuvent s'imbriquer pour exprimer des structures riches.

xml
<xs:complexType name="AddressType">
  <xs:sequence>
    <xs:element name="street" type="xs:string"/>
    <xs:element name="city" type="xs:string"/>
    <xs:element name="zip" type="xs:string"/>
  </xs:sequence>
  <xs:attribute name="country" type="xs:string" default="US"/>
</xs:complexType>

<!-- Content model indicators: sequence, choice, all -->
<xs:complexType name="ContactType">
  <xs:choice>
    <xs:element name="phone" type="xs:string"/>
    <xs:element name="email" type="xs:string"/>
  </xs:choice>
</xs:complexType>

Types intégrés

XSD fournit une hiérarchie de types riche : chaînes, nombres (integer, decimal, float), dates/heures, boolean, anyURI, ID/IDREF et QName. Chacun supporte des facets comme length, pattern et enumeration pour une restriction supplémentaire.

xml
<!-- Common XSD built-in types -->
<xs:element name="count"  type="xs:integer"/>
<xs:element name="price"  type="xs:decimal"/>
<xs:element name="flag"   type="xs:boolean"/>
<xs:element name="name"   type="xs:string"/>
<xs:element name="date"   type="xs:date"/>        <!-- 2024-01-15 -->
<xs:element name="time"   type="xs:time"/>        <!-- 13:45:00 -->
<xs:element name="dt"     type="xs:dateTime"/>    <!-- 2024-01-15T13:45:00 -->
<xs:element name="id"     type="xs:ID"/>
<xs:element name="ref"    type="xs:IDREF"/>
<xs:element name="uri"    type="xs:anyURI"/>

Restrictions (facets)

Les facets contraignent les types simples : enumeration (valeurs autorisées), pattern (regex), length/minLength/maxLength, min/maxInclusive/Exclusive, totalDigits, fractionDigits et whiteSpace (preserve/replace/collapse).

xml
<xs:simpleType name="ColorType">
  <xs:restriction base="xs:string">
    <xs:enumeration value="red"/>
    <xs:enumeration value="green"/>
    <xs:enumeration value="blue"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="PasswordType">
  <xs:restriction base="xs:string">
    <xs:minLength value="8"/>
    <xs:maxLength value="32"/>
    <xs:pattern value="[A-Za-z0-9!@#]+"/>
  </xs:restriction>
</xs:simpleType>

Éléments et attributs en XSD

minOccurs/maxOccurs contrôlent la cardinalité (défaut 1) ; maxOccurs='unbounded' autorise n'importe quel nombre. L'attribut 'use' est required/optional/prohibited, avec un défaut ou une valeur fixe optionnelle. Les complexTypes anonymes inline la définition.

xml
<xs:element name="product">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="name" type="xs:string"
                  minOccurs="1" maxOccurs="1"/>
      <xs:element name="tag" type="xs:string"
                  minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
    <xs:attribute name="sku" type="xs:string" use="required"/>
    <xs:attribute name="weight" type="xs:decimal" use="optional"
                  default="0.0"/>
  </xs:complexType>
</xs:element>
07

XPath

Expressions de chemin

XPath utilise des expressions façon chemin. '/' sélectionne depuis la racine ; '//' les descendants à toute profondeur. '*' est un wildcard pour tout élément ; '@' sélectionne les attributs. Une expression commençant par '/' est absolue.

xml
<!-- Sample: <bookstore><book><title>..</title></book></bookstore> -->

/bookstore/book/title       <!-- absolute path -->
bookstore/book/title        <!-- relative path -->
//title                     <!-- any title, anywhere -->
/bookstore//title           <!-- title anywhere under bookstore -->
bookstore/*                 <!-- all children of bookstore -->
//@lang                     <!-- all lang attributes -->
//@*                        <!-- all attributes -->

Prédicats

Les prédicats dans [ ] filtrent un ensemble de nœuds. L'indexation commence à 1. last() et position() désignent la position du nœud dans son contexte. Les prédicats peuvent tester le texte d'élément, les attributs (@nom) ou des valeurs calculées.

xml
//book[1]                  <!-- first book -->
//book[last()]            <!-- last book -->
//book[position() <= 3]   <!-- first three books -->
//book[price > 25]        <!-- books with price > 25 -->
//book[@category='web']   <!-- books in the web category -->
//book[author='Smith']    <!-- books authored by Smith -->
//book[@lang][2]          <!-- 2nd book that has a lang attr -->

Axes

Les axes définissent les directions de navigation : child (défaut), descendant, parent (..), ancestor, following-sibling, preceding-sibling, attribute (@), self (.), descendant-or-self (//). La plupart ont des formes raccourcies utilisées en pratique.

xml
child::book            <!-- default axis: children named book -->
descendant::title      <!-- all title descendants -->
parent::*              <!-- the parent element (shorthand: ..) -->
ancestor::section      <!-- all section ancestors -->
following-sibling::p   <!-- p elements after this one -->
preceding::item        <!-- items before this in document order -->
attribute::id          <!-- the id attribute (shorthand: @id) -->
self::node()           <!-- the current node (shorthand: .) -->

Fonctions

XPath 1.0 a des fonctions intégrées : count, sum, string-length, contains, starts-with, normalize-space, name, concat, substring, round et plus. XPath 2.0+ élargit considérablement la bibliothèque de fonctions et ajoute le typage.

xml
count(//book)                  <!-- number of book elements -->
string-length(//title)        <!-- length of first title's text -->
contains(//name, 'Ali')       <!-- true if name contains 'Ali' -->
starts-with(@id, 'b')         <!-- true if id starts with 'b' -->
normalize-space(//summary)    <!-- collapse whitespace -->
name(//*[1])                  <!-- name of the first element -->
concat(/a, /b)                <!-- concatenate strings -->
sum(//price)                  <!-- sum of all price values -->

Opérateurs

XPath utilise = pour l'égalité (un seul =, pas ==), et les opérateurs 'and'/'or' pour la logique (pas && / ||). 'div' est la division et 'mod' le modulo, puisque '/' est réservé aux chemins. '|' calcule l'union d'ensembles de nœuds.

xml
<!-- Comparison: =, !=, <, >, <=, >= -->
//book[price = 29.99]
//book[price < 20]

<!-- Logical: and, or -->
//book[price > 10 and price < 30]
//book[@cat='a' or @cat='b']

<!-- Arithmetic: + - * div mod -->
//item[price * quantity > 100]
5 div 2        <!-- 2.5 -->
5 mod 2        <!-- 1 -->

<!-- Union: | -->
//book | //magazine

Exemples XPath

Ces patterns combinent chemins, prédicats et fonctions pour de vraies requêtes. text() sélectionne le nœud texte ; min() exige XPath 2.0+. Le wildcard //* avec un prédicat est un moyen courant de trouver des éléments par attribut dans tout l'arbre.

xml
<!-- Select all book titles priced over 20 -->
//book[price > 20]/title/text()

<!-- The category of the cheapest book -->
//book[price = min(//book/price)]/@category

<!-- Authors of books in the 'programming' category -->
//book[@category='programming']/author

<!-- Every 2nd item in each list -->
//list/item[position() mod 2 = 0]

<!-- Elements with a specific attribute value -->
//*[@lang='fr']
08

Transformations XSLT

Transformation de base

Une feuille de style XSLT est du XML. Les templates matchent les nœuds avec XPath ; apply-templates traite récursivement les nœuds sélectionnés. value-of extrait le texte. Le template match='/' tourne en premier, sur la racine du document.

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

  <xsl:template match="/">
    <html>
      <body>
        <h2>Book List</h2>
        <xsl:apply-templates select="bookstore/book"/>
      </body>
    </html>
  </xsl:template>

  <xsl:template match="book">
    <p><xsl:value-of select="title"/> - <xsl:value-of select="price"/></p>
  </xsl:template>
</xsl:stylesheet>

xsl:template et apply-templates

Les templates match se déclenchent quand le processeur visite les nœuds correspondants ; les templates nommés s'appellent explicitement avec call-template. apply-templates sans select traite tous les enfants, permettant des transformations récursives pilotées par règles.

xml
<xsl:template match="book">
  <div class="book">
    <xsl:apply-templates select="title"/>
    <xsl:apply-templates select="author"/>
  </div>
</xsl:template>

<xsl:template match="title">
  <h3><xsl:apply-templates/></h3>
</xsl:template>

<!-- named template (like a function) -->
<xsl:template name="divider">
  <hr/>
</xsl:template>

xsl:value-of et xsl:for-each

xsl:for-each itère un ensemble de nœuds, changeant le nœud de contexte. Souvent plus simple que les templates pour une sortie plate, mais l'abus rend les feuilles de style procédurales. Préférez templates et apply-templates pour les structures récursives.

xml
<xsl:template match="/">
  <ul>
    <xsl:for-each select="bookstore/book">
      <li>
        <xsl:value-of select="title"/>
        (<xsl:value-of select="@category"/>)
      </li>
    </xsl:for-each>
  </ul>
</xsl:template>

<!-- value-of outputs the string value of an expression -->

xsl:if et xsl:choose

xsl:if n'a pas de else — utilisez xsl:choose pour les branchements multiples. L'expression 'test' suit les règles booléennes XPath : un ensemble de nœuds non vide est vrai, un vide faux, les nombres non nuls vrais.

xml
<xsl:for-each select="bookstore/book">
  <xsl:if test="price > 25">
    <premium><xsl:value-of select="title"/></premium>
  </xsl:if>

  <xsl:choose>
    <xsl:when test="@category='fiction'">F</xsl:when>
    <xsl:when test="@category='programming'">P</xsl:when>
    <xsl:otherwise>?</xsl:otherwise>
  </xsl:choose>
</xsl:for-each>

<!-- test uses XPath; non-empty node-sets and non-zero numbers are true -->

xsl:sort et xsl:variable

xsl:sort réordonne l'ensemble de nœuds courant par une ou plusieurs clés ; data-type est 'text' ou 'number'. Les variables (xsl:variable) sont immuables et délimitées. Rappelez-vous d'échapper < en &lt; dans les valeurs d'attributs du XML de la feuille de style.

xml
<xsl:variable name="max-price" select="50"/>

<xsl:for-each select="bookstore/book[price &lt; $max-price]">
  <xsl:sort select="price" data-type="number" order="descending"/>
  <xsl:sort select="title" order="ascending"/>
  <p>
    <xsl:value-of select="title"/>: <xsl:value-of select="price"/>
  </p>
</xsl:for-each>

<!-- Note: in XSLT, < must be written &lt; inside test attributes -->

xsl:apply-templates et modes

Les modes laissent un même ensemble de nœuds sources se traiter de différentes façons (ex. une table des matières vs les entrées complètes). L'attribut mode sur template et apply-templates doit correspondre. Sans mode, seuls les templates sans mode s'appliquent.

xml
<!-- A template can have a 'mode' for different outputs -->
<xsl:template match="book" mode="list">
  <li><xsl:value-of select="title"/></li>
</xsl:template>

<xsl:template match="book" mode="detail">
  <div><h3><xsl:value-of select="title"/></h3>
       <p><xsl:value-of select="author"/></p></div>
</xsl:template>

<!-- Invoke a specific mode -->
<xsl:apply-templates select="bookstore/book" mode="list"/>
<xsl:apply-templates select="bookstore/book" mode="detail"/>
09

XQuery

Expressions FLWOR

FLWOR est la construction cœur de XQuery : for lie des variables aux éléments de séquence, let lie des valeurs calculées, where filtre, order by trie et return façonne la sortie. Cela rappelle le SELECT-FROM-WHERE de SQL.

xml
for $b in /bookstore/book
let $discount := $b/price * 0.9
where $b/price > 20
order by $b/price descending
return
  <book>
    <title>{ $b/title/text() }</title>
    <salePrice>{ $discount }</salePrice>
  </book>

<!-- FLWOR = For, Let, Where, Order by, Return -->

Expressions de chemin

XQuery embarque XPath directement. doc('fichier.xml') charge un document ; collection('uri') interroge plusieurs documents. Les expressions de chemin retournent des séquences de nœuds, que les expressions FLWOR peuvent itérer.

xml
(: XQuery uses XPath for navigation :)
/bookstore/book/title/text()
/bookstore/book[@category='web']
//author[contains(., 'Smith')]

(: Use doc() to open an external document :)
doc('catalog.xml')//book[price < 30]

(: collection() queries a set of documents :)
collection('/db/books')//title

Prédicats et jointures

Plusieurs clauses 'for' forment une jointure (comme SQL JOIN). XQuery fait les jointures en itérant les combinaisons et filtrant avec where. Pour les grands jeux de données, les jointures explicites via prédicats ou clés sont plus efficaces que les boucles imbriquées.

xml
(: Join books to authors by id :)
for $b in doc('books.xml')//book
for $a in doc('authors.xml')//author
where $b/@author-id = $a/@id
return
  <entry>
    <title>{ $b/title/text() }</title>
    <author>{ $a/name/text() }</author>
  </entry>

(: Equivalent join with a predicate :)
for $b in doc('books.xml')//book
return
  <entry>{ $b/title, $b/@author-id }</entry>

Conditionnel et quantifié

XQuery a if-then-else (le else est obligatoire), des expressions quantifiées (some/every ... satisfies) et typeswitch pour brancher sur le type de nœud. Les conditions utilisent une sémantique booléenne style XPath.

xml
(: if-then-else :)
for $b in //book
return
  if ($b/price > 30) then <expensive>{ $b/title }</expensive>
  else <cheap>{ $b/title }</cheap>

(: quantified expressions :)
some $a in //author satisfies contains($a, 'Smith')
every $p in //price satisfies $p > 0

(: typeswitch for type-based dispatch :)
typeswitch($node)
  case element(book) return "book"
  case element(author) return "author"
  default return "other"

Fonctions

XQuery réutilise les fonctions XPath et en ajoute beaucoup (string-join, distinct-values, avg, min, max). Les fonctions utilisateur se déclarent dans le module avec types de paramètres et de retour, dans le namespace local: par convention.

xml
(: Built-in functions :)
concat('a', 'b', 'c')
string-join(//title, ', ')
count(//book)
distinct-values(//book/@category)
avg(//book/price)
max(//book/price)

(: User-defined function :)
declare function local:discount($price as xs:decimal)
  as xs:decimal {
  $price * 0.9
};

local:discount(29.99)

Construire du XML

XQuery bâtit du XML avec des constructeurs directs (tags littéraux avec { } pour les expressions embarquées) ou calculés (element name { ... }). Les accolades évaluent les expressions encloses ; les attributs peuvent embarquer des valeurs inline.

xml
(: Direct element construction :)
<result>
  <count>{ count(//book) }</count>
  <books>
    { for $b in //book return <book title="{ $b/title/text() }"/> }
  </books>
</result>

(: Computed constructors :)
element result {
  attribute total { count(//book) },
  for $b in //book
  return element book { $b/title/text() }
}

(: Enclosed expressions use { } to embed values -->
10

Parsing DOM

Charger du XML (JavaScript)

DOMParser transforme une chaîne XML en arbre DOM dans le navigateur ; les erreurs de parsing apparaissent comme un élément <parsererror> plutôt qu'une exception. Node.js n'a pas de DOM XML intégré — utilisez xmldom, @xmldom/xmldom ou un parseur en streaming.

xml
// Browser: parse an XML string
const parser = new DOMParser();
const doc = parser.parseFromString(xmlString, "application/xml");

const errorNode = doc.querySelector("parsererror");
if (errorNode) {
  console.error("Parse error:", errorNode.textContent);
}

const books = doc.getElementsByTagName("book");
for (const book of books) {
  console.log(book.getAttribute("id"));
}

// Node.js: use xmldom or fast-xml-parser instead

Traversée DOM

L'API DOM expose documentElement, children, childNodes et nextSibling pour la traversée. nodeType 1 est un élément, 3 du texte, 8 un commentaire. document.evaluate exécute XPath dans les navigateurs (Node exige des bibliothèques xpath).

xml
// JavaScript DOM API (also works for XML documents)
const root = doc.documentElement;        // <bookstore>
const firstBook = root.children[0];      // first <book>
const titles = doc.getElementsByTagName("title");

// walk children
let node = root.firstChild;
while (node) {
  if (node.nodeType === 1) {             // Element node
    console.log(node.tagName);
  }
  node = node.nextSibling;
}

// XPath against the DOM
const it = doc.evaluate("//book[@id='b1']", doc, null,
                        XPathResult.ANY_TYPE, null);
const found = it.iterateNext();

Modifier le DOM

createElement/setAttribute/appendChild bâtissent et attachent des nœuds ; textContent règle le texte. XMLSerializer reconvertit un DOM en chaîne. Le DOM est vivant — les mutations se reflètent immédiatement dans toute référence.

xml
const book = doc.createElement("book");
book.setAttribute("id", "b3");

const title = doc.createElement("title");
title.textContent = "New Book";
book.appendChild(title);

root.appendChild(book);                  // add to tree

// change an existing element
const price = doc.querySelector("book:nth-child(2) price");
price.textContent = "19.99";
price.setAttribute("currency", "EUR");

// serialize back to a string
const xml = new XMLSerializer().serializeToString(doc);

Créer des éléments

minidom permet de bâtir un document from scratch : createDocument pour la racine, createElement/setAttribute/createTextNode pour le contenu, appendChild pour lier. toprettyxml sérialise avec indentation. minidom est simple mais lent pour les grands arbres.

xml
// Python: xml.dom.minidom
from xml.dom import minidom

impl = minidom.getDOMImplementation()
doc = impl.createDocument(None, "root", None)
root = doc.documentElement

item = doc.createElement("item")
item.setAttribute("id", "1")
item.appendChild(doc.createTextNode("Hello"))
root.appendChild(item)

print(doc.toprettyxml(encoding="UTF-8").decode())

Parsing DOM Java

Le DOM JAXP de Java charge tout le document en mémoire via DocumentBuilder. setNamespaceAware(true) garde les préfixes de namespace. Le DOM est pratique pour l'accès aléatoire mais lourd en mémoire pour les gros fichiers — préférez alors StAX/SAX.

xml
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.*;

DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
f.setNamespaceAware(true);
Document doc = f.newDocumentBuilder().parse(new File("data.xml"));

Element root = doc.getDocumentElement();
NodeList books = root.getElementsByTagName("book");
for (int i = 0; i < books.getLength(); i++) {
  Element b = (Element) books.item(i);
  String id = b.getAttribute("id");
  String title = b.getElementsByTagName("title")
                      .item(0).getTextContent();
  System.out.println(id + ": " + title);
}

lxml (Python)

lxml est un binding Python rapide et riche pour libxml2. Il supporte XPath complet, XSLT, validation (DTD/XSD/RelaxNG) et parsing incrémental. Son ElementPath (find/findall) est un sous-ensemble d'XPath ; utilisez xpath() pour le XPath complet.

xml
from lxml import etree

# parse and validate against a schema
tree = etree.parse("data.xml")
root = tree.getroot()

# XPath with namespaces
ns = {"bk": "https://example.com/books"}
for book in root.xpath("//bk:book", namespaces=ns):
    print(book.get("id"), book.find("bk:title", namespaces=ns).text)

# build an element tree
root = etree.Element("root")
child = etree.SubElement(root, "item", id="1")
child.text = "Hello"
print(etree.tostring(root, pretty_print=True, encoding="unicode"))
11

Parsing SAX

Handler SAX (Python)

SAX est piloté par événements et streame : le parseur appelle startElement, characters et endElement à la lecture, ne bâtissant jamais un arbre complet. Économe en mémoire pour les fichiers énormes. Il faut suivre l'état (ex. élément courant) soi-même.

xml
import xml.sax

class BookHandler(xml.sax.ContentHandler):
    def startElement(self, name, attrs):
        if name == "book":
            print("Book id:", attrs.getValue("id"))
        self.current = name

    def characters(self, content):
        if self.current == "title":
            print("Title:", content.strip())

    def endElement(self, name):
        self.current = None

xml.sax.parse("books.xml", BookHandler())

Méthodes d'événements SAX

Les callbacks ContentHandler marquent les frontières de document et d'élément. characters() peut scinder un seul nœud texte en plusieurs appels — accumulez dans un buffer. startPrefixMapping/endPrefixMapping rapportent les déclarations de namespace.

xml
class Handler(xml.sax.ContentHandler):
    def startDocument(self):
        print("parsing started")

    def endDocument(self):
        print("parsing done")

    def startElement(self, name, attrs):
        # attrs: get via attrs.getValue('id') or attrs['id']
        pass

    def endElement(self, name):
        pass

    def characters(self, text):
        # may be called multiple times for one text node
        pass

    def startPrefixMapping(self, prefix, uri):
        print("namespace:", prefix, uri)

startElement / endElement

Suivre un chemin d'élément (une pile) est la façon standard de savoir où on en est pendant le streaming. Bufférisez la sortie de characters() et flush-la dans endElement, car characters peut se déclencher plus d'une fois par nœud texte.

xml
class Handler(xml.sax.ContentHandler):
    def __init__(self):
        self.path = []
        self.text = []

    def startElement(self, name, attrs):
        self.path.append(name)
        self.text = []
        if "id" in attrs:
            print("/".join(self.path), "id =", attrs["id"])

    def endElement(self, name):
        if self.path[-1] == "title":
            print("title:", "".join(self.text).strip())
        self.path.pop()

    def characters(self, content):
        self.text.append(content)

Parseur SAX Java

Le SAX Java étend DefaultHandler. startElement reçoit l'URI de namespace, le nom local, le nom qualifié et un objet Attributes. characters(ch, start, len) fournit une tranche de chars — bufférisez-la car un nœud texte peut s'étendre sur plusieurs appels.

xml
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.*;
import javax.xml.parsers.*;

class BookHandler extends DefaultHandler {
    private StringBuilder buf = new StringBuilder();

    public void startElement(String uri, String local,
                             String qName, Attributes attrs) {
        buf.setLength(0);
        if ("book".equals(qName))
            System.out.println("id=" + attrs.getValue("id"));
    }

    public void characters(char[] ch, int start, int len) {
        buf.append(ch, start, len);
    }

    public void endElement(String uri, String local, String qName) {
        if ("title".equals(qName))
            System.out.println("title=" + buf);
    }
}
// SAXParserFactory.newInstance().newSAXParser().parse(file, new BookHandler());

SAX vs DOM

SAX streame des événements avec mémoire constante, idéal pour les fichiers énormes et l'extraction en une passe. DOM charge tout l'arbre, permettant XPath et la mutation aléatoire mais utilisant une mémoire proportionnelle à la taille du fichier. Choisissez selon le pattern d'accès et la taille du fichier.

xml
<!-- SAX: event-driven, streaming, low memory
     DOM:  full tree in memory, random access

     SAX is best for:
       - large files that won't fit in memory
       - read-only filtering / extraction
       - simple state machines over the document

     DOM is best for:
       - random access to many parts of the tree
       - repeated queries / XPath
       - editing and re-serializing -->

<!-- Memory: SAX ~ O(1); DOM ~ O(file size) -->
<!-- Speed:  SAX often faster for one-pass scans -->

Gestion des erreurs (SAX)

Un ErrorHandler reçoit avertissements, erreurs récupérables et erreurs fatales. Par défaut, les erreurs fatales lèvent une exception et arrêtent le parsing. Implémenter error() permet de logger les soucis de validation non fatals sans avorter tout le parsing.

xml
import xml.sax

class Handler(xml.sax.ContentHandler):
    pass

# ErrorHandler: warning, error, fatalError
class ErrHandler(xml.sax.ErrorHandler):
    def error(self, exception):
        print("ERROR:", exception)
    def fatalError(self, exception):
        print("FATAL:", exception)
        raise exception
    def warning(self, exception):
        print("WARN:", exception)

parser = xml.sax.make_parser()
parser.setContentHandler(Handler())
parser.setErrorHandler(ErrHandler())
parser.parse("data.xml")
12

StAX (parsing pull)

API curseur StAX

StAX est un parseur pull : votre code tire l'événement suivant avec next(), contrôlant la boucle. L'API curseur (XMLStreamReader) avance dans les événements un à la fois. Plus rapide et moins gourmand que le DOM, et plus flexible que le modèle push de SAX.

xml
import javax.xml.stream.*;
import java.io.*;

XMLInputFactory factory = XMLInputFactory.newInstance();
// defend against XXE
factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
factory.setProperty(XMLInputFactory.SUPPORT_DTD, false);

XMLStreamReader r = factory.createXMLStreamReader(new FileInputStream("data.xml"));
while (r.hasNext()) {
    int event = r.next();
    if (event == XMLStreamConstants.START_ELEMENT) {
        System.out.println("start: " + r.getLocalName());
    } else if (event == XMLStreamConstants.END_ELEMENT) {
        System.out.println("end: " + r.getLocalName());
    }
}
r.close();

Événements XMLStreamReader

Les types d'événements incluent START_ELEMENT, END_ELEMENT, CHARACTERS, COMMENT, PROCESSING_INSTRUCTION et START/END_DOCUMENT. getText() retourne le texte courant ; isWhiteSpace() filtre l'indentation. Le curseur avance d'un événement par appel next().

xml
XMLStreamReader r = factory.createXMLStreamReader(in);
while (r.hasNext()) {
    switch (r.next()) {
        case XMLStreamConstants.START_ELEMENT:
            // r.getLocalName(), r.getAttributeValue(i), r.getNamespaceURI()
            break;
        case XMLStreamConstants.END_ELEMENT:
            break;
        case XMLStreamConstants.CHARACTERS:
            if (!r.isWhiteSpace()) {
                String text = r.getText();
            }
            break;
        case XMLStreamConstants.START_DOCUMENT:
            break;
        case XMLStreamConstants.END_DOCUMENT:
            break;
        case XMLStreamConstants.PROCESSING_INSTRUCTION:
            break;
    }
}

Lire éléments et attributs

getAttributeValue(namespaceURI, localName) lit les attributs par nom (passez null pour sans namespace). getElementText() est une commodité qui lit le texte d'un élément uniquement-texte et avance au-delà de son END_ELEMENT — plus propre que buffériser les characters soi-même.

xml
while (r.hasNext()) {
    int event = r.next();
    if (event == XMLStreamConstants.START_ELEMENT
            && "book".equals(r.getLocalName())) {
        String id = r.getAttributeValue(null, "id");
        String category = r.getAttributeValue(null, "category");
        System.out.println("Book " + id + " (" + category + ")");
    }
    if (event == XMLStreamConstants.START_ELEMENT
            && "title".equals(r.getLocalName())) {
        String title = r.getElementText();   // consumes until END_ELEMENT
        System.out.println("Title: " + title);
    }
}

Writer StAX

XMLStreamWriter bâtit du XML séquentiellement. writeStartDocument, writeStartElement/writeEndElement, writeAttribute, writeCharacters et writeNamespace doivent s'équilibrer. Flush/close à la fin pour garantir la complétude de la sortie.

xml
XMLOutputFactory out = XMLOutputFactory.newInstance();
XMLStreamWriter w = out.createXMLStreamWriter(System.out, "UTF-8");

w.writeStartDocument("UTF-8", "1.0");
w.writeStartElement("books");
w.writeNamespace("bk", "https://example.com/books");

w.writeStartElement("bk", "book", "https://example.com/books");
w.writeAttribute("id", "b1");
w.writeStartElement("bk", "title", "https://example.com/books");
w.writeCharacters("XML Guide");
w.writeEndElement();   // title
w.writeEndElement();   // book

w.writeEndElement();   // books
w.writeEndDocument();
w.close();

StAX vs SAX

SAX pousse les événements vers votre handler ; StAX laisse tirer les événements à la demande. Le modèle pull de StAX facilite sauter des sous-arbres et gérer l'état, et il ajoute une API d'écriture. Les deux évitent de bâtir un arbre DOM complet, convenant donc aux grands documents.

xml
<!-- StAX: PULL model  (client calls next())
     SAX:  PUSH model  (parser calls your handlers)

     StAX advantages:
       - client controls parsing (easy to skip sections)
       - simpler state management for many tasks
       - supports both reading and writing
       - can pause/resume naturally

     SAX advantages:
       - slightly lower overhead in pure streaming
       - mature, widely available
       - filters/chains via XMLFilter

     Both are streaming and memory-efficient. -->

Event Reader (API itérateur)

L'API itérateur (XMLEventReader) retourne des objets XMLEvent qu'on peut sonder et consommer. Plus orientée objet que l'API curseur et plus facile pour filtrer ou scinder, mais légèrement plus lourde à cause de l'allocation des objets d'événement.

xml
import javax.xml.stream.*;
import javax.xml.stream.events.*;

XMLEventReader reader = XMLInputFactory.newInstance()
        .createXMLEventReader(in);

while (reader.hasNext()) {
    XMLEvent e = reader.peek();              // look without consuming
    if (e.isStartElement()) {
        StartElement se = e.asStartElement();
        System.out.println(se.getName());
    }
    XMLEvent consumed = reader.nextEvent();   // consume it
    if (consumed.isEndElement()) {
        System.out.println("closed");
    }
}
reader.close();
13

Conversion XML et JSON

XML vers JSON (JavaScript)

fast-xml-parser convertit XML en JSON dans Node.js. Les attributs se préfixent (défaut @_) et les éléments répétés deviennent des tableaux. La bibliothèque est en pur JavaScript et rapide, avec des options pour contrôler tableaux, nombres et booléens.

xml
// Node.js with fast-xml-parser
const { XMLParser } = require("fast-xml-parser");

const xml = "<book id='b1'><title>XML</title><price>29.99</price></book>";
const parser = new XMLParser({
  ignoreAttributes: false,
  attributeNamePrefix: "@_",
});

const json = parser.parse(xml);
console.log(json.book["@_id"]);   // b1
console.log(json.book.title);     // XML
console.log(json.book.price);     // 29.99

JSON vers XML (JavaScript)

XMLBuilder inverse la conversion. Le préfixe @_ marque les attributs et les objets imbriqués deviennent des éléments enfants. Les tableaux produisent des éléments répétés. La règle de racine unique du XML signifie que l'objet JSON de premier niveau doit mapper à un seul élément racine.

xml
const { XMLBuilder } = require("fast-xml-parser");

const json = {
  book: {
    "@_id": "b1",
    title: "XML Guide",
    price: 29.99,
  },
};

const builder = new XMLBuilder({
  format: true,
  attributeNamePrefix: "@_",
  ignoreAttributes: false,
});

const xml = builder.build(json);
console.log(xml);
// <book id="b1">
//   <title>XML Guide</title>
//   <price>29.99</price>
// </book>

xmltodict (Python)

xmltodict traite le XML comme des structures dict/list : les attributs utilisent '@nom', le texte '#text'. parse() lit le XML, unparse() l'écrit. Parfait pour des aller-retours rapides mais perd l'ordre et certains cas limites des schémas complexes.

xml
import xmltodict, json

xml = """<book id="b1"><title>XML</title><price>29.99</price></book>"""

# XML -> dict
data = xmltodict.parse(xml)
print(data["book"]["@id"])      # b1
print(data["book"]["title"])    # XML

# dict -> JSON
print(json.dumps(data, indent=2))

# dict -> XML
xml_out = xmltodict.unparse({"book": {"@id": "b2", "title": "New"}})
print(xml_out)

Gestion des attributs et du texte

Convertir XML en JSON force des décisions sur les attributs (@_préfixe), le texte (#text) et le contenu mixte. Le contenu mixte — texte entrecoupé d'éléments enfants — ne mappe pas proprement au JSON et perd souvent de la fidélité. Choisissez des conventions et restez cohérent.

xml
<!-- XML with mixed attributes and text -->
<product sku="A1" stock="5">Widget<note>sale</note></product>

// fast-xml-parser output:
// {
//   product: {
//     "@_sku": "A1",
//     "@_stock": "5",
//     "#text": "Widget",
//     note: "sale"
//   }
// }

// Round-trip carefully: mixed content (text + elements)
// is hard to represent losslessly in JSON -->

Défis de conversion

Pièges de conversion courants : enfant unique vs multiples (chaîne vs tableau), ordre des éléments, préfixes de namespace (qui sont des alias), la contrainte de racine unique et le typage primitif (le XML n'a pas de nombres ni booléens natifs). Documentez vos conventions.

xml
<!-- 1. Repeated elements -> array -->
<list><item>a</item><item>b</item></list>
// { list: { item: ["a", "b"] } }   (or single string if only one)

<!-- 2. Order is significant in XML but not in JSON objects -->
<a><x/><y/></a>   vs   <a><y/><x/></a>   // may differ

<!-- 3. Namespaces -->
<ns:elem xmlns:ns="http://x"/>   // prefixes are aliases

<!-- 4. Single root: JSON top-level must be one object -->
<!-- 5. Numbers/booleans: XML is all text; typing is heuristic -->

Exemple d'aller-retour

L'aller-retour (XML -> JSON -> XML) marche pour des données bien structurées mais peut perdre commentaires, instructions de traitement, frontières CDATA et espaces exacts. Pour une édition sans perte, utilisez une API DOM/arbre au lieu d'une conversion JSON.

xml
// Parse, modify, and re-serialize with fast-xml-parser
const { XMLParser, XMLBuilder } = require("fast-xml-parser");

const opts = { ignoreAttributes: false, attributeNamePrefix: "@_" };
const parser = new XMLParser(opts);
const builder = new XMLBuilder({ ...opts, format: true });

const obj = parser.parse(xmlString);
// mutate
obj.book.price = 19.99;
obj.book["@_onSale"] = "true";

const newXml = builder.build(obj);
console.log(newXml);
14

Flux RSS et Atom

Structure RSS 2.0

RSS 2.0 a une racine <rss> avec un seul <channel>. Champs de canal requis : title, link, description. Chaque <item> porte title, link, description, guid, pubDate. Les dates suivent RFC 822 (ex. 'Wed, 02 Oct 2024 13:00:00 GMT').

xml
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>My Blog</title>
    <link>https://example.com</link>
    <description>Recent posts</description>
    <language>en-us</language>
    <pubDate>Wed, 02 Oct 2024 13:00:00 GMT</pubDate>
    <item>
      <title>First Post</title>
      <link>https://example.com/1</link>
      <description>A short summary</description>
      <pubDate>Wed, 02 Oct 2024 12:00:00 GMT</pubDate>
      <guid>https://example.com/1</guid>
    </item>
  </channel>
</rss>

Canal et item RSS

Les champs au niveau du canal décrivent le flux (title, link, description, language, ttl, image). Les champs d'item décrivent chaque entrée ; enclosure supporte podcasts/médias avec URL, longueur en octets et type MIME. category peut porter un attribut domain.

xml
<channel>
  <title>Site Title</title>
  <link>https://example.com</link>
  <description>What the feed is about</description>
  <category>Technology</category>
  <ttl>60</ttl>                          <!-- cache minutes -->
  <image>
    <url>https://example.com/logo.png</url>
    <title>Site Title</title>
    <link>https://example.com</link>
  </image>
  <item>
    <title>Post Title</title>
    <link>https://example.com/post</link>
    <description>Summary text</description>
    <author>[email protected]</author>
    <category domain="https://example.com/tags">xml</category>
    <enclosure url="https://example.com/p.mp3" length="12345"
               type="audio/mpeg"/>
  </item>
</channel>

Flux Atom

Atom (RFC 4287) utilise une racine <feed> dans le namespace Atom. Requis : id, title, updated. Les entrées exigent id, title, updated. Les IDs devraient être globalement uniques (URN ou URIs tag:). Les dates utilisent RFC 3339 (ISO 8601) avec fuseau.

xml
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>Example Feed</title>
  <link href="https://example.com/feed.atom" rel="self"/>
  <link href="https://example.com"/>
  <id>urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6</id>
  <updated>2024-10-02T13:00:00Z</updated>
  <author><name>Jane Doe</name></author>
  <entry>
    <title>Atom Entry</title>
    <id>tag:example.com,2024:/post/1</id>
    <updated>2024-10-02T12:00:00Z</updated>
    <summary>A short summary</summary>
    <content type="html">&lt;p&gt;Full post body&lt;/p&gt;</content>
  </entry>
</feed>

Détails des entrées Atom

Les entrées Atom supportent du contenu riche : text, html ou xhtml via l'attribut type. link utilise les attributs rel (alternate, self, enclosure, related). category a term/scheme/label. published est la date d'origine ; updated le dernier changement.

xml
<entry>
  <title type="text">Post Title</title>
  <id>tag:example.com,2024:/posts/42</id>
  <updated>2024-10-02T12:00:00Z</updated>
  <published>2024-10-01T09:00:00Z</published>
  <author>
    <name>Jane Doe</name>
    <email>[email protected]</email>
    <uri>https://example.com/jane</uri>
  </author>
  <link href="https://example.com/posts/42" rel="alternate"/>
  <category term="xml" scheme="https://example.com/tags" label="XML"/>
  <summary type="text">A teaser.</summary>
  <content type="xhtml">
    <div xmlns="http://www.w3.org/1999/xhtml"><p>Body</p></div>
  </content>
</entry>

Namespaces de flux courants

RSS s'étend souvent avec des modules : Dublin Core (dc:creator, dc:date), content (content:encoded pour le HTML complet), Media RSS (media:content) et le atom:link rel='self' qui aide les lecteurs à trouver l'URL du flux. Les namespaces laissent les flux mêler vocabulaires.

xml
<?xml version="1.0"?>
<rss version="2.0"
     xmlns:content="http://purl.org/rss/1.0/modules/content/"
     xmlns:dc="http://purl.org/dc/elements/1.1/"
     xmlns:media="http://search.yahoo.com/mrss/"
     xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Feed</title>
    <link>https://example.com</link>
    <description>desc</description>
    <atom:link href="https://example.com/feed.xml" rel="self"
               type="application/rss+xml"/>
    <item>
      <title>Post</title>
      <dc:creator>Jane Doe</dc:creator>
      <content:encoded><![CDATA[<p>HTML body</p>]]></content:encoded>
      <media:content url="https://example.com/img.png" medium="image"/>
    </item>
  </channel>
</rss>

Validation des flux

Utilisez le W3C Feed Validator pour vérifier RSS/Atom. Erreurs courantes : champs requis manquants, mauvais formats de dates, IDs non uniques, XML invalide (& non échappé) et self link manquant. Des flux valides garantissent que les agrégateurs les parsent fiablement.

xml
<!-- RSS: dates must be RFC 822, e.g. -->
<pubDate>Wed, 02 Oct 2024 13:00:00 GMT</pubDate>

<!-- Atom: dates must be RFC 3339, e.g. -->
<updated>2024-10-02T13:00:00Z</updated>

<!-- Validate online with https://validator.w3.org/feed/ -->
<!-- Required RSS channel fields: title, link, description -->
<!-- Required Atom feed fields: id, title, updated -->
<!-- GUIDs/IDs should be unique and permanent -->
15

SVG et XML

Structure de document SVG

SVG est un vocabulaire XML pour les graphiques vectoriels. La racine <svg> déclare le namespace SVG et un viewBox pour le système de coordonnées. Tous les éléments graphiques (rect, circle, text) sont des éléments XML avec attributs de présentation.

xml
<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     width="200" height="200" viewBox="0 0 200 200">
  <rect x="10" y="10" width="180" height="180"
        fill="#005FAD" stroke="black" stroke-width="2"/>
  <circle cx="100" cy="100" r="40" fill="white"/>
  <text x="100" y="105" text-anchor="middle">SVG</text>
</svg>
<!-- SVG is an XML application; it must be well-formed -->

Namespace SVG et imports

Les éléments SVG vivent dans le namespace http://www.w3.org/2000/svg. xlink sert aux références href (en SVG 1.1) ; SVG 2 préfère le href simple. defs héberge les dégradés, patterns et symbols réutilisables référencés par id via url(#id).

xml
<?xml version="1.0"?>
<svg xmlns="http://www.w3.org/2000/svg"
     xmlns:xlink="http://www.w3.org/1999/xlink"
     version="1.1">
  <defs>
    <linearGradient id="g1">
      <stop offset="0%" stop-color="red"/>
      <stop offset="100%" stop-color="blue"/>
    </linearGradient>
  </defs>
  <rect width="100" height="100" fill="url(#g1)"/>
</svg>

Formes SVG

Éléments de forme SVG : rect (avec rx/ry pour les coins arrondis), circle, ellipse, line, polyline (ouverte) et polygon (fermée). Les coordonnées sont en unités utilisateur définies par le viewBox. stroke et fill sont des attributs de présentation courants.

xml
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="200">
  <rect x="10" y="10" width="80" height="50" rx="10" fill="teal"/>
  <circle cx="150" cy="60" r="40" fill="orange"/>
  <ellipse cx="220" cy="60" rx="50" ry="20" fill="purple"/>
  <line x1="10" y1="120" x2="290" y2="120" stroke="black"/>
  <polyline points="10,180 50,140 90,180 130,140" fill="none" stroke="red"/>
  <polygon points="200,180 250,140 280,200" fill="green"/>
</svg>

Texte et chemins SVG

Le texte SVG utilise font-family, font-size, font-weight, font-style. tspan permet des styles mixtes dans un élément text. L'attribut 'd' de l'élément path utilise des commandes : M (déplacer), L (ligne), C (bezier cubique), Q (quadratique), A (arc), Z (fermer le chemin).

xml
<svg xmlns="http://www.w3.org/2000/svg" width="300" height="150">
  <text x="10" y="40" font-family="Arial" font-size="24"
        font-weight="bold" fill="navy">Hello SVG</text>

  <text x="10" y="80">
    <tspan font-size="16">Normal</tspan>
    <tspan font-size="16" font-style="italic"> italic</tspan>
  </text>

  <path d="M10 100 L 100 100 L 55 140 Z"
        fill="none" stroke="black" stroke-width="2"/>
</svg>
<!-- Path commands: M=move, L=line, H/V, C=cubic, Q=quad, A=arc, Z=close -->

Groupement et réutilisation SVG

L'élément <g> groupe les formes pour un style et des transforms partagés. <use> référence un élément par id (href='#id' en SVG 2, xlink:href en 1.1) et le clone à une nouvelle position. <symbol> définit des graphiques réutilisables qui ne se rendent que via <use>.

xml
<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200">
  <g id="node" stroke="black" fill="lightblue">
    <circle cx="50" cy="50" r="20"/>
    <circle cx="100" cy="50" r="20"/>
  </g>

  <use href="#node" x="0" y="100"/>
  <use href="#node" x="0" y="150" opacity="0.5"/>

  <symbol id="star" viewBox="0 0 24 24">
    <polygon points="12,2 15,9 22,9 17,14 19,21 12,17 5,21 7,14 2,9 9,9"/>
  </symbol>
  <use href="#star" width="24" height="24"/>
</svg>

Validation SVG

Les documents SVG peuvent se valider contre la DTD ou le XSD du W3C. Soucis courants : namespace SVG oublié, préfixes non déclarés, attributs dans le mauvais namespace et données de path mal formées. xmllint est le validateur en ligne de commande standard.

xml
<?xml version="1.0"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
  <rect width="100" height="100"/>
</svg>

<!-- Validate with xmllint: -->
<!-- xmllint --noout --valid file.svg        (DTD) -->
<!-- xmllint --noout --schema svg11.xsd file.svg   (XSD) -->

<!-- Common errors: wrong namespace, undeclared prefixes,
     text outside a text element, invalid path data -->
16

SOAP et WSDL

Enveloppe SOAP

Un message SOAP est un document XML avec une racine <Envelope> dans le namespace SOAP. L'<Header> optionnel porte des métadonnées (auth, routage) ; le <Body> requis détient le payload réel du message. SOAP 1.1 et 1.2 utilisent des namespaces différents.

xml
<?xml version="1.0"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <auth xmlns="https://example.com/auth">
      <token>abc123</token>
    </auth>
  </soap:Header>
  <soap:Body>
    <m:GetPrice xmlns:m="https://example.com/pricing">
      <m:Item>Apples</m:Item>
    </m:GetPrice>
  </soap:Body>
</soap:Envelope>
<!-- Envelope is the root; Header is optional, Body is required -->

En-tête SOAP

Les en-têtes portent des infos hors bande comme l'authentification, l'adressage (WS-Addressing) et les transactions. soap:mustUnderstand='1' dit au récepteur qu'il DOIT traiter cet en-tête ou retourner un fault SOAP — cela impose le respect du contrat.

xml
<soap:Header xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">
    http://example.com/GetPrice
  </wsa:Action>
  <wsa:MessageID>urn:uuid:1234</wsa:MessageID>
  <auth xmlns="https://example.com/auth"
        soap:mustUnderstand="1">
    <token>secret</token>
  </auth>
</soap:Header>
<!-- mustUnderstand="1" forces the receiver to process the header -->

Corps SOAP et Fault

Le Body porte le payload de requête ou réponse. En erreur, le Body contient un <Fault> avec faultcode (Client/Server), une faultstring lisible humain et un detail optionnel. SOAP 1.2 renomme ces éléments et ajoute une structure Code/Reason.

xml
<!-- Request body -->
<soap:Body>
  <m:GetPrice xmlns:m="https://example.com/pricing">
    <m:Item>Apples</m:Item>
  </m:GetPrice>
</soap:Body>

<!-- Fault (error response) -->
<soap:Body>
  <soap:Fault>
    <faultcode>soap:Client</faultcode>
    <faultstring>Unknown item: Apples</faultstring>
    <detail>
      <m:Error xmlns:m="https://example.com/pricing">
        <code>404</code>
      </m:Error>
    </detail>
  </soap:Fault>
</soap:Body>

Structure WSDL

WSDL décrit un service web : <types> (schémas XSD), <message> (payloads d'entrée/sortie), <portType> (l'interface — opérations et leurs messages), <binding> (protocole/encodage) et <service> (URL d'endpoint). WSDL 2.0 simplifie cela en interfaces et bindings.

xml
<?xml version="1.0"?>
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/"
             xmlns:xs="http://www.w3.org/2001/XMLSchema"
             targetNamespace="https://example.com/pricing">
  <types>
    <xs:schema targetNamespace="https://example.com/pricing">
      <xs:element name="GetPriceRequest" type="xs:string"/>
      <xs:element name="GetPriceResponse" type="xs:decimal"/>
    </xs:schema>
  </types>
  <message name="GetPriceInput">
    <part name="item" element="tns:GetPriceRequest"/>
  </message>
  <portType name="PricingPort">
    <operation name="GetPrice">
      <input message="tns:GetPriceInput"/>
      <output message="tns:GetPriceOutput"/>
    </operation>
  </portType>
</definitions>

Binding et service WSDL

Le binding mappe un portType vers un protocole concret (SOAP sur HTTP) et un style (document/literal est le défaut moderne). L'élément service liste les endpoints (soap:address). Document/literal enveloppe le payload dans un élément défini par le schéma.

xml
<binding name="PricingSOAP" type="tns:PricingPort">
  <soap:binding style="document"
                transport="http://schemas.xmlsoap.org/soap/http"/>
  <operation name="GetPrice">
    <soap:operation soapAction="http://example.com/GetPrice"/>
    <input><soap:body use="literal"/></input>
    <output><soap:body use="literal"/></output>
  </operation>
</binding>

<service name="PricingService">
  <port name="PricingPort" binding="tns:PricingSOAP">
    <soap:address location="https://example.com/pricing"/>
  </port>
</service>
<!-- style: rpc or document; use: encoded or literal -->

SOAP vs REST

SOAP est un protocole avec une enveloppe XML stricte, un contrat WSDL et des standards WS-* (sécurité, transactions) ; le mieux pour les intégrations d'entreprise exigeant fiabilité et contrats formels. REST est un style léger basé HTTP, habituellement en JSON, qui domine les API publiques.

xml
<!-- SOAP: protocol with envelope, strict contract (WSDL),
     built-in error model (Fault), WS-* extensions.
     Heavier, XML-only, common in enterprise/B2B. -->

<!-- REST: architectural style using HTTP verbs (GET/POST/...),
     flexible payloads (often JSON), no built-in contract.
     Lighter, browser-friendly, dominant on the web. -->

<!-- When to use SOAP:
     - you need strict contracts and tooling
     - transactional reliability (WS-ReliableMessaging)
     - standardized security (WS-Security)
     - existing SOAP-based infrastructure -->

<!-- When to use REST:
     - public APIs, mobile/web clients
     - JSON payloads, HTTP caching
     - simpler, faster iteration -->
17

Signature numérique XML

Structure de signature

La racine <Signature> d'une signature XML contient <SignedInfo> (ce qui est signé et comment), <SignatureValue> (la signature cryptographique sur le SignedInfo canonisé), un <KeyInfo> optionnel et des <Object> détenant les données référencées.

xml
<?xml version="1.0"?>
<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
  <SignedInfo>
    <CanonicalizationMethod Algorithm="..."/>
    <SignatureMethod Algorithm="..."/>
    <Reference URI="#data">
      <DigestMethod Algorithm="..."/>
      <DigestValue>...</DigestValue>
    </Reference>
  </SignedInfo>
  <SignatureValue>...</SignatureValue>
  <KeyInfo>...</KeyInfo>
  <Object Id="data">signed content</Object>
</Signature>
<!-- A signature = SignedInfo + SignatureValue + optional KeyInfo -->

SignedInfo

SignedInfo spécifie la canonicalisation (pour que la signature identique aux octets survive à la re-sérialisation XML), l'algorithme de signature et une ou plusieurs References. Chaque Reference pointe des données via URI, liste des Transforms et donne un DigestValue de ces données.

xml
<SignedInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
  <CanonicalizationMethod
      Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
  <SignatureMethod
      Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
  <Reference URI="">
    <Transforms>
      <Transform Algorithm="...enveloped-signature"/>
    </Transforms>
    <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
    <DigestValue>base64digest==</DigestValue>
  </Reference>
</SignedInfo>

Reference et Transforms

Chaque Reference identifie quoi signer (URI), applique des Transforms (canonicalisation, filtrage XPath, retrait de signature enveloppée), puis hache avec DigestMethod. Le transform enveloped-signature exclut l'élément Signature lui-même de son propre hash.

xml
<Reference URI="#order">
  <Transforms>
    <Transform Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
    <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
    <XPath xmlns="...">not(ancestor-or-self::ds:Signature)</XPath>
  </Transforms>
  <DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
  <DigestValue>abc123base64==</DigestValue>
</Reference>

<!-- Reference types:
     - same-document (URI="#id")
     - external (URI="https://...")
     - detached (URI pointing elsewhere) -->

SignatureValue et KeyInfo

SignatureValue est le résultat base64 de signer le SignedInfo canonisé avec la clé privée du signataire. KeyInfo est OPTIONNEL et ne fait que suggérer comment trouver la clé de vérification (cert X.509, clé publique RSA, nom de clé ou URL de récupération) — il faut la valider hors bande.

xml
<SignatureValue>base64encodedSignature==</SignatureValue>

<KeyInfo>
  <X509Data>
    <X509SubjectName>CN=Example,O=Example Inc</X509SubjectName>
    <X509Certificate>MIID...base64...==</X509Certificate>
  </X509Data>
</KeyInfo>

<!-- Other KeyInfo options: -->
<!--   <KeyName>key-id</KeyName> -->
<!--   <KeyValue><RSAKeyValue>...</RSAKeyValue></KeyValue> -->
<!--   <RetrievalMethod URI="..."/> -->
<!-- KeyInfo is optional and unverified by itself -->

Canonicalisation

La canonicalisation convertit un ensemble de nœuds XML en octets stables pour qu'une signature soit reproductible malgré des différences non pertinentes (ordre des attributs, CDATA). La c14n exclusive (xml-exc-c14n) est préférée pour les signatures car elle délimite les namespaces au sous-arbre signé.

xml
<!-- Two documents that are logically identical may differ in bytes:
     - attribute order
     - namespace declarations
     - CDATA vs escaping
     - whitespace outside elements
     Canonical XML (c14n) produces a canonical byte form. -->

<CanonicalizationMethod
    Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>

<!-- Exclusive c14n (recommended for signatures): -->
<CanonicalizationMethod
    Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>

<!-- Exclusive form avoids leaking inherited namespace declarations
     into the signed digest, preventing wrapping attacks. -->

Signature enveloppée

Une signature enveloppée s'embarque dans le document qu'elle signe (le plus courant pour le XML). Le transform enveloped-signature retire l'élément <Signature> avant le hachage, pour que la signature ne fasse pas partie de son propre digest. Des variantes détachées et enveloppantes existent aussi.

xml
<?xml version="1.0"?>
<order Id="order">
  <item>Widget</item>
  <Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
    <SignedInfo>
      <CanonicalizationMethod Algorithm="...exc-c14n#"/>
      <SignatureMethod Algorithm="...rsa-sha256"/>
      <Reference URI="#order">
        <Transforms>
          <Transform Algorithm="...enveloped-signature"/>
        </Transforms>
        <DigestMethod Algorithm="...sha256"/>
        <DigestValue>...</DigestValue>
      </Reference>
    </SignedInfo>
    <SignatureValue>...</SignatureValue>
  </Signature>
</order>
<!-- The signature lives INSIDE the signed element -->
19

Conventions de nommage

Nommer les éléments

Choisissez un style et appliquez-le de façon cohérente. Le minuscules-avec-tirets est courant pour les vocabulaires XML (HTML, SVG). Les noms devraient être assez descriptifs pour être sans ambiguïté mais concis. Évitez les abréviations cryptiques et les noms trop verbeux.

xml
<!-- Good: lowercase, hyphen-separated, descriptive -->
<customer-address>
  <street>123 Main St</street>
  <postal-code>12345</postal-code>
</customer-address>

<!-- Avoid: abbreviations that are unclear -->
<!-- <cust-addr><pc>...</pc></cust-addr> -->

<!-- Avoid: too long -->
<!-- <customerMailingPostalAddressCode> -->

<!-- Be consistent across the whole vocabulary -->

Nommer les attributs

Les attributs conviennent aux métadonnées (id, type, href, status). Matchez le style de nommage des éléments. Les booléens portent des valeurs explicites. Ne préfixez pas un attribut du nom de son élément (user-id sur <user> est redondant). Utilisez 'id' pour les identifiants uniques.

xml
<product sku="A1" unit-price="9.99" in-stock="true">
  <name>Widget</name>
</product>

<!-- Conventions:
     - attributes are metadata: id, type, href, status
     - use lowercase-hyphen style to match elements
     - boolean attributes still carry a value ("true"/"false")
     - avoid repeating the element name: <user user-id="..."/>
       prefer <user id="..."/> -->

<!-- IDs: use 'id' or '<element>-id' for clarity -->

URIs et préfixes de namespace

Les URIs de namespace sont des identifiants, pas des URLs fetchables, mais devraient être stables et détenus (utilisez HTTPS sur un domaine que vous contrôlez). Les préfixes sont des alias locaux — gardez-les courts et conventionnels. Versionnez l'URI quand le schéma change de façon incompatible.

xml
<!-- Namespace URIs should be stable, owned, and permanent -->
xmlns:bk  = "https://example.com/ns/books/2024"
xmlns:auth= "https://example.com/ns/auth"

<!-- Prefix conventions:
     - short and mnemonic: xs, xsi, xsl, svg, html, dc
     - lowercase, no punctuation beyond letters
     - 'tns' commonly means 'this namespace' in XSD
     - avoid 'xml' (reserved) -->

<!-- Version the URI when the vocabulary changes incompatibly:
     .../ns/books/2024  vs  .../ns/books/2025 -->

Styles de casse

Styles de casse XML courants : PascalCase (XSD/WSDL, .NET), camelCase (dérivé JSON, Java), minuscules-tirets (HTML/SVG, friendly REST), snake_case (rare). La règle cruciale est la cohérence au sein d'un vocabulaire — mélanger les styles troublerait.

xml
<!-- PascalCase (UpperCamelCase): common in XSD/WSDL, .NET -->
<OrderRequest>
  <CustomerId>123</CustomerId>
</OrderRequest>

<!-- camelCase: common in JSON-derived XML, Java ecosystems -->
<orderRequest>
  <customerId>123</customerId>
</orderRequest>

<!-- lowercase-with-hyphens: HTML5, SVG, REST-friendly -->
<order-request>
  <customer-id>123</customer-id>
</order-request>

<!-- snake_case: rare in XML, used in some Python/SQL ecosystems -->
<order_request><customer_id>123</customer_id></order_request>

Versioning

Versionnez explicitement les vocabulaires XML : un attribut version à la racine est le plus simple ; un URI de namespace versionné est le plus rigoureux (les changements incompatibles reçoivent un nouvel URI). Décidez ce qui compte comme changement mineur (additif) vs majeur (cassant) et documentez-le.

xml
<!-- Versioning strategies -->

<!-- 1. Attribute on the root -->
<catalog version="2.0">...</catalog>

<!-- 2. Versioned namespace URI -->
<catalog xmlns="https://example.com/ns/catalog/v2">...</catalog>

<!-- 3. Versioned root element name -->
<catalog-v2>...</catalog-v2>

<!-- Backward-compatible changes: add optional elements/attributes
     Incompatible changes: bump the version (and/or namespace) -->

<!-- Document the policy: which changes are "minor" vs "major" -->

Conventions de fichiers et extensions

Utilisez des extensions reconnues pour que les outils et humains identifient les types de fichiers. L'attribut encoding de la déclaration XML devrait matcher l'encodage réel des octets ; UTF-8 est le défaut sûr. Les BOM sont déconseillés pour le XML UTF-8.

xml
<!-- Common file extensions:
     .xml   generic XML
     .xsd   XML Schema
     .xsl   XSLT stylesheet
     .xslt  XSLT (alternate)
     .dtd   Document Type Definition
     .rss   RSS feed
     .atom  Atom feed
     .svg   SVG graphic
     .wsdl  WSDL service description
     .xhtml XHTML document
     .plist Apple property list -->

<!-- XML files are UTF-8 by default; declare encoding if different:
     <?xml version="1.0" encoding="UTF-8"?> -->
20

Bonnes pratiques

La bien-formation d'abord

Un document doit être bien formé avant que tout outil le traite. Validez avec un parseur tôt : xmllint --noout fichier.xml rapporte la première erreur. La bien-formation est non négociable ; la validité face à un schéma est une couche additionnelle, optionnelle.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <child>properly nested &amp; escaped</child>
</root>

<!-- Always ensure well-formedness before worrying about validity:
     - exactly one root element
     - all tags closed and properly nested
     - attributes quoted and unique per element
     - & < escaped (and > in some contexts)
     - valid encoding declaration -->

Validation et schémas

Validez contre un schéma pour attraper les erreurs structurelles. XSD est le choix le plus courant pour les vocabulaires typés et namespacés ; Schematron le complète avec des règles métier. xsi:noNamespaceSchemaLocation lie un document à son XSD ; utilisez xsi:schemaLocation pour les schémas namespacés.

xml
<!-- Choose a schema language:
     - DTD:      simple, built-in, limited types
     - XSD:      rich types, namespaces, industry standard
     - RelaxNG:  compact syntax, flexible patterns
     - Schematron: rule-based business constraints -->

<?xml version="1.0"?>
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="schema.xsd">
  <item>valid</item>
</root>

<!-- Validate during development; consider it at runtime for
     untrusted input. -->

Encodage (UTF-8)

UTF-8 est l'encodage par défaut et recommandé pour le XML — il gère tout l'Unicode sans entités. Déclarez toujours l'encodage et sauvegardez le fichier dans cet encodage. Évitez les BOM ; pour des caractères spéciaux on peut aussi utiliser des références de caractères numériques.

xml
<?xml version="1.0" encoding="UTF-8"?>
<root>
  <msg>Café — résumé — 中文 — emoji 🙂</msg>
</root>

<!-- Always declare UTF-8 and save the file as UTF-8.
     Avoid legacy encodings (ISO-8859-1) unless required.
     Do not add a UTF-8 BOM (some parsers mishandle it).
     For non-UTF-8 encodings, declare them accurately. -->

Lisibilité et indentation

Une indentation cohérente (2 espaces est courant) rend le XML lisible et les diffs propres. Évitez les longues lignes uniques. Des outils comme 'xmllint --format' ou un formateur XML peuvent normaliser les espaces — mais sachez que les régions xml:space='preserve' ne doivent pas se reformater.

xml
<?xml version="1.0"?>
<catalog>
  <book id="b1">
    <title>XML Guide</title>
    <author>Jane Doe</author>
  </book>
  <book id="b2">
    <title>Advanced XML</title>
    <author>John Smith</author>
  </book>
</catalog>

<!-- Use 2-space indentation; one element per line for mixed
     or deep structures. Tools: xmllint --format, prettier. -->

Performance

Pour les gros fichiers, préférez les parseurs en streaming (SAX/StAX) au DOM pour garder la mémoire basse. Désactivez le chargement de DTD et les entités externes sauf besoin. Compilez les expressions XPath une fois et réutilisez-les. Pour les systèmes internes, considérez des formats binaires compacts pour réduire taille et temps de parsing.

xml
<!-- Parsing large XML efficiently:
     - use SAX/StAX (streaming) instead of DOM for big files
     - disable DTD/external entities if you don't need them
     - validate once, not on every read
     - reuse parser instances (factory creation is costly)
     - consider binary formats (protobuf, CBOR) for internal traffic -->

<!-- Java StAX with XXE disabled:
     factory.setProperty(XMLInputFactory.SUPPORT_DTD, false); -->

<!-- For repeated XPath, compile once and reuse the expression -->

Sécurité (XXE)

Les attaques XML External Entity (XXE) abusent des entités externes de DTD pour lire des fichiers, déclencher du SSRF ou causer un déni de service (billion laughs/expansion d'entités). La défense la plus forte est de désactiver entièrement les DTD et la résolution d'entités externes sauf si votre cas d'usage les exige.

xml
<?xml version="1.0"?>
<!DOCTYPE root [
  <!-- XXE: attacker forces the parser to read a local file -->
  <!ENTITY xxe SYSTEM "file:///etc/passwd">
]>
<root>&xxe;</root>

<!-- Defenses (do ALL that apply):
     1. Disable DTDs entirely if you don't need them.
     2. Disable external entity resolution.
     3. Disable XInclude.
     4. Validate input; limit entity expansion (billion laughs). -->

<!-- Python: defusedxml
     Java:  XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES = false
     PHP:   libxml_disable_entity_loader(true) -->

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.