Trabalho com XML em Rust: parsing, criação e serialização de dados

Trabalho com XML em Rust: bibliotecas e ferramentas

XML (eXtensible Markup Language) continua sendo um dos principais formatos para troca de dados, arquivos de configuração e fluxo de documentos. O ecossistema Rust oferece várias soluções maduras para trabalhar com XML — desde parsing de fluxo de alto desempenho até serialização conveniente via serde. Neste artigo, analisaremos três das ferramentas mais populares: quick-xml, roxmltree e serde-xml-rs.

Por que Rust para trabalhar com XML?

Rust combina a velocidade de C/C++ com segurança de memória. Ao processar grandes arquivos XML (por exemplo, registros médicos ou dados geoespaciais), isso é crítico. As bibliotecas para XML em Rust são escritas do zero em Rust (sem vínculos com C), garantindo segurança de thread e desempenho previsível.

Bibliotecas para trabalhar com XML em Rust

• quick-xml — parser de fluxo de alto desempenho (estilo SAX) e writer. Consumo mínimo de memória, ideal para arquivos grandes.
• roxmltree — parser DOM, que constrói uma árvore do documento. Conveniente para navegação e modificação.
• serde-xml-rs — serialização/desserialização de estruturas Rust para/de XML através do crate serde. Integração máxima com o sistema de tipos.

Instalação

Adicione as dependências ao Cargo.toml:

[dependencies]quick-xml = "0.36"        # parser de fluxoroxmltree = "0.20"        # parser DOMserde-xml-rs = "0.6"      # serialização (em conjunto com serde)serde = { version = "1.0", features = ["derive"] }

Parsing de XML com quick-xml

quick-xml opera no modo Reader — lê tokens sequencialmente (abertura de tag, texto, fechamento de tag). Isso economiza memória: você processa o documento em partes, sem carregá-lo inteiramente.

Exemplo: leitura de feed 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>Notícias Rust</title>            <item>                <title>Lançado Rust 1.78</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!("Erro: {}", e),            _ => ()        }        buf.clear();    }    Ok(())}

Saída: títulos de todos os <item>.

Parsing DOM com roxmltree

roxmltree carrega todo o XML em uma árvore. Isso é conveniente quando você precisa acessar repetidamente diferentes nós ou modificar a estrutura.

Exemplo: extração de atributos e texto

use roxmltree::Document;

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