Comment Go Middleware peut-il gérer efficacement les erreurs renvoyées par les gestionnaires de requêtes ?

Middleware avec gestionnaires de requêtes retournant des erreurs

Le middleware dans Go isole les problèmes et augmente les gestionnaires de requêtes avec des fonctionnalités supplémentaires. Le modèle middleware traditionnel implique l’exécution de gestionnaires avant et après le gestionnaire de requêtes principal. Cependant, il ne prend pas en charge la gestion des erreurs, ce qui peut être fastidieux.

Gestionnaires de requêtes de gestion des erreurs

Pour résoudre ce problème, nous pouvons utiliser des gestionnaires de requêtes de gestion des erreurs définis comme suit :

type errorHandler func(http.ResponseWriter, *http.Request) error

Ces gestionnaires nous permettent de renvoyer directement les erreurs, ce qui rend la gestion des erreurs plus intuitive.

Combiner le middleware avec Gestionnaires de gestion des erreurs

Pour combiner le modèle middleware avec des gestionnaires de gestion des erreurs, nous introduisons un middleware supplémentaire qui sert d'étape finale dans la chaîne :

func errorHandler(h MyHandlerFunc) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        err := h(w, r)
        if err != nil {
            // Handle error here
        }
    })
}

Ce middleware enveloppe le spécial type de fonction de gestionnaire MyHandlerFunc, qui renvoie des erreurs.

Utilisation

Pour utiliser ce modèle, enveloppez votre gestionnaire de gestion des erreurs avec le middleware errorHandler et ajoutez-le à la fin de la chaîne middleware :

moreMiddleware(myMiddleware(errorHandler(myhandleFuncReturningError)))

Exemple

Considérez l'exemple suivant :

func loggingHandler(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Before executing the handler.
        start := time.Now()
        log.Printf("Started %s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
        // After executing the handler.
        log.Printf("Completed %s in %v", r.URL.Path, time.Since(start))
    })
}

func errorHandle(w http.ResponseWriter, r *http.Request) error {
    w.Write([]byte(`Hello World from errorHandle!`))
    return nil
}

func main() {
    http.Handle("/", errorHandler(errorHandle))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Dans Dans cet exemple, loggingHandler est un middleware traditionnel, tandis que errorHandle est un gestionnaire de requêtes de gestion des erreurs. Le middleware errorHandler encapsule errorHandle et garantit que les erreurs sont traitées de manière appropriée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!