Saltar al contenido

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

  1. Define el límite de 1024 bytes.

  2. Decodifica una lectura válida y codifícala de nuevo.

  3. Envía un campo adicional y captura el error.

  4. 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:

go
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.

Navegador, API y base de datos conectados por solicitudes, consultas y respuestas en sentidos opuestos.
CursaloMapa de práctica
Del navegador a los datos

El 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:

  1. Leer el cuerpo de la solicitud HTTP
  2. Deserializar el JSON a una estructura Go
  3. Validar y procesar los datos
  4. Serializar la respuesta a JSON
  5. 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.MaxBytesReader para 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/json y valida que las solicitudes lo tengan también.

Checklist de dominio

  1. ¿Usas json.Decoder con DisallowUnknownFields() para rechazar campos no esperados?
  2. ¿Limitas el tamaño del cuerpo de las solicitudes con http.MaxBytesReader?
  3. ¿Aplicas el tag omitempty a campos opcionales para reducir el tamaño de las respuestas?
  4. ¿Reutilizas encoders y decoders usando sync.Pool en endpoints de alto tráfico?
  5. ¿Validas los datos inmediatamente después de la deserialización, antes de cualquier procesamiento?
  6. ¿Serializas directamente al ResponseWriter usando json.Encoder en lugar de crear buffers intermedios?
  7. ¿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

  1. 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)
    }
  2. Identifica al menos 3 problemas de rendimiento en el código actual relacionados con serialización/deserialización.
  3. 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)
  4. Crea un test de carga simple que envíe 1000 solicitudes concurrentes al endpoint y compara el rendimiento antes/después.
  5. 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.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.