Sérialisation d'objets en Go (Golang) : Guide complet

Sérialisation d'objets en Go (Golang) : de JSON à Protobuf

La sérialisation (marshal) est le processus de conversion d'une structure de données (objet) en une séquence d'octets pour la transmission sur un réseau ou la sauvegarde sur disque. Le processus inverse est la désérialisation (unmarshal). En Go, cette tâche est résolue par des paquets standards et tiers. Examinons les principales approches.

1. Bibliothèque standard : encoding/json

La méthode la plus populaire. Pour la sérialisation, on utilise le paquet encoding/json.

Exemple de base

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"}

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

    // Désérialisation (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}}

Étiquettes de structure importantes

• json:"field_name" — définit le nom du champ en JSON
• ,omitempty — ignore le champ s'il est vide (par exemple, chaîne vide, 0, nil)
• ,string — force la représentation sous forme de chaîne pour les champs numériques
• - — ignore le champ lors de la sérialisation

2. Sérialisation en XML : encoding/xml

Le paquet encoding/xml fonctionne sur un principe similaire, mais utilise des balises XML.

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))    // Sortie :    // <person age="30">    //   <name>Bob</name>    // </person>}

Les attributs (,attr), les éléments imbriqués, CDATA et les espaces de noms sont pris en charge.

3. Sérialisation binaire : encoding/gob

Le paquet gob est le format natif de Go pour la sérialisation binaire. Idéal pour l'échange de données entre applications Go.

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"}

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

    // Décodage    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}}

Caractéristiques de gob :

• Nécessite un enregistrement préalable des types (si des interfaces sont utilisées)
• Plus compact que JSON pour les données binaires
• Non pris en charge par d'autres langages (uniquement Go)

4. Protocol Buffers (protobuf)

Protocole de Google pour une sérialisation binaire efficace. Nécessite l'installation de protoc et du plugin protoc-gen-go.

Étape 1 : Définition du schéma (user.proto)

syntax = "proto3";package main;

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

Étape 2 : Génération du code

protoc --go_out=. user.proto