Lección 7 de 20 · Lectura y práctica
Serialización y deserialización JSON eficiente
Concepto claveLa serialización y deserialización JSON son procesos fundamentales en APIs REST que convierten estructuras de datos Go en texto JSON (serialización) y viceversa (deserialización). Piensa en esto como un traductor.
Del concepto a la práctica
Taller de esta lección
La eficiencia aquí empieza por controlar el cuerpo y el contrato. Un decoder puede rechazar campos desconocidos, mientras http.MaxBytesReader evita que una petición local consuma memoria sin límite. Para un sensor, aceptar solo name y value hace visible cualquier error de cliente.
Ejemplo resuelto
El helper completo siguiente decodifica y valida la lectura.
El JSON {"name":"temp","value":21.5} se convierte en una estructura; {"name":"temp","value":21.5,"unit":"C"} se rechaza por campo inesperado.
Pruébalo
Define el límite de 1024 bytes.
Decodifica una lectura válida y codifícala de nuevo.
Envía un campo adicional y captura el error.
Comprueba el límite y un único objeto; el servidor gestiona cierre del cuerpo entrante.
Error frecuente: confundir JSON válido con JSON permitido. Corrígelo aplicando reglas de estructura después de la decodificación y usando DisallowUnknownFields cuando el contrato sea cerrado.
Comprueba tu resultado
La lectura válida debe conservar name y value. El JSON con unit debe devolver 400 y nunca producir una lectura almacenada.
Decoder por petición y un solo objeto
encoding/json.Encoder y Decoder no ofrecen Reset para reasignar writer/reader; los pools con encoder.Reset/decoder.Reset del material histórico no compilan. Crea un decoder por petición; una mejora de rendimiento requiere medición y no justificar APIs inexistentes. Este helper es completo en un paquete que importe encoding/json,errors,io,net/http,strings:
type Reading struct { Name string `json:"name"`; Value *float64 `json:"value"` }
func decodeReading(w http.ResponseWriter,r *http.Request)(Reading,error){
r.Body=http.MaxBytesReader(w,r.Body,1024)
dec:=json.NewDecoder(r.Body);dec.DisallowUnknownFields()
var in Reading
if err:=dec.Decode(&in);err!=nil{return in,err}
if err:=dec.Decode(&struct{}{});err!=io.EOF{return in,errors.New("un solo objeto JSON")}
in.Name=strings.TrimSpace(in.Name)
if in.Name==""||in.Value==nil{return in,errors.New("name y value obligatorios")}
return in,nil
}Pointer distingue value ausente/null de0 válido. Acepta temp/21.5 y temp/0; rechaza unit, un segundo objeto, null, nombre vacío y cuerpo excedido. El handler mapea errores de formato a400 y *http.MaxBytesError a413 si declara esa política. El servidor cierra el cuerpo entrante; quien usa un cliente HTTP debe cerrar response.Body. DisallowUnknownFields no garantiza rechazo de claves duplicadas: si eso importa, implementa detección expresa. JSON.

Mapa de prácticaEl navegador envía una solicitud a la API. El servidor valida la operación y consulta los datos; después devuelve una respuesta que el navegador puede mostrar. La base de datos se comunica con el servidor y no directamente con el navegador.
Ver la infografía en tamaño completo ↗Concepto clave
La serialización y deserialización JSON son procesos fundamentales en APIs REST que convierten estructuras de datos Go en texto JSON (serialización) y viceversa (deserialización). Piensa en esto como un traductor que convierte entre dos idiomas: Go (el lenguaje de tu aplicación) y JSON (el lenguaje de la web).
En APIs de alto rendimiento, la eficiencia de estos procesos impacta directamente en el tiempo de respuesta y consumo de recursos. Una mala implementación puede causar cuellos de botella, especialmente en microservicios que procesan miles de solicitudes por segundo. La clave está en entender cómo Go maneja la reflexión y la asignación de memoria durante estas conversiones.
Cómo funciona en la práctica
Cuando un cliente envía una solicitud POST con datos JSON, tu API debe:
- Leer el cuerpo de la solicitud HTTP
- Deserializar el JSON a una estructura Go
- Validar y procesar los datos
- Serializar la respuesta a JSON
- Enviar la respuesta HTTP
El paquete encoding/json de Go proporciona las funciones json.Marshal() para serialización y json.Unmarshal() para deserialización. Sin embargo, usar estas funciones de forma ingenua puede ser costoso en términos de rendimiento.
Código en acción
Veamos primero un enfoque básico y luego uno optimizado:
Antes: Enfoque básico
package main
import (
"encoding/json"
"net/http"
)
type User struct {
ID int `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
Age int `json:"age"`
}
func createUserHandler(w http.ResponseWriter, r *http.Request) {
var user User
// Deserialización básica
err := json.NewDecoder(r.Body).Decode(&user)
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// Procesamiento...
user.ID = generateID()
// Serialización básica
response, err := json.Marshal(user)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write(response)
}
func generateID() int {
return 1 // Simplificado para el ejemplo
}Después: Enfoque optimizado
package main
import (
"encoding/json"
"net/http"
"sync"
)
type User struct {
ID int `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
Age int `json:"age,omitempty"` // omitempty evita serializar si es cero
}
var (
jsonEncoderPool = sync.Pool{
New: func() interface{} {
return json.NewEncoder(nil)
},
}
jsonDecoderPool = sync.Pool{
New: func() interface{} {
return json.NewDecoder(nil)
},
}
)
func createUserHandlerOptimized(w http.ResponseWriter, r *http.Request) {
// Obtener decoder del pool
decoder := jsonDecoderPool.Get().(*json.Decoder)
decoder.Reset(r.Body)
defer jsonDecoderPool.Put(decoder)
var user User
// Deserialización con decoder reutilizado
err := decoder.Decode(&user)
if err != nil {
http.Error(w, "Datos inválidos", http.StatusBadRequest)
return
}
// Validación temprana
if user.Name == "" || user.Email == "" {
http.Error(w, "Nombre y email son requeridos", http.StatusBadRequest)
return
}
user.ID = generateID()
// Obtener encoder del pool
encoder := jsonEncoderPool.Get().(*json.Encoder)
encoder.Reset(w)
defer jsonEncoderPool.Put(encoder)
w.Header().Set("Content-Type", "application/json")
// Serialización directa al ResponseWriter
err = encoder.Encode(user)
if err != nil {
http.Error(w, "Error interno", http.StatusInternalServerError)
}
}Errores comunes
- No validar antes de deserializar: Deserializar datos malformados o muy grandes sin límites puede causar panics o consumo excesivo de memoria. Usa
http.MaxBytesReaderpara limitar el tamaño. - Serializar estructuras con campos privados: Los campos que empiezan con minúscula no se serializan. Asegúrate de que los campos a exportar empiecen con mayúscula.
- Ignorar el tag omitempty: Sin
omitempty, los campos con valores cero se serializan, aumentando el tamaño de la respuesta innecesariamente. - Crear nuevos encoders/decoders por cada solicitud: Esto genera overhead de memoria. Usa pools para reutilizarlos.
- No manejar correctamente los content types: Asegúrate de que las respuestas tengan
Content-Type: application/jsony valida que las solicitudes lo tengan también.
Checklist de dominio
- ¿Usas
json.DecoderconDisallowUnknownFields()para rechazar campos no esperados? - ¿Limitas el tamaño del cuerpo de las solicitudes con
http.MaxBytesReader? - ¿Aplicas el tag
omitemptya campos opcionales para reducir el tamaño de las respuestas? - ¿Reutilizas encoders y decoders usando sync.Pool en endpoints de alto tráfico?
- ¿Validas los datos inmediatamente después de la deserialización, antes de cualquier procesamiento?
- ¿Serializas directamente al ResponseWriter usando
json.Encoderen lugar de crear buffers intermedios? - ¿Manejas correctamente los errores de serialización/deserialización con códigos HTTP apropiados?
Optimizar un endpoint existente para alto rendimiento
En este ejercicio, mejorarás un endpoint REST existente para hacerlo más eficiente en términos de serialización/deserialización JSON.
Contexto
Tienes un microservicio que gestiona productos con un endpoint POST /products que recibe datos JSON y devuelve el producto creado. El código actual tiene problemas de rendimiento.
Pasos a seguir
- Clona o crea un proyecto Go con el siguiente código base:
package main import ( "encoding/json" "net/http" ) type Product struct { ID int `json:"id"` Name string `json:"name"` Price float64 `json:"price"` Description string `json:"description"` InStock bool `json:"in_stock"` } var products []Product var nextID = 1 func createProductHandler(w http.ResponseWriter, r *http.Request) { var product Product // Leer todo el body primero body, err := ioutil.ReadAll(r.Body) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } // Deserializar err = json.Unmarshal(body, &product) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } // Asignar ID product.ID = nextID nextID++ products = append(products, product) // Serializar respuesta response, err := json.Marshal(product) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Content-Type", "application/json") w.Write(response) } func main() { http.HandleFunc("/products", createProductHandler) http.ListenAndServe(":8080", nil) } - Identifica al menos 3 problemas de rendimiento en el código actual relacionados con serialización/deserialización.
- Refactoriza el handler implementando:
- Límite de tamaño para el cuerpo de la solicitud (máximo 1MB)
- Reutilización de encoders/decoders usando sync.Pool
- Serialización directa al ResponseWriter
- Validación temprana de campos requeridos (nombre y precio)
- Uso apropiado de tags JSON (agrega omitempty donde corresponda)
- Crea un test de carga simple que envíe 1000 solicitudes concurrentes al endpoint y compara el rendimiento antes/después.
- Documenta las mejoras específicas que implementaste y su impacto esperado.
Pistas
- Piensa en cómo el uso de ioutil.ReadAll puede ser ineficiente para cuerpos grandes
- Considera qué campos del struct Product podrían ser opcionales y beneficiarse de omitempty
- Recuerda que json.Decoder tiene métodos como DisallowUnknownFields() para mejorar la seguridad
Evalua tu comprension
Completa el quiz interactivo de arriba para ganar XP.
Sigue con Go con Gorilla/Mux: CRUD, Validación y Microservicios
Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.
Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.