Middleware comme décorateur

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 97 sur 107.

Le middleware est l’une des applications les plus pratiques du pattern Decorator en Go. Dans le développement web, les fonctions de middleware enveloppent les gestionnaires HTTP afin d’ajouter des préoccupations transversales telles que la journalisation, l’authentification ou le chronométrage, sans modifier le gestionnaire d’origine.

L’idée clé est que middleware prend un handler et renvoie un nouveau handler avec un comportement ajouté. Cela suit exactement le patron Decorator : même interface en entrée et en sortie, avec des fonctionnalités améliorées :

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)
    }
}

Chaque middleware encapsule le gestionnaire suivant dans la chaîne, en ajoutant son comportement avant ou après l’appel du gestionnaire encapsulé. Vous pouvez empiler plusieurs middlewares en les composant :

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

handler := LoggingMiddleware(AuthMiddleware(MainHandler))
fmt.Println(handler("GET /users"))
// [LOG] [AUTH] Réponse à : GET /users

L’ordre d’encapsulation détermine l’ordre d’exécution : le middleware le plus externe s’exécute en premier. Ce modèle est largement utilisé dans les frameworks web Go pour les pipelines de traitement des requêtes, ce qui facilite l’ajout ou la suppression de fonctionnalités sans toucher à la logique du gestionnaire principal.

Défi

Facile

Construisons un pipeline de traitement des requêtes en utilisant le modèle Middleware comme décorateur ! Vous allez créer un système dans lequel des fonctions middleware enveloppent des gestionnaires afin d’ajouter des fonctionnalités comme le chronométrage, la validation et le formatage, le tout sans modifier la logique du gestionnaire principal.

Vous organiserez votre code sur trois fichiers :

handler.go : définissez votre type de gestionnaire ainsi que le gestionnaire de base qui traite les requêtes.
Créez un type Handler sous la forme d’une fonction qui prend une chaîne de requête et renvoie une chaîne de réponse :
```
type Handler func(request string) string
```
Implémentez une fonction BaseHandler qui renvoie Processed: [request] pour toute requête reçue.
middleware.go : créez vos fonctions middleware qui enveloppent les gestionnaires avec un comportement supplémentaire.
Créez trois fonctions middleware, chacune prenant un Handler et renvoyant un nouveau Handler :
- TimingMiddleware : enveloppe la réponse avec des informations de chronométrage et renvoie [TIMING] [response]
- ValidationMiddleware : ajoute un préfixe de validation et renvoie [VALID] [response]
- UppercaseMiddleware : convertit toute la réponse en majuscules
Chaque middleware doit appeler le gestionnaire enveloppé et enrichir son résultat.
main.go : construisez un pipeline de traitement en composant les middleware.
Lisez le nombre de couches middleware à appliquer. Ensuite, pour chaque couche, lisez le type de middleware (timing, validation ou uppercase) et enveloppez votre gestionnaire actuel avec ce middleware. Appliquez-les dans l’ordre où ils sont lus : le premier middleware lu devient l’enveloppe la plus externe.

Après avoir construit le pipeline, lisez la chaîne de requête, traitez-la via votre gestionnaire composé et affichez le résultat.

Les entrées suivantes seront fournies :

Ligne 1 : nombre de couches middleware
Lignes suivantes : un type de middleware par ligne (timing, validation ou uppercase)
Dernière ligne : la requête à traiter

Par exemple, avec :

2
timing
validation
GET /users

Votre sortie doit être :

[TIMING] [VALID] Processed: GET /users

Et avec :

3
uppercase
timing
validation
POST /data

Votre sortie doit être :

[TIMING] [VALID] PROCESSED: POST /DATA

Et avec :

1
uppercase
hello world

Votre sortie doit être :

PROCESSED: HELLO WORLD

Et avec :

0
simple request

Votre sortie doit être :

Processed: simple request

Remarquez comment l’ordre d’enveloppement des middleware affecte la sortie : le premier middleware appliqué (le plus externe) s’exécute en premier et reçoit le résultat final de tous les middleware internes. Dans le deuxième exemple, le middleware en majuscules s’exécute en dernier (le plus interne), il convertit donc la réponse de base en majuscules avant que le chronométrage et la validation n’ajoutent leurs préfixes !

Essayez vous-même

package main

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

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

	// Lire le nombre de couches de middleware
	nLine, _ := reader.ReadString('\n')
	n, _ := strconv.Atoi(strings.TrimSpace(nLine))

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

	// Lire la requête
	request, _ := reader.ReadString('\n')
	request = strings.TrimSpace(request)

	// TODO: Commencer avec le BaseHandler

	// TODO: Construire le pipeline en enveloppant le handler avec le middleware
	// Appliquer le middleware dans l'ordre - le premier middleware lu devient le wrapper le plus externe
	// Hint: Parcourir middlewareTypes dans l'ordre REVERSE pour y parvenir
	// Le dernier middleware appliqué sera le plus externe (s'exécute en premier)

	// TODO: Traiter la requête via le handler composé et afficher le résultat
	fmt.Println("TODO: implement pipeline")
}