Arbeiten mit XML in Go: encoding/xml, Bibliotheken und Beispiele

Arbeiten mit XML in Go (Golang): vollständige Anleitung mit Beispielen

Go (Golang) bietet integrierte Unterstützung für die Arbeit mit XML über das Paket encoding/xml. Dieses Paket bietet leistungsstarke Werkzeuge zum Parsen (Lesen), Generieren (Schreiben) und Serialisieren von Daten im XML-Format. Im Gegensatz zu JSON erfordert XML eine strengere Struktur und Unterstützung für Namespaces, was encoding/xml besonders flexibel macht.

In diesem Artikel werden wir im Detail besprechen, wie man mit XML in Go arbeitet: vom grundlegenden Unmarshalling (Umwandlung von XML in Go-Strukturen) bis zur Erstellung komplexer XML-Dokumente mit Attributen und Namespaces.

Grundlagen: Strukturen und XML-Tags

Für die Zuordnung von XML-Elementen zu Feldern von Go-Strukturen werden spezielle xml-Tags verwendet. Sie definieren den Elementnamen, Attribute und das Verhalten bei der Serialisierung.

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" — Name des Wurzelelements.
• xml:"id,attr" — das Feld wird zu einem Attribut des Elements.
• xml:"email,omitempty" — das Feld wird übersprungen, wenn es leer ist.
• xml:"address" — das Array wird als mehrere verschachtelte Elemente serialisiert.

XML-Parsing: Unmarshalling

Die Funktion xml.Unmarshal wandelt XML-Bytes in eine Go-Struktur um. Betrachten wir ein Beispiel mit unserem Typ Person:

package main

import (    "encoding/xml"    "fmt")

func main() {    xmlData := `<person id="123">    <name>Iwan Petrow</name>    <age>30</age>    <email>ivan@example.com</email>    <address>        <city>Moskau</city>        <street>Twerskaja, 1</street>        <zip>101000</zip>    </address></person>`

    var p Person    err := xml.Unmarshal([]byte(xmlData), &p)    if err != nil {        fmt.Printf("Parsing-Fehler: %v", err)        return    }

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

Ausgabe des Programms:

ID: 123Name: Iwan PetrowAlter: 30Stadt: Moskau

XML-Generierung: Marshalling

Zur Erstellung von XML aus einer Struktur wird xml.Marshal oder xml.MarshalIndent (mit Einrückungen) verwendet.

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

    output, err := xml.MarshalIndent(p, "", "  ")    if err != nil {        fmt.Printf("Serialisierungsfehler: %v", err)        return    }

    fmt.Println(string(output))}

Ergebnis:

<person id="456">  <name>Anna Smirnowa</name>  <age>25</age>  <email>anna@example.com</email>  <address>    <city>Sankt Petersburg</city>    <street>Newski, 10</street>    <zip>191186</zip>  </address></person>

Arbeiten mit Namespaces

XML-Namespaces werden über das Feld XMLName mit dem Attribut xmlns verarbeitet.

type Document struct {    XMLName xml.Name `xml