Serialización de objetos en Go (Golang): JSON, XML, Gob y Protocol Buffers

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

La serialización es el proceso de convertir una estructura de datos (objeto, slice, mapa) en una secuencia de bytes para guardarla en un archivo, transmitirla por la red o almacenarla en caché. El proceso inverso es la deserialización. En Go (Golang), esta tarea se resuelve con paquetes integrados y bibliotecas de terceros. La elección de la herramienta depende de los requisitos de velocidad, tamaño de datos, legibilidad y compatibilidad con otros lenguajes.

1. Paquete integrado encoding/json

La forma más popular de serialización en Go. JSON es un formato legible por humanos y multiplataforma. El paquete encoding/json proporciona las funciones Marshal y 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"}

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

Características:

• Soporte de etiquetas de estructura para personalizar nombres de campos.
• Funciona con slices, mapas y estructuras anidadas.
• Más lento que los formatos binarios, pero conveniente para depuración.
• No soporta referencias cíclicas.

2. encoding/xml — Serialización XML

XML se utiliza en SOAP, RSS y archivos de configuración. El paquete encoding/xml funciona de manera similar a JSON, pero con etiquetas 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>}

Cuándo usarlo:

• Integración con sistemas heredados.
• Esquemas estrictos (XSD).
• Datos orientados a documentos.

3. encoding/gob — Formato binario nativo de Go

El paquete encoding/gob está creado específicamente para Go. Codifica datos de manera eficiente en formato binario y soporta tipos complejos (interfaces, canales, funciones — con limitaciones).

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

Ventajas:

• Alta velocidad y compacidad.
• Registro automático de tipos.
• Soporte de estructuras cíclicas.

Desventaja: incompatibilidad con otros lenguajes.

4. Protocol Buffers (protobuf) — Serialización binaria rápida

Desarrollado por Google. Requiere definir un esquema en un archivo .proto y generar código mediante protoc. La biblioteca google.golang.org/protobuf es el estándar moderno.

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