Middleware como Decorator

Parte de la sección Programación Orientada a Objetos del Journey de GO de Coddy. Lección 97 de 107.

Middleware es una de las aplicaciones más prácticas del patrón Decorator en Go. En el desarrollo web, las funciones de middleware envuelven controladores HTTP para añadir aspectos transversales como el registro, la autenticación o la medición del tiempo sin modificar el controlador original.

La idea clave es que el middleware toma un controlador y devuelve un nuevo controlador con un comportamiento añadido. Esto sigue exactamente el patrón Decorator: la misma interfaz de entrada y salida, con una funcionalidad mejorada:

type Handler func(request string) string

func LoggingMiddleware(next Handler) Handler {
    return func(request string) string {
        result := next(request)
        return "[LOG] " + result
    }
}

func AuthMiddleware(next Handler) Handler {
    return func(request string) string {
        return "[AUTH] " + next(request)
    }
}

Cada middleware envuelve al siguiente controlador de la cadena y añade su comportamiento antes o después de llamar al controlador envuelto. Puedes apilar varios middleware componiéndolos:

func MainHandler(request string) string {
    return "Response to: " + request
}

handler := LoggingMiddleware(AuthMiddleware(MainHandler))
fmt.Println(handler("GET /users"))
// [LOG] [AUTH] Respuesta a: GET /users

El orden de envoltura determina el orden de ejecución: el middleware más externo se ejecuta primero. Este patrón se utiliza ampliamente en los frameworks web de Go para las canalizaciones de procesamiento de solicitudes, lo que facilita añadir o eliminar funcionalidades sin tocar la lógica principal del controlador.

Desafío

Fácil

¡Construyamos una canalización de procesamiento de solicitudes usando el patrón Middleware como Decorador! Crearás un sistema en el que las funciones de middleware envuelven controladores para añadir funcionalidades como medición del tiempo, validación y formato, todo ello sin modificar la lógica principal del controlador.

Organizarás tu código en tres archivos:

handler.go: Define el tipo de controlador y el controlador base que procesa las solicitudes.
Crea un tipo Handler como una función que recibe una cadena de solicitud y devuelve una cadena de respuesta:
```
type Handler func(request string) string
```
Implementa una función BaseHandler que devuelva Processed: [request] para cualquier solicitud que reciba.
middleware.go: Crea tus funciones de middleware que envuelvan controladores con comportamiento adicional.
Construye tres funciones de middleware, cada una de las cuales reciba un Handler y devuelva un nuevo Handler:
- TimingMiddleware: envuelve la respuesta con información de tiempo y devuelve [TIMING] [response]
- ValidationMiddleware: añade un prefijo de validación y devuelve [VALID] [response]
- UppercaseMiddleware: convierte toda la respuesta a mayúsculas
Cada middleware debe llamar al controlador envuelto y mejorar su resultado.
main.go: Construye una canalización de procesamiento componiendo middleware.
Lee el número de capas de middleware que se aplicarán. Después, para cada capa, lee el tipo de middleware (timing, validation o uppercase) y envuelve el controlador actual con ese middleware. Aplícalos en el orden en que se leen: el primer middleware leído se convierte en la envoltura más externa.

Después de construir la canalización, lee la cadena de solicitud, procésala mediante tu controlador compuesto e imprime el resultado.

Se proporcionarán las siguientes entradas:

Línea 1: Número de capas de middleware
Líneas siguientes: Un tipo de middleware por línea (timing, validation o uppercase)
Última línea: La solicitud que se procesará

Por ejemplo, dada la siguiente entrada:

2
timing
validation
GET /users

Tu salida debe ser:

[TIMING] [VALID] Processed: GET /users

Y dada la siguiente entrada:

3
uppercase
timing
validation
POST /data

Tu salida debe ser:

[TIMING] [VALID] PROCESSED: POST /DATA

Y dada la siguiente entrada:

1
uppercase
hello world

Tu salida debe ser:

PROCESSED: HELLO WORLD

Y dada la siguiente entrada:

0
simple request

Tu salida debe ser:

Processed: simple request

Observa cómo el orden de envoltura del middleware afecta a la salida: el primer middleware aplicado (el más externo) se ejecuta primero y recibe el resultado final de todos los middleware internos. El middleware de mayúsculas del segundo ejemplo se ejecuta al final (como el más interno), por lo que convierte a mayúsculas la respuesta base antes de que la medición del tiempo y la validación añadan sus prefijos.

Pruébalo tú mismo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Leer el número de capas de middleware
	nLine, _ := reader.ReadString('\n')
	n, _ := strconv.Atoi(strings.TrimSpace(nLine))

	// Leer los tipos de middleware
	middlewareTypes := make([]string, n)
	for i := 0; i < n; i++ {
		line, _ := reader.ReadString('\n')
		middlewareTypes[i] = strings.TrimSpace(line)
	}

	// Leer la solicitud
	request, _ := reader.ReadString('\n')
	request = strings.TrimSpace(request)

	// TODO: Empieza con el BaseHandler

	// TODO: Construye el pipeline envolviendo el handler con middleware
	// Aplica el middleware en orden - el primer middleware leído se convierte en el wrapper más externo
	// Pista: Recorre middlewareTypes en orden INVERSO para lograr esto
	// El último middleware aplicado será el más externo (se ejecuta primero)

	// TODO: Procesa la solicitud a través del handler compuesto e imprime el resultado
	fmt.Println("TODO: implement pipeline")
}