Serialização de objetos em Go (Golang): Guia completo

Serialização de objetos em Go (Golang): do JSON ao Protobuf

Serialização (marshalling) é o processo de converter uma estrutura de dados (objeto) em uma sequência de bytes para transmissão pela rede ou armazenamento em disco. O processo inverso é a desserialização (unmarshalling). Em Go, essa tarefa é resolvida por pacotes padrão e de terceiros. Vamos analisar as principais abordagens.

1. Biblioteca padrão: encoding/json

A forma mais popular. Para serialização, utiliza-se o pacote encoding/json.

Exemplo básico

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

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

    // Desserialização (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}}

Tags importantes de struct

• json:"field_name" — define o nome do campo em JSON
• ,omitempty — ignora o campo se estiver vazio (ex.: string vazia, 0, nil)
• ,string — força a representação como string para campos numéricos
• - — ignora o campo durante a serialização

2. Serialização em XML: encoding/xml

O pacote encoding/xml funciona de forma semelhante, mas usa tags 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))    // Saída:    // <person age="30">    //   <name>Bob</name>    // </person>}

Suporta atributos (,attr), elementos aninhados, CDATA e namespaces.

3. Serialização binária: encoding/gob

O pacote gob é o formato nativo do Go para serialização binária. Ideal para troca de dados entre aplicações 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"}

    // Codificação    if err := enc.Encode(data); err != nil {        log.Fatal(err)    }

    // Decodificação    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}}

Características do gob:

• Requer registro prévio de tipos (se forem usadas interfaces)
• Mais compacto que JSON para dados binários
• Não suportado por outras linguagens (apenas Go)

4. Protocol Buffers (protobuf)

Protocolo do Google para serialização binária eficiente. Requer instalação do protoc e do plugin protoc-gen-go.

Passo 1: Definição do esquema (user.proto)

syntax = "proto3";package main;

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

Passo 2: Geração de código

protoc --go_out=. user.proto
                
    

  
Também na biblioteca
  

                
                  
                 Frameworks CLI para Kotlin: Clikt, kotlinx-cli, picocli — visão geral e comparação
      
                
                  
                 deepkit/type para TypeScript: guia completo com exemplos
      
                
                  
                 Trabalho com datas em JavaScript (Node.js): bibliotecas populares
      
                
                  
                 Cache em C++: Redis, Memcached e soluções embutidas
      
                
                  
                 Processamento de JSON em Kotlin: bibliotecas, parsing e serialização