XML : qu’est-ce que c’est, structure du document et principe de fonctionnement

Qu’est-ce que le XML ?

XML est un langage de balisage qui définit un ensemble de règles pour encoder des documents dans un format lisible à la fois par l’humain et la machine. Contrairement au HTML, le XML n’a pas d’ensemble fixe de balises — les développeurs créent leurs propres balises correspondant à la structure des données.

Le XML a été développé par le consortium W3C en 1996 comme un sous-ensemble simplifié du SGML (Standard Generalized Markup Language). L’objectif principal du XML est de séparer le contenu de la présentation des données. Contrairement au HTML, qui décrit l’apparence, le XML décrit la structure et la signification des données.

La propriété clé du XML est l’extensibilité. Si de nouveaux types de données apparaissent dans un projet, le développeur ajoute simplement de nouvelles balises sans modifier la structure existante. Cela rend le XML pratique pour le stockage à long terme des données et l’échange entre différents systèmes.

Principaux domaines d’application du XML

• Développement Android — fichiers layout, manifeste, ressources (strings, colors, themes)
• Configuration — Maven POM, Ant build, configurations web (web.xml)
• Services web — SOAP, XML-RPC, flux RSS/Atom
• Flux documentaire — SVG, DocBook, Office Open XML
• Bases de données — SQL Server (type XML), Oracle, PostgreSQL

Syntaxe et structure du XML

La syntaxe XML est plus stricte que celle du HTML. Chaque balise ouvrante doit avoir une balise fermante correspondante, les attributs sont placés entre guillemets et les noms de balises sont sensibles à la casse. Le document doit avoir exactement un élément racine contenant tous les autres.

Un document XML peut commencer par une déclaration indiquant la version XML et l’encodage. Vient ensuite l’élément racine, qui peut contenir des éléments imbriqués, des attributs, du contenu textuel et des commentaires. Les éléments vides s’écrivent comme .

<?xml version="1.0" encoding="UTF-8"?>
<catalog>
    <book id="bk001">
        <title>XML Developer Guide</title>
        <author>John Smith</author>
        <price currency="USD">29.99</price>
        <published>2026-03-15</published>
    </book>
    <book id="bk002">
        <title>Advanced XML Schemas</title>
        <author>Jane Doe</author>
        <price currency="USD">49.99</price>
        </book>
</catalog>

Règles du XML bien formé

Le XML bien formé doit respecter les règles de base : les balises fermantes sont obligatoires pour chaque balise ouvrante, l’imbrication est stricte (le chevauchement des balises est interdit), les valeurs d’attributs sont toujours entre guillemets. Toute violation rend le document invalide et non analysable.

1. Un élément racine — le document contient exactement une racine
2. Imbrication correcte — les balises ne doivent pas se chevaucher
3. Balises fermantes — obligatoires pour tous les éléments sauf auto-fermants
4. Sensibilité à la casse — <Book> et <book> sont des éléments différents
5. Guillemets dans les attributs — valeurs d’attributs entre guillemets doubles ou simples

Espaces de noms et schémas XML

Les espaces de noms XML résolvent le problème de conflits de noms lorsque des éléments de différents vocabulaires sont utilisés dans un même document. Un espace de noms est défini par l’attribut xmlns avec une URI qui identifie de manière unique le vocabulaire.

XML Schema (XSD) est un langage de description de la structure d’un document XML. XSD définit quels éléments et attributs sont autorisés, leurs types de données, leur obligation et leurs contraintes. Les schémas permettent la validation automatique du document avant traitement, ce qui est critique pour les solutions d’intégration.

XML dans le développement mobile

XML joue un rôle clé dans le développement Android. Le système d’exploitation Android utilise le XML pour décrire l’interface utilisateur (fichiers layout), la configuration de l’application (AndroidManifest.xml), les ressources (strings, colors, themes) et les graphiques vectoriels (VectorDrawable). Sous iOS, le XML est moins utilisé, principalement pour les Storyboard et les fichiers de configuration plist.

Sous Android, chaque écran d’application est décrit par un fichier XML avec une hiérarchie de composants View : ConstraintLayout, LinearLayout, TextView, Button. Cette approche sépare la logique applicative de la présentation, simplifiant la maintenance et l’adaptation aux différents écrans. Les fichiers XML de ressources permettent de localiser l’application sans modifier le code.

Exemple de layout Android

Un fichier layout typique contient un ConstraintLayout racine avec des éléments imbriqués, chacun ayant des attributs de position, de taille et de style. Android compile le XML au format binaire AXML pour optimiser les performances au démarrage.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/title"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/welcome"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintStart_toStartOf="parent" />

    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/click"
        app:layout_constraintTop_toBottomOf="@id/title"
        app:layout_constraintStart_toStartOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Analyse XML sur les plateformes mobiles

L’analyse XML sur les plateformes mobiles se fait par deux approches principales : DOM (Document Object Model) charge tout le document en mémoire sous forme d’arbre, SAX (Simple API for XML) lit le document en flux, appelant des gestionnaires d’événements. DOM est pratique pour les petits documents, SAX pour les gros fichiers avec des limitations mémoire.

Android dispose d’analyseurs intégrés : XmlPullParser pour l’analyse en flux et DocumentBuilder pour l’approche DOM. iOS utilise Foundation XMLParser avec un protocole délégué. Pour sérialiser des objets en XML, on utilise souvent des bibliothèques comme SimpleXML en PHP ou Jackson XML en Java.

Analyse XML sur Android (Kotlin)

Android recommande d’utiliser XmlPullParser pour une analyse XML efficace. L’analyseur fonctionne en mode piloté par événements : il appelle next() pour passer à l’élément suivant et retourne le type d’événement (START_TAG, TEXT, END_TAG). Cela permet de traiter des documents de toute taille avec une consommation mémoire minimale.

import org.xmlpull.v1.XmlPullParser
import org.xmlpull.v1.XmlPullParserException
import java.io.IOException

fun parseCatalog(parser: XmlPullParser): List<Book> {
    val books = mutableListOf<Book>()
    var eventType = parser.getEventType()
    var currentBook: Book? = null

    while (eventType != XmlPullParser.END_DOCUMENT) {
        when (eventType) {
            XmlPullParser.START_TAG -> {
                when (parser.getName()) {
                    "book" -> currentBook = Book()
                    "title" -> parser.next()
                    "author" -> parser.next()
                }
            }
            XmlPullParser.TEXT -> {
                currentBook?.apply {
                    title = parser.getText() ?: ""
                }
            }
            XmlPullParser.END_TAG -> {
                if (parser.getName() == "book") {
                    currentBook?.let { books.add(it) }
                }
            }
        }
        eventType = parser.next()
    }
    return books
}

Exemples de XML dans les applications

Des exemples d’utilisation du XML montrent son rôle dans des projets réels. Outre le développement Android, le XML est utilisé pour la configuration de build, la description de données et le flux documentaire. Comprendre la syntaxe XML est nécessaire pour travailler avec Maven, les services SOAP et de nombreux outils d’entreprise.

Configuration Maven (POM)

Le fichier pom.xml décrit un projet Maven : dépendances, plugins, versions et profils de build. Chaque dépendance est spécifiée avec les balises groupId, artifactId et version. Maven télécharge automatiquement les bibliothèques spécifiées depuis les dépôts.

<?xml version="1.0" encoding="UTF-8"?>
<project
    xmlns="http://maven.apache.org/POM/4.0.0"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
    http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>my-app</artifactId>
    <version>1.0.0</version>
    <dependencies>
        <dependency>
            <groupId>com.squareup.retrofit2</groupId>
            <artifactId>retrofit</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
</project>

XML vs JSON : quand choisir quoi

Le choix entre XML et JSON dépend des exigences spécifiques du projet. JSON convient aux API REST, aux applications mobiles et aux configurations où la compacité et la vitesse sont importantes. Le XML est irremplaçable dans les systèmes d’entreprise, le flux documentaire et le développement Android, où une validation stricte, des espaces de noms et une transformation des données sont nécessaires.

Le XML l’emporte dans les scénarios de stockage de documents à long terme. Grâce aux schémas XSD, les documents XML peuvent être validés automatiquement, ce qui est crucial pour les systèmes médicaux, financiers et juridiques. Les transformations XSLT permettent de générer du HTML, du PDF et d’autres formats à partir d’une seule source XML, simplifiant le flux documentaire.

JSON, quant à lui, est devenu le standard pour les API web et les applications mobiles. La facilité d’intégration avec JavaScript, la taille plus réduite et la vitesse d’analyse élevée font de JSON le choix préféré pour les API REST, les messages WebSocket et les fichiers de configuration. Pour la plupart des nouveaux projets, il est recommandé de commencer par JSON et de passer au XML uniquement lorsque des exigences spécifiques apparaissent.