Objektserialisierung in Go (Golang): Ein vollständiger Leitfaden

Objektserialisierung in Go (Golang): von JSON bis Protobuf

Serialisierung (Marshalling) ist der Prozess der Umwandlung einer Datenstruktur (eines Objekts) in eine Byte-Sequenz zur Übertragung über ein Netzwerk oder zur Speicherung auf einer Festplatte. Der umgekehrte Prozess ist die Deserialisierung (Unmarshalling). In Go wird diese Aufgabe mit Standard- und Drittanbieter-Paketen gelöst. Betrachten wir die wichtigsten Ansätze.

1. Standardbibliothek: encoding/json

Die beliebteste Methode. Für die Serialisierung wird das Paket encoding/json verwendet.

Basisbeispiel

package main

import (    "encoding/json"    "fmt"    "log")

type User struct {    ID    int    `json:"id"`    Name  string `json:"name"`    Email string `json:"email,omitempty"`}

func main() {    user := User{ID: 1, Name: "Alice", Email: "alice@example.com"}

    // Serialisierung (Marshal)    jsonData, err := json.Marshal(user)    if err != nil {        log.Fatal(err)    }    fmt.Println(string(jsonData)) // {"id":1,"name":"Alice","email":"alice@example.com"}

    // Deserialisierung (Unmarshal)    var decoded User    err = json.Unmarshal(jsonData, &decoded)    if err != nil {        log.Fatal(err)    }    fmt.Printf("%+v", decoded) // {ID:1 Name:Alice Email:alice@example.com}}

Wichtige Struktur-Tags

• json:"field_name" — legt den Feldnamen in JSON fest
• ,omitempty — überspringt das Feld, wenn es leer ist (z. B. leerer String, 0, nil)
• ,string — erzwingt eine String-Darstellung für numerische Felder
• - — ignoriert das Feld bei der Serialisierung

2. Serialisierung in XML: encoding/xml

Das Paket encoding/xml funktioniert nach einem ähnlichen Prinzip, verwendet aber XML-Tags.

package main

import (    "encoding/xml"    "fmt")

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

func main() {    p := Person{Name: "Bob", Age: 30}    xmlData, _ := xml.MarshalIndent(p, "", "  ")    fmt.Println(string(xmlData))    // Ausgabe:    // <person age="30">    //   <name>Bob</name>    // </person>}

Unterstützt werden Attribute (,attr), verschachtelte Elemente, CDATA und Namensräume.

3. Binäre Serialisierung: encoding/gob

Das Paket gob ist das eigene Format von Go für die binäre Serialisierung. Ideal für den Datenaustausch zwischen Go-Anwendungen.

package main

import (    "bytes"    "encoding/gob"    "fmt"    "log")

type Data struct {    X, Y int    Label string}

func main() {    var buf bytes.Buffer    enc := gob.NewEncoder(&buf)    data := Data{X: 10, Y: 20, Label: "test"}

    // Kodierung    if err := enc.Encode(data); err != nil {        log.Fatal(err)    }

    // Dekodierung    var decoded Data    dec := gob.NewDecoder(&buf)    if err := dec.Decode(&decoded); err != nil {        log.Fatal(err)    }    fmt.Printf("%+v", decoded) // {X:10 Y:20 Label:test}}

Besonderheiten von gob:

• Erfordert die vorherige Registrierung von Typen (falls Schnittstellen verwendet werden)
• Kompakter als JSON für binäre Daten
• Wird von anderen Sprachen nicht unterstützt (nur Go)

4. Protocol Buffers (protobuf)

Das Google-Protokoll für effiziente binäre Serialisierung. Erfordert die Installation von protoc und des Plugins protoc-gen-go.

Schritt 1: Schema-Definition (user.proto)

syntax = "proto3";package main;

message User {  int32 id = 1;  string name = 2;  string email = 3;}

Schritt 2: Code-Generierung

protoc --go_out=. user.proto
                
    

  
Auch in der Bibliothek
  

                
                  
                 Arbeiten mit CSV in Go (Golang): vollständige Anleitung zu encoding/csv
      
                
                  
                 Aufgabenwarteschlangen für JavaScript (Node.js): Bull, Bee-Queue, Kue
      
                
                  
                 Arbeiten mit YAML in Kotlin: Bibliotheken und Beispiele
      
                
                  
                 Puppeteer für JavaScript (Node.js): Komplettguide mit Beispielen
      
                
                  
                 Verarbeitung und Parsing von XML in TypeScript: Bibliotheken und praktische Beispiele