Serialização de objetos em Go (Golang): JSON, XML, Gob e Protocol Buffers

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

Serialização é o processo de converter uma estrutura de dados (objeto, slice, mapa) em uma sequência de bytes para salvar em arquivo, transmitir pela rede ou armazenar em cache. O processo inverso é a desserialização. Em Go (Golang), essa tarefa é resolvida por pacotes nativos e bibliotecas de terceiros. A escolha da ferramenta depende dos requisitos de velocidade, tamanho dos dados, legibilidade e compatibilidade com outras linguagens.

1. Pacote nativo encoding/json

A forma mais popular de serialização em Go. JSON é um formato legível por humanos e multiplataforma. O pacote encoding/json fornece as funções Marshal e Unmarshal.

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    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    var decoded User    err = json.Unmarshal(jsonData, &decoded)    if err != nil {        log.Fatal(err)    }    fmt.Printf("%+v", decoded)}

Características:

• Suporte a tags de estrutura para configurar nomes dos campos.
• Funciona com slices, mapas e estruturas aninhadas.
• Mais lento que formatos binários, mas conveniente para depuração.
• Não suporta referências cíclicas.

2. encoding/xml — Serialização XML

XML é usado em SOAP, RSS e arquivos de configuração. O pacote encoding/xml funciona de forma semelhante ao JSON, mas com tags xml.

type Book struct {    Title  string `xml:"title"`    Author string `xml:"author"`    Pages  int    `xml:"pages,attr"`}

func main() {    book := Book{Title: "Go in Action", Author: "William Kennedy", Pages: 500}    xmlData, _ := xml.MarshalIndent(book, "", "  ")    fmt.Println(string(xmlData))    // <Book pages="500">    //   <title>Go in Action</title>    //   <author>William Kennedy</author>    // </Book>}

Quando usar:

• Integração com sistemas legados.
• Esquemas rigorosos (XSD).
• Dados orientados a documentos.

3. encoding/gob — Formato binário nativo do Go

O pacote encoding/gob foi criado especificamente para Go. Ele codifica dados de forma eficiente em formato binário, suportando tipos complexos (interfaces, canais, funções — com limitações).

import "encoding/gob"

type Task struct {    ID     int    Status string}

func main() {    var network bytes.Buffer    enc := gob.NewEncoder(&network)    dec := gob.NewDecoder(&network)

    task := Task{ID: 42, Status: "done"}    err := enc.Encode(task)    if err != nil {        log.Fatal(err)    }

    var restored Task    err = dec.Decode(&restored)    fmt.Println(restored) // {42 done}}

Vantagens:

• Alta velocidade e compactação.
• Registro automático de tipos.
• Suporte a estruturas cíclicas.

Desvantagem: incompatibilidade com outras linguagens.

4. Protocol Buffers (protobuf) — Serialização binária rápida

Desenvolvido pelo Google. Requer definição de esquema em arquivo .proto e geração de código via protoc. A biblioteca google.golang.org/protobuf é o padrão moderno.

// user.proto// syntax = "proto3";// message User {//   int32 id = 1;//   string name =