Trabajo con XML en Go: encoding/xml, bibliotecas y ejemplos

Trabajo con XML en Go (Golang): guía completa con ejemplos

Go (Golang) ofrece soporte integrado para trabajar con XML a través del paquete encoding/xml. Este paquete proporciona potentes herramientas para el análisis (lectura), generación (escritura) y serialización de datos en formato XML. A diferencia de JSON, XML requiere una estructura más estricta y soporte para espacios de nombres (namespaces), lo que hace que encoding/xml sea especialmente flexible.

En este artículo, analizaremos en detalle cómo trabajar con XML en Go: desde el unmarshalling básico (conversión de XML a estructuras de Go) hasta la creación de documentos XML complejos con atributos y espacios de nombres.

Fundamentos: estructuras y etiquetas XML

Para mapear elementos XML con campos de estructuras Go, se utilizan etiquetas especiales xml. Estas definen el nombre del elemento, los atributos y el comportamiento durante la serialización.

type Person struct {    XMLName   xml.Name `xml:"person"`    ID        int      `xml:"id,attr"`    Name      string   `xml:"name"`    Age       int      `xml:"age"`    Email     string   `xml:"email,omitempty"`    Addresses []Address `xml:"address"`}

type Address struct {    City    string `xml:"city"`    Street  string `xml:"street"`    ZipCode string `xml:"zip"`}

• xml:"person" — nombre del elemento raíz.
• xml:"id,attr" — el campo se convierte en un atributo del elemento.
• xml:"email,omitempty" — el campo se omite si está vacío.
• xml:"address" — el array se serializará como varios elementos anidados.

Análisis XML: Unmarshalling

La función xml.Unmarshal convierte bytes XML en una estructura Go. Veamos un ejemplo con nuestro tipo Person:

package main

import (    "encoding/xml"    "fmt")

func main() {    xmlData := `<person id="123">    <name>Ivan Petrov</name>    <age>30</age>    <email>ivan@example.com</email>    <address>        <city>Moscú</city>        <street>Tverskaya, 1</street>        <zip>101000</zip>    </address></person>`

    var p Person    err := xml.Unmarshal([]byte(xmlData), &p)    if err != nil {        fmt.Printf("Error de análisis: %v", err)        return    }

    fmt.Printf("ID: %d", p.ID)    fmt.Printf("Nombre: %s", p.Name)    fmt.Printf("Edad: %d", p.Age)    fmt.Printf("Ciudad: %s", p.Addresses[0].City)}

Salida del programa:

ID: 123Nombre: Ivan PetrovEdad: 30Ciudad: Moscú

Generación XML: Marshalling

Para crear XML a partir de una estructura, se utiliza xml.Marshal o xml.MarshalIndent (con sangría).

func main() {    p := Person{        ID:   456,        Name: "Anna Smirnova",        Age:  25,        Email: "anna@example.com",        Addresses: []Address{            {City: "San Petersburgo", Street: "Nevsky, 10", ZipCode: "191186"},        },    }

    output, err := xml.MarshalIndent(p, "", "  ")    if err != nil {        fmt.Printf("Error de serialización: %v", err)        return    }

    fmt.Println(string(output))}

Resultado:

<person id="456">  <name>Anna Smirnova</name>  <age>25</age>  <email>anna@example.com</email>  <address>    <city>San Petersburgo</city>    <street>Nevsky, 10</street>    <zip>191186</zip>  </address></person>

Trabajo con espacios de nombres (Namespaces)

Los espacios de nombres XML se manejan a través del campo XMLName con el atributo xmlns.

type Document struct {    XMLName xml.Name `xml