Fundamentos de Frameworks Web

10 ejemplos para empezar con Frameworks Web: 7 básicos y 3 intermedios.

Prerrequisitos

• Instala Go 1.26.x o posterior desde go.dev/dl.
• Crea un módulo: mkdir webdemo && cd webdemo && go mod init example.com/webdemo.
• Añade dependencias según sea necesario: go get github.com/go-chi/chi/v5 y go get github.com/gin-gonic/gin.
• Ejecuta los ejemplos con go run . después de guardarlos como main.go (o divide los archivos en el mismo módulo).

Ejemplos Básicos

1. Manejador hello de la biblioteca estándar

La base sobre la que se construyen todos los frameworks: http.HandlerFunc.

package main
 
import (
    "fmt"
    "net/http"
)
 
func main() {
    http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "hello, stdlib")
    })
    http.ListenAndServe(":8080", nil)
}

• http.HandleFunc se registra en DefaultServeMux.
• Los manejadores reciben ResponseWriter y Request, el contrato universal.
• Prefiere http.Server explícito en producción; esto muestra la forma más pequeña.

Relacionado: net/http: La Pila HTTP Incluida de Go - modelo HTTP de la biblioteca estándar

2. Enrutador chi con una sola ruta GET

chi se mantiene compatible con http.Handler mientras añade parámetros de ruta.

package main
 
import (
    "net/http"
 
    "github.com/go-chi/chi/v5"
)
 
func main() {
    r := chi.NewRouter()
    r.Get("/ping", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("pong"))
    })
    http.ListenAndServe(":8080", r)
}

• chi.NewRouter() devuelve un http.Handler que pasas a ListenAndServe.
• Los métodos de ruta (Get, Post) establecen restricciones de verbo HTTP.
• Sin contexto específico del framework; los manejadores se parecen al código de la biblioteca estándar.

Relacionado: chi: Enrutamiento y Middleware Ligeros - grupos de rutas y middleware

3. Parámetro de URL de chi

Los segmentos nombrados aparecen en el patrón y se leen de la solicitud.

r.Get("/users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := chi.URLParam(r, "id")
    w.Write([]byte("user " + id))
})

• {id} enlaza un segmento de ruta; usa {id:*} para rutas de resto codiciosas cuando sea necesario.
• chi.URLParam devuelve una cadena vacía si la clave falta; valida antes de usar.
• Los nombres de los parámetros son por ruta; documéntalos en OpenAPI o tablas de rutas.

Relacionado: Frameworks HTTP de Go: Enrutadores vs Frameworks Completos - modelo de enrutador vs framework

4. Cadena de middleware de chi

Use envuelve todas las rutas registradas después de él en ese enrutador.

import "github.com/go-chi/chi/v5/middleware"
 
r.Use(middleware.RequestID)
r.Use(middleware.Logger)
r.Get("/time", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("ok"))
})

• El orden del middleware importa: el primer Use es el más externo al entrar.
• chi incluye middleware comunes: ID de solicitud, recuperador, tiempo de espera, compresión.
• Escribe middleware personalizado como func(http.Handler) http.Handler.

Relacionado: Patrones de Middleware y Decorador - modelo de envoltura de manejador

5. Grupo de rutas de chi con prefijo

Monta rutas relacionadas bajo una ruta y middleware compartidos.

r.Route("/api/v1", func(r chi.Router) {
    r.Get("/health", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(`{"status":"ok"}`))
    })
    r.Get("/version", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte(`{"version":"1"}`))
    })
})

• Route crea un subenrutador que hereda el middleware del padre a menos que te ramifiques antes.
• Los prefijos se apilan: /api/v1/health coincide con el manejador de salud.
• Los grupos mantienen las etiquetas de OpenAPI y los límites de autenticación alineados con la estructura de URL.

6. Motor predeterminado de Gin y ruta JSON

Gin usa *gin.Context en lugar de http.ResponseWriter crudo.

package main
 
import "github.com/gin-gonic/gin"
 
func main() {
    g := gin.Default() // Middleware Logger + Recovery
    g.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "pong"})
    })
    g.Run(":8080")
}

• gin.Default() habilita el middleware de registro de depuración; usa gin.New() más middleware explícito en la optimización de producción.
• c.JSON establece Content-Type y codifica el mapa.
• gin.H es un atajo para map[string]any para cargas útiles pequeñas.

Relacionado: Gin: APIs JSON Rápidas y Vinculación - vinculación y validación

7. Parámetro de ruta de Gin

El contexto del framework expone los parámetros con Param.

g.GET("/users/:id", func(c *gin.Context) {
    id := c.Param("id")
    c.JSON(200, gin.H{"id": id})
})

• Gin usa la sintaxis :id; chi usa {id}; la migración requiere reescrituras de ruta o adaptadores.
• Los parámetros son siempre cadenas; analiza enteros con strconv o ayudantes de vinculación.
• Las rutas comodín usan *path con semántica ligeramente diferente a {path:*} de chi.

Ejemplos Intermedios

8. Vinculación JSON de Gin en POST

Vincula cuerpos de solicitud en estructuras con etiquetas.

type createUser struct {
    Email string `json:"email" binding:"required,email"`
}
 
g.POST("/users", func(c *gin.Context) {
    var in createUser
    if err := c.ShouldBindJSON(&in); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }
    c.JSON(201, gin.H{"email": in.Email})
})

• ShouldBindJSON evita escribir respuestas dobles en caso de error (preferir sobre BindJSON en manejadores).
• Las etiquetas de validación necesitan github.com/go-playground/validator integrado a través de Gin.
• Mantén las estructuras DTO en un paquete api o transport separado de los modelos de dominio.

9. Subenrutador de chi montado en una ruta

Monta enrutadores independientes para servicios modulares.

admin := chi.NewRouter()
admin.Get("/stats", func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("stats"))
})
 
r.Mount("/admin", admin)

• Mount elimina el prefijo antes de que el subenrutador coincida.
• Cada enrutador montado puede llevar su propia pila de middleware.
• Útil para dividir admin, API pública y webhooks en un solo binario.

10. Manejador de negocio compartido detrás de dos enrutadores

Escribe la lógica una vez como http.HandlerFunc, regístrala en chi; Gin necesita un adaptador delgado.

func showHealth(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.Write([]byte(`{"ok":true}`))
}
 
// chi
r.Get("/health", showHealth)
 
// adaptador gin
g.GET("/health", func(c *gin.Context) {
    showHealth(c.Writer, c.Request)
})

• Los manejadores portátiles facilitan la migración entre enrutadores.
• c.Writer y c.Request de Gin son los tipos subyacentes de la biblioteca estándar.
• Para aplicaciones más grandes, monta un chi.Router completo bajo Gin o viceversa en lugar de adaptadores por ruta.

Relacionado: Migración entre Enrutadores sin Reescribir Manejadores - patrones de adaptador

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