Travailler avec XML en Rust : parsing, création et sérialisation de données

Travailler avec XML en Rust : bibliothèques et outils

XML (eXtensible Markup Language) reste l'un des formats clés pour l'échange de données, les fichiers de configuration et la gestion documentaire. L'écosystème Rust propose plusieurs solutions matures pour travailler avec XML — du parsing stream haute performance à la sérialisation pratique via serde. Dans cet article, nous analyserons trois outils les plus populaires : quick-xml, roxmltree et serde-xml-rs.

Pourquoi Rust pour travailler avec XML ?

Rust combine la vitesse du C/C++ avec la sécurité mémoire. Lors du traitement de gros fichiers XML (par exemple, des dossiers médicaux ou des données géospatiales), cela est crucial. Les bibliothèques XML en Rust sont écrites entièrement en Rust (sans liaisons C), garantissant ainsi la sécurité des threads et des performances prévisibles.

Bibliothèques pour travailler avec XML en Rust

• quick-xml — un parseur stream haute performance (style SAX) et un writer. Consommation mémoire minimale, idéal pour les gros fichiers.
• roxmltree — un parseur DOM qui construit l'arbre du document. Pratique pour la navigation et la modification.
• serde-xml-rs — sérialisation/désérialisation de structures Rust en/à partir de XML via la crate serde. Intégration maximale avec le système de types.

Installation

Ajoutez les dépendances dans Cargo.toml :

[dependencies]quick-xml = "0.36"        # parseur streamroxmltree = "0.20"        # parseur DOMserde-xml-rs = "0.6"      # sérialisation (en paire avec serde)serde = { version = "1.0", features = ["derive"] }

Parsing XML avec quick-xml

quick-xml fonctionne en mode Reader — il lit séquentiellement les tokens (ouverture de balise, texte, fermeture de balise). Cela économise la mémoire : vous traitez le document par parties, sans le charger entièrement.

Exemple : lecture d'un flux RSS

use quick_xml::Reader;use quick_xml::events::Event;

fn main() -> Result<(), Box<dyn std::error::Error>> {    let xml = r#"    <rss version="2.0">        <channel>            <title>Actualités Rust</title>            <item>                <title>Rust 1.78 est sorti</title>                <link>https://example.com/rust-1.78</link>            </item>        </channel>    </rss>"#;

    let mut reader = Reader::from_str(xml);    reader.trim_text(true);

    let mut buf = Vec::new();    let mut in_item = false;

    loop {        match reader.read_event_into(&mut buf) {            Ok(Event::Start(ref e)) => {                if e.name().as_ref() == b"item" {                    in_item = true;                }            }            Ok(Event::Text(ref e)) => {                if in_item {                    let text = e.unescape()?;                    println!("{}", text);                }            }            Ok(Event::End(ref e)) => {                if e.name().as_ref() == b"item" {                    in_item = false;                }            }            Ok(Event::Eof) => break,            Err(e) => eprintln!("Erreur : {}", e),            _ => ()        }        buf.clear();    }    Ok(())}

Sortie : les titres de tous les <item>.

Parsing DOM avec roxmltree

roxmltree charge tout le XML dans un arbre. C'est pratique lorsque vous devez accéder plusieurs fois à différents nœuds ou modifier la structure.

Exemple : extraction d'attributs et de texte

use roxmltree::Document;

fn main() {    let data = r#"    <config version="1.0">        <database>            <host>localhost</host>            <port>5432</port>        </database>    </config>"#;