Patrones de Diseño en Go: Implementando Middleware y Decoradores

Introducción a los Patrones de Diseño en Go 🚀

El lenguaje de programación Go destaca por su simplicidad, su excelente rendimiento y su modelo de concurrencia nativo. A diferencia de lenguajes orientados a objetos clásicos como Java o C++, Go no cuenta con clases, herencia tradicional ni jerarquías complejas. En su lugar, fomenta la composición mediante estructuras (structs) y la abstracción mediante interfaces (interfaces).

Esta filosofía puede desconcertar al principio a los desarrolladores que provienen de paradigmas tradicionales, ya que los patrones de diseño clásicos de la "Gang of Four" (GoF) deben reinterpretarse. En este tutorial, profundizaremos en dos de los patrones más potentes y utilizados en el ecosistema de Go: el Patrón Decorador y el Patrón Middleware.

Comprendiendo el Patrón Decorador en Go 🛠️

El Patrón Decorador permite añadir responsabilidades o comportamientos dinámicos a un objeto existente sin alterar su estructura fundamental. En Go, esto se logra gracias a que las funciones son ciudadanos de primera clase y a la flexibilidad de las interfaces.

Imagina que estás construyendo un sistema de notificaciones. Tienes una interfaz base y una implementación concreta para enviar correos electrónicos. Más adelante, necesitas añadir la capacidad de registrar (loguear) cada envío o comprimir el mensaje antes de enviarlo, todo ello sin modificar el código original.

Definición de la Interfaz Base

Comenzaremos definiendo una interfaz clara que represente el comportamiento de envío de notificaciones:

package main

import "fmt"

// Notifier es la interfaz base para el envío de mensajes
type Notifier interface {
	Send(message string) error
}

Implementación Concreta

Ahora crearemos una estructura básica que cumpla con esta interfaz enviando correos electrónicos:

// EmailNotifier implementa Notifier para correo electrónico
type EmailNotifier struct{}

func (e *EmailNotifier) Send(message string) error {
	fmt.Printf("Enviando correo electrónico: %s\n", message)
	return nil
}

Creando el Decorador

Para decorar nuestro EmailNotifier, creamos otra estructura que también implemente la interfaz Notifier, pero que internamente envuelva a otra instancia de Notifier:

// LoggingNotifier es un decorador que añade logs a cualquier Notifier
type LoggingNotifier struct {
	wrapper Notifier
}

func NewLoggingNotifier(w Notifier) Notifier {
	return &LoggingNotifier{wrapper: w}
}

func (l *LoggingNotifier) Send(message string) error {
	fmt.Println("[LOG]: Iniciando proceso de envío...")
	err := l.wrapper.Send(message)
	if err != nil {
		fmt.Printf("[ERROR]: Falló el envío: %v\n", err)
		return err
	}
	fmt.Println("[LOG]: Envío completado con éxito.")
	return nil
}

Implementación del Patrón Middleware 🔥

El patrón middleware es una especialización del patrón decorador, altamente utilizado en el desarrollo web y de APIs en Go. Permite encadenar funciones que se ejecutan antes y después de la lógica principal de manejo de peticiones (handlers).

Los middlewares son ideales para tareas transversales como:

• Autenticación y autorización
• Logging de peticiones HTTP
• Recuperación de pánicos (recovery)
• Limitación de tasa (rate limiting)

Estructura Básica de un Middleware HTTP

En la librería estándar de Go (net/http), un handler se define mediante la interfaz http.Handler o funciones con la firma http.HandlerFunc. Un middleware es una función que recibe un http.Handler y devuelve otro http.Handler.

package main

import (
	"fmt"
	"net/http"
	"time"
)

// LoggingMiddleware registra el tiempo que toma procesar una petición HTTP
func LoggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		
		// Llamamos al siguiente handler en la cadena
		next.ServeHTTP(w, r)
		
		// Lógica ejecutada después de la petición
		duration := time.Since(start)
		fmt.Printf("[%s] %s - Duración: %v\n", r.Method, r.URL.Path, duration)
	})
}

Middleware de Autenticación Sencillo

Veamos un ejemplo práctico de un middleware que valida la presencia de un token de autorización en las cabeceras HTTP:

func AuthMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		token := r.Header.Get("Authorization")
		
		if token != "Bearer token-secreto-123" {
			http.Error(w, "No autorizado", http.StatusUnauthorized)
			return
		}
		
		next.ServeHTTP(w, r)
	})
}

Encadenando Múltiples Middlewares ⛓️

A medida que tu aplicación crece, necesitarás aplicar múltiples middlewares a tus rutas (por ejemplo: Logger, Recovery, Auth, CORS). Si los anidas manualmente, el código puede volverse ilegible:

// Código difícil de leer por anidación excesiva
handler := LoggingMiddleware(AuthMiddleware(CORS내는(myHandler)))

Para solucionar esto, podemos crear una función de utilidad llamada Chain que nos permita aplicar una lista de middlewares de forma ordenada y limpia.

// Middleware define la firma estándar para nuestras funciones middleware
type Middleware func(http.Handler) http.Handler

// Chain aplica una lista de middlewares a un http.Handler básico
func Chain(h http.Handler, middlewares ...Middleware) http.Handler {
	// Iteramos en orden inverso para preservar el orden de ejecución correcto
	for i := len(middlewares) - 1; i >= 0; i-- {
		h = middlewares[i](h)
	}
	return h
}

Ejemplo de Uso Completo con Servidor Web

A continuación, un ejemplo completo de cómo integrar todo lo aprendido en un servidor web básico utilizando la librería estándar de Go:

package main

import (
	"fmt"
	"net/http"
	"time"
)

// Tipos y funciones previas...

func homeHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "¡Bienvenido a la API protegida!")
}

func main()
{
	// Definimos el handler final
	finalHandler := http.HandlerFunc(homeHandler)
	
	// Definimos nuestra cadena de middlewares
	// Se ejecutan en orden: Logger primero, luego Auth
	protectedRoutes := Chain(finalHandler, LoggingMiddleware, AuthMiddleware)
	
	// Registramos la ruta en el multiplexor
	http.Handle("/api/recurso", protectedRoutes)
	
	fmt.Println("Servidor escuchando en el puerto :8080...")
	http.ListenAndServe(":8080", nil)
}

Buenas Prácticas y Consejos Avanzados 💡

Para asegurar que tu código se mantenga mantenible y eficiente al utilizar decoradores y middlewares, ten en cuenta las siguientes recomendaciones:

Pasando Datos entre Middleware y Handler usando Context

Es muy común que un middleware de autenticación extraiga el ID del usuario y necesite pasarlo al handler final. Esto se hace mediante el paquete context de Go:

import "context"

type contextKey string
const userKey contextKey = "userID"

func ContextAuthMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		userID := "user_98765"
		
		// Adjuntamos el usuario al contexto de la petición
		ctx := context.WithValue(r.Context(), userKey, userID)
		
		// Llamamos al siguiente handler pasando el nuevo contexto
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

Preguntas Frecuentes (FAQ)

Intermedio Go