Serialización de objetos en Go (Golang): Guía completa

Serialización de objetos en Go (Golang): desde JSON hasta Protobuf

La serialización (marshal) es el proceso de convertir una estructura de datos (objeto) en una secuencia de bytes para su transmisión por red o almacenamiento en disco. El proceso inverso es la deserialización (unmarshal). En Go, esta tarea se resuelve con paquetes estándar y de terceros. Analicemos los enfoques principales.

1. Biblioteca estándar: encoding/json

La forma más popular. Para la serialización se utiliza el paquete encoding/json.

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

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

    // Deserialización (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}}

Etiquetas importantes de estructuras

• json:"field_name" — define el nombre del campo en JSON
• ,omitempty — omite el campo si está vacío (por ejemplo, cadena vacía, 0, nil)
• ,string — fuerza una representación de cadena para campos numéricos
• - — ignora el campo durante la serialización

2. Serialización en XML: encoding/xml

El paquete encoding/xml funciona de manera similar, pero utiliza etiquetas 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))    // Salida:    // <person age="30">    //   <name>Bob</name>    // </person>}

Se admiten atributos (,attr), elementos anidados, CDATA y espacios de nombres.

3. Serialización binaria: encoding/gob

El paquete gob es el formato propio de Go para serialización binaria. Es ideal para el intercambio de datos entre aplicaciones 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"}

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

    // Decodificación    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 de gob:

• Requiere registro previo de tipos (si se utilizan interfaces)
• Más compacto que JSON para datos binarios
• No es compatible con otros lenguajes (solo Go)

4. Protocol Buffers (protobuf)

Protocolo de Google para serialización binaria eficiente. Requiere la instalación de protoc y el plugin protoc-gen-go.

Paso 1: Definición del esquema (user.proto)

syntax = "proto3";package main;

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

Paso 2: Generación de código

protoc --go_out=. user.proto
                
    

  
También en la biblioteca
  

                
                  
                 Planificador de tareas en Node.js (node-cron, node-schedule, Bull)
      
                
                  
                 Event Bus y el patrón Observer en Swift: implementación y ejemplos
      
                
                  
                 Registro para Java: mejores soluciones y bibliotecas
      
                
                  
                 Guía completa de Symfony/EventDispatcher para PHP con ejemplos
      
                
                  
                 Validación de datos en C++: bibliotecas, métodos y ejemplos de código