encoding/xml, gob e Formatos Binários

JSON cobre a maioria das APIs HTTP, mas Go também inclui encoding/xml e encoding/gob para feeds legados e caches binários nativos do Go.

Protobuf e outros codecs binários ficam ao lado da stdlib quando contratos cruzam linguagens ou precisam de tamanhos de rede compactos.

Resumo

Escolha o serializador para corresponder ao consumidor: navegadores e REST público permanecem em JSON; integrações XML corporativas usam encoding/xml; limites de processos exclusivamente Go podem usar gob; serviços gRPC usam protobuf.

Cada formato tem regras de compatibilidade, considerações de segurança e ergonomia de depuração diferentes.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

// Marshal XML
type Feed struct {
    XMLName xml.Name `xml:"feed"`
    Title   string   `xml:"title"`
    Items   []Item   `xml:"item"`
}
 
b, err := xml.Marshal(Feed{Title: "News"})
 
// registro + codificação gob (apenas Go-para-Go)
gob.Register(User{})
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
_ = enc.Encode(User{ID: 1})

Quando usar isso:

• Sistemas parceiros exigem envelopes XML ou cargas SOAP.
• Dois processos Go compartilham um arquivo de cache ou pipe sem leitores não-Go.
• Microsserviços internos já padronizam em binários gRPC/protobuf.

Exemplo de Trabalho

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

O que isso demonstra:

• xml.Name em XMLName define o elemento raiz.
• Tags de struct podem diferir por formato na mesma struct quando as formas se alinham.
• gob.Register é necessário para valores de interface e tipos concretos não exportados em alguns casos.
• O ciclo de ida e volta do gob preserva os tipos Go, mas não são legíveis por humanos.

Mergulho Profundo

encoding/xml

Tags XML espelham tags JSON: xml:"field", xml:"-", xml:",attr" para atributos, xml:",chardata" para nós de texto.

xml.Unmarshal é rigoroso ao corresponder elementos de início; namespaces podem exigir atributos xmlns em structs.

Use XML quando:

• Integrando com barramentos corporativos legados, RSS/Atom ou esquemas governamentais.
• Um contrato WSDL ou XSD já existe.

Evite XML para novas APIs móveis ou de navegador públicas, a menos que seja necessário.

encoding/gob

gob codifica informações de tipo Go na rede.

Tanto o codificador quanto o decodificador devem concordar com os tipos registrados quando interfaces estão envolvidas.

gob não é adequado para:

• Clientes de navegador.
• Microsserviços políglota.
• Armazenamento de longo prazo quando os tipos Go podem renomear campos.

gob se encaixa:

• Cache de structs computadas localmente entre duas binários Go que você implanta juntas.
• Ferramentas internas estilo net/rpc (legado; prefira gRPC para novo trabalho).

Formatos Binários Além da Stdlib

google.golang.org/grpc usa protobuf sobre HTTP/2; veja Noções Básicas de gRPC para o fluxo de trabalho de geração de código.

Notas Go

// Prefira DTOs separados quando as formas XML e JSON divergirem
type UserXML struct { /* tags xml */ }
type UserJSON struct { /* tags json */ }

Misturar muitas famílias de tags em uma mega-struct complica as revisões; divida quando as formas de rede diferirem materialmente.

Armadilhas

• gob sem Register - Codificar valores de interface causa pânico ou falha em tempo de execução. Correção: chame gob.Register para tipos concretos na inicialização.
• Surpresas de namespace XML - XMLName ausente ou tags xmlns quebram o unmarshal. Correção: espelhe exatamente a amostra XML do parceiro nos testes.
• gob e campos renomeados - gob rastreia nomes de campos, não tags; renomeações quebram blobs cacheados. Correção: versione as chaves de cache ou use JSON/protobuf para armazenamento durável.
• Codificação binária dupla - Colocar bytes gob em JSON como strings sem base64 quebra os clientes. Correção: use base64 em JSON ou escolha um formato por endpoint.
• Atributo vs elemento XML - O mesmo nome de campo em atributo e elemento filho colide. Correção: separe structs ou use formas de tag explícitas.
• Segurança: mil risadas - Analisadores XML podem ser abusados com entidades expansivas. Correção: limite o tamanho do leitor, desabilite DTDs se o seu analisador permitir, defina tempo limite para leituras.

Alternativas

FAQs

Relacionados

• Serialização em Go: JSON Primeiro, Formatos Sob Demanda - visão geral da seleção de formato
• Noções Básicas de gRPC - geração de código protobuf
• Design de Esquema de Protocol Buffers - contratos binários duráveis
• Tags de Struct para JSON, DB e Validação - tags multiformato
• Melhores Práticas de Serialização - política de formato por limite

Versões da Pilha: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizers - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos da placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).