encoding/xml, gob y Formatos Binarios

JSON cubre la mayoría de las API HTTP, pero Go también incluye encoding/xml y encoding/gob para feeds heredados y cachés binarios nativos de Go.

Protobuf y otros códecs binarios se sitúan junto a la biblioteca estándar cuando los contratos cruzan lenguajes o necesitan tamaños de cable compactos.

Resumen

Elija el serializador para que coincida con el consumidor: los navegadores y las REST públicas se quedan con JSON; las integraciones empresariales XML utilizan encoding/xml; los límites de procesos solo de Go pueden usar gob; los servicios gRPC usan protobuf.

Cada formato tiene diferentes reglas de compatibilidad, consideraciones de seguridad y ergonomía de depuración.

Receta

Tarjeta de receta de referencia rápida, lista para copiar y pegar.

// XML marshal
type Feed struct {
    XMLName xml.Name `xml:"feed"`
    Title   string   `xml:"title"`
    Items   []Item   `xml:"item"`
}
 
b, err := xml.Marshal(Feed{Title: "News"})
 
// registro gob + codificación (solo Go a Go)
gob.Register(User{})
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
_ = enc.Encode(User{ID: 1})

Cuándo recurrir a esto:

• Los sistemas asociados requieren sobres XML o cargas útiles estilo SOAP.
• Dos procesos de Go comparten un archivo de caché o una tubería sin lectores que no sean de Go.
• Los microservicios internos ya se estandarizan en binarios gRPC/protobuf.

Ejemplo de Trabajo

package main
 
import (
    "bytes"
    "encoding/gob"
    "encoding/xml"
    "fmt"
)
 
type Item struct {
    ID    int    `xml:"id" json:"id"`
    Label string `xml:"label" json:"label"`
}
 
type Catalog struct {
    XMLName xml.Name `xml:"catalog"`
    Items   []Item   `xml:"item"`
}
 
type CacheEntry struct {
    Key   string
    Items []Item
}
 
func main() {
    cat := Catalog{Items: []Item{{ID: 1, Label: "bolt"}}}
    xmlBytes, _ := xml.MarshalIndent(cat, "", "  ")
    fmt.Println(string(xmlBytes))
 
    gob.Register(CacheEntry{})
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)
    _ = enc.Encode(CacheEntry{Key: "parts", Items: cat.Items})
 
    dec := gob.NewDecoder(&buf)
    var restored CacheEntry
    _ = dec.Decode(&restored)
    fmt.Println(restored.Items[0].Label)
}

Lo que esto demuestra:

• xml.Name en XMLName establece el elemento raíz.
• Las etiquetas de estructura pueden diferir por formato en la misma estructura cuando las formas se alinean.
• gob.Register es necesario para valores de interfaz y tipos concretos no exportados en algunos casos.
• Las idas y vueltas de gob preservan los tipos de Go pero no son legibles por humanos.

Inmersión Profunda

encoding/xml

Las etiquetas XML reflejan las etiquetas JSON: xml:"field", xml:"-", xml:",attr" para atributos, xml:",chardata" para nodos de texto.

xml.Unmarshal es estricto al hacer coincidir los elementos de inicio; los espacios de nombres pueden requerir atributos xmlns en las estructuras.

Use XML cuando:

• Se integre con buses empresariales heredados, RSS/Atom o esquemas gubernamentales.
• Ya exista un contrato WSDL o XSD.

Evite XML para nuevas API móviles o de navegador públicas a menos que sea necesario.

encoding/gob

gob codifica la información de tipo de Go en el cable.

Tanto el codificador como el decodificador deben estar de acuerdo con los tipos registrados cuando hay interfaces involucradas.

gob no es adecuado para:

• Clientes del navegador.
• Microservicios políglotas.
• Almacenamiento a largo plazo cuando los tipos de Go pueden renombrar campos.

gob encaja:

• Almacenar en caché estructuras calculadas localmente entre dos binarios de Go que implemente juntos.
• Herramientas internas estilo net/rpc (heredado; prefiera gRPC para nuevo trabajo).

Formatos binarios más allá de la biblioteca estándar

google.golang.org/grpc usa protobuf sobre HTTP/2; consulte Fundamentos de gRPC para el flujo de trabajo de generación de código.

Notas de Go

// Prefiera DTOs separados cuando las formas XML y JSON diverjan
type UserXML struct { /* etiquetas xml */ }
type UserJSON struct { /* etiquetas json */ }

Mezclar muchas familias de etiquetas en una mega-estructura complica las revisiones; divida cuando las formas del cable difieran materialmente.

Trampas

• gob sin Register - La codificación de valores de interfaz falla o se interrumpe en tiempo de ejecución. Solución: llame a gob.Register para tipos concretos al inicio.
• Sorpresas de espacio de nombres XML - La falta de XMLName o etiquetas xmlns rompe la desserialización. Solución: refleje la muestra XML del socio exactamente en las pruebas.
• gob y campos renombrados - gob rastrea los nombres de los campos, no las etiquetas; los cambios de nombre rompen los blobs en caché. Solución: versione las claves de caché o quédese con JSON/protobuf para el almacenamiento duradero.
• Codificación doble de binario - Insertar bytes gob en JSON como cadenas sin base64 rompe a los clientes. Solución: use base64 en JSON o elija un formato por punto final.
• Atributo XML vs elemento - El mismo nombre de campo en un atributo y un elemento hijo colisiona. Solución: estructuras separadas o formas de etiquetas explícitas.
• Seguridad: mil risas - Los analizadores XML pueden ser abusados con entidades expansivas. Solución: limite el tamaño del lector, deshabilite las DTD si su analizador lo permite, establezca tiempos de espera para las lecturas.

Alternativas

Preguntas Frecuentes

Relacionado

• Serialización en Go: JSON Primero, Formatos Bajo Demanda - resumen de selección de formato
• Fundamentos de gRPC - generación de código protobuf
• Diseño de Esquemas de Protocol Buffers - contratos binarios duraderos
• Etiquetas de Estructura para JSON, DB y Validación - etiquetas multiformato
• Mejores Prácticas de Serialización - política de formato por límite

Versiones de la pila: Esta página fue escrita para Go 1.26.x (predeterminado de GC Green Tea, go fix modernizers - verifique el parche en la compilación), chi (última versión - verifique en la compilación), gin (última versión - verifique en la compilación), echo (última versión - verifique en la compilación), google.golang.org/grpc (última versión - verifique en la compilación), sigs.k8s.io/controller-runtime (última versión - verifique en la compilación), kubebuilder (última versión - verifique en la compilación), tinygo (última versión - verifique los objetivos de la placa en la compilación), wazero (última versión - verifique en la compilación) y golangci-lint (última versión - verifique el conjunto de linters en la compilación).