Trabalho com XML em Go (Golang): pacote encoding/xml e alternativas

Introdução ao processamento de XML na linguagem Go

A linguagem Go (Golang) oferece uma forma poderosa e elegante de trabalhar com XML através do pacote padrão encoding/xml. Este pacote implementa uma interface simples para leitura (parsing) e escrita (serialização) de documentos XML, usando anotações em structs (struct tags). Ao contrário de muitas outras linguagens, Go não requer a criação de parsers DOM ou SAX separados — basta descrever a estrutura de dados, e o próprio pacote mapeia as tags XML para os campos.

Neste artigo, vamos explorar detalhadamente as principais funcionalidades do pacote encoding/xml, começando pelo parsing básico e indo até técnicas avançadas: manipulação de atributos, namespaces, leitura em streaming de arquivos grandes e geração de XML. Também veremos bibliotecas de terceiros populares que podem ser úteis em cenários específicos.

Fundamentos: parsing de XML em structs Go

A forma mais comum de trabalhar com XML em Go é através da desserialização (unmarshal) de dados XML em instâncias de structs. Para isso, utiliza-se a função xml.Unmarshal(). A característica principal é o uso de tags xml:"..." na declaração dos campos da struct.

Exemplo simples: parsing de um feed RSS

package main

import (    "encoding/xml"    "fmt")

// Estrutura para o elemento 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("Descrição: %s", rss.Channel.Description)    for _, item := range rss.Channel.Items {        fmt.Printf("- %s (%s)", item.Title, item.Link)    }}

Neste exemplo, a tag xml:"rss" vincula a struct ao elemento raiz, e xml:"channel", xml:"item" aos elementos aninhados. O campo XMLName é opcional, mas permite obter o nome do elemento raiz.

Trabalhando com atributos XML

Os atributos XML são tratados através de uma sintaxe especial na tag: xml:"nome_da_tag,attr". Se o atributo estiver diretamente no elemento raiz, usa-se 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, Nome: %s, Idade: %d", p.ID, p.Name, p.Age)    // Saída: ID: 123, Nome: Alice, Idade: 30}

Geração (serialização) de XML

Para criar XML a partir de uma struct, utiliza-se a função xml.Marshal() ou xml.MarshalIndent() para saída formatada. O pacote usa automaticamente as tags das structs para gerar os nomes corretos dos elementos e atributos.

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