Arbeiten mit XML in Go (Golang): Die Standardbibliothek encoding/xml

Arbeiten mit XML in Go (Golang): Ausführliche Anleitung zum Paket encoding/xml

In der modernen Entwicklung mit Go (Golang) kommt die Aufgabe der Verarbeitung von XML-Daten recht häufig vor – von der Integration mit Altsystemen bis zum Datenaustausch in SOAP-Diensten. Die Standardbibliothek von Go bietet ein leistungsstarkes und flexibles Paket encoding/xml, mit dem Sie XML-Dokumente effizient parsen, erstellen und umwandeln können. In diesem Artikel werden wir alle wichtigen Möglichkeiten der Arbeit mit XML in Go im Detail besprechen.

Hauptfunktionen des Pakets encoding/xml

Das Paket encoding/xml implementiert eine einfache Schnittstelle zur Serialisierung (Marshaling) von Go-Strukturen in XML und zur Deserialisierung (Unmarshaling) von XML zurück in Strukturen. Es unterstützt:

• Umwandlung von Go-Strukturen in XML-Dokumente und umgekehrt
• Arbeit mit Attributen, verschachtelten Elementen und Namespaces
• Streaming-Parsing großer XML-Dateien mit xml.Decoder
• Anpassbare Serialisierungsregeln mittels Struktur-Tags

Installation und Import des Pakets

Das Paket encoding/xml ist Teil der Go-Standardbibliothek, daher ist keine zusätzliche Installation erforderlich. Für die Nutzung reicht es aus, es zu importieren:

import (    "encoding/xml"    "fmt"    "os")

Marshaling: Go-Struktur → XML

Zur Umwandlung einer Go-Struktur in XML wird die Funktion xml.Marshal() oder xml.MarshalIndent() für formatierte Ausgabe verwendet. Betrachten wir ein Beispiel:

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

func main() {    p := Person{        ID:        123,        FirstName: "Ivan",        LastName:  "Petrov",        Age:       30,    }

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

    fmt.Println(string(output))}

Ergebnis der Ausführung:

<person id="123">  <name>    <first>Ivan</first>    <last>Petrov</last>  </name>  <age>30</age></person>

Unmarshaling: XML → Go-Struktur

Der umgekehrte Prozess – die Umwandlung von XML-Daten in eine Go-Struktur – erfolgt mit xml.Unmarshal():

func unmarshalExample() {    xmlData := `<person id="456">  <name>    <first>Maria</first>    <last>Sidorova</last>  </name>  <age>25</age></person>`

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

    fmt.Printf("ID: %d, Name: %s %s, Alter: %d", p.ID, p.FirstName, p.LastName, p.Age)    // Ausgabe: ID: 456, Name: Maria Sidorova, Alter: 25}

Arbeit mit Attributen und verschachtelten Elementen

Das Paket encoding/xml verwendet Struktur-Tags zur Steuerung der Abbildung. Die wichtigsten Tag-Direktiven:

• xml:"name" – Name des Elements
• xml:"name,attr" – Attribut des Elements
• xml:"parent>child" – verschachteltes Element
• xml:",chardata" – Textinhalt
• xml:",innerxml" – rohes XML innerhalb des Elements
• xml:",comment" – XML-Kommentar
• xml:"-" – Feld ignorieren

Streaming-Parsing großer XML-Dateien

Zur Verarbeitung großer XML-Dokumente (z. B. Dateien mit einer Größe von Gigabyte) wird der Streaming-Parser xml.Decoder verwendet. Dies ermöglicht es, den Speicher nicht zu übe