Travailler avec XML en Go (Golang) : le package encoding/xml et ses alternatives

Introduction au traitement XML en langage Go

Le langage Go (Golang) offre une manière puissante et élégante de travailler avec XML via le package standard encoding/xml. Ce package implémente une interface simple pour la lecture (analyse) et l'écriture (sérialisation) de documents XML, en utilisant des annotations sur les structures (struct tags). Contrairement à de nombreux autres langages, Go ne nécessite pas de créer des analyseurs DOM ou SAX séparés — il suffit de décrire la structure des données, et le package associe automatiquement les balises XML aux champs.

Dans cet article, nous allons détailler les principales fonctionnalités du package encoding/xml, en commençant par l'analyse de base et en terminant par des techniques avancées : gestion des attributs, des espaces de noms, lecture en flux de gros fichiers et génération de XML. Nous examinerons également les bibliothèques tierces populaires qui peuvent être utiles dans des scénarios spécifiques.

Fondamentaux : analyse XML en structures Go

La méthode la plus courante pour travailler avec XML en Go est la désérialisation (unmarshal) des données XML en instances de structures. Pour cela, on utilise la fonction xml.Unmarshal(). La caractéristique clé est l'utilisation de balises xml:"..." dans la déclaration des champs de la structure.

Exemple simple : analyse d'un flux RSS

package main

import (    "encoding/xml"    "fmt")

// Structure pour un élément RSStype RSS struct {    XMLName xml.Name `xml:"rss"`    Channel Channel  `xml:"channel"`}

type Channel struct {    Title       string    `xml:"title"`    Description string    `xml:"description"`    Items       []Item    `xml:"item"`}

type Item struct {    Title       string `xml:"title"`    Link        string `xml:"link"`    Description string `xml:"description"`}

func main() {    data := `<?xml version="1.0" encoding="UTF-8"?>    <rss version="2.0">        <channel>            <title>Example Feed</title>            <description>A sample RSS feed</description>            <item>                <title>First Post</title>                <link>https://example.com/1</link>                <description>This is the first post.</description>            </item>        </channel>    </rss>`

    var rss RSS    err := xml.Unmarshal([]byte(data), &rss)    if err != nil {        panic(err)    }

    fmt.Printf("Canal : %s", rss.Channel.Title)    fmt.Printf("Description : %s", rss.Channel.Description)    for _, item := range rss.Channel.Items {        fmt.Printf("- %s (%s)", item.Title, item.Link)    }}

Dans cet exemple, la balise xml:"rss" associe la structure à l'élément racine, et xml:"channel", xml:"item" aux éléments imbriqués. Le champ XMLName est facultatif, mais permet d'obtenir le nom de l'élément racine.

Gestion des attributs XML

Les attributs XML sont traités via une syntaxe spéciale dans la balise : xml:"nom_balise,attr". Si l'attribut se trouve directement dans l'élément racine, on utilise xml:",attr".

type Person struct {    XMLName xml.Name `xml:"person"`    ID      int      `xml:"id,attr"`    Name    string   `xml:"name"`    Age     int      `xml:"age,attr"`}

func main() {    xmlData := `<person id="123" age="30"><name>Alice</name></person>`    var p Person    xml.Unmarshal([]byte(xmlData), &p)    fmt.Printf("ID : %d, Nom : %s, Âge : %d", p.ID, p.Name, p.Age)    // Affichage : ID : 123, Nom : Alice, Âge : 30}

Génération (sérialisation) de XML

Pour créer du XML à partir d'une structure, on utilise la fonction xml.Marshal() ou xml.MarshalIndent() pour une sortie formatée. Le package utilise automatiquement les balises des structures pour générer les noms corrects des éléments et des attributs.

type Book struct {    XMLName xml.Name `xml:"book"`    Title   string