Comment gérer les erreurs dans le middleware Gin : une approche centralisée ?

Comment gérer les erreurs dans un middleware Gin

Introduction

Lors de la création d'applications Web à l'aide du framework Gin, il est courant de gérer les erreurs dans chaque itinéraire gestionnaire. Cela peut conduire à une approche lourde et redondante, en particulier lors de la gestion de plusieurs erreurs HTTP. Gin fournit une solution plus élégante grâce à l'utilisation d'un middleware de gestion des erreurs.

Gestion des erreurs basée sur un middleware

Au lieu de gérer explicitement les erreurs dans chaque itinéraire, nous pouvons créer un middleware qui intercepte les erreurs et fournit une manière centralisée de les gérer. La fonction middleware doit inclure les étapes suivantes :

<code class="go">func ErrorHandler(c *gin.Context) {
    // Proceed to the next handler in the chain
    c.Next()

    // Iterate over the errors that occurred during the request handling
    for _, err := range c.Errors {
        // Log the error or perform any other necessary operations
        logger.Error(&quot;whoops&quot;, ...)

        // Send an HTTP response with the appropriate status (or -1 to omit overwriting)
        c.JSON(-1, /* error payload */)
    }
}</code>

Le middleware est ajouté au routeur à l'aide de la méthode Use :

<code class="go">router := gin.New()
router.Use(middleware.ErrorHandler)</code>

Au sein des gestionnaires de route, au lieu de gérer les erreurs manuellement, nous pouvons abandonner la requête avec le statut HTTP approprié :

<code class="go">func (h *Handler) List(c *gin.Context) {
    movies, err := h.service.ListService()

    if err != nil {
        c.AbortWithError(http.StatusInternalServerError, err)
        return
    }

    c.JSON(http.StatusOK, movies)
}</code>

Gestion des erreurs personnalisées

Dans le middleware, nous pouvons inspecter l'erreur d'origine en accédant au champ Err du type gin.Error :

<code class="go">for _, err := range c.Errors {
    switch err.Err {
        case ErrNotFound:
            c.JSON(-1, gin.H{&quot;error&quot;: ErrNotFound.Error()})
    }
    // etc...
}</code>

Accumulation et journalisation des erreurs

L'avantage d'utiliser un middleware est qu'il nous permet d'accumuler plusieurs erreurs lors du traitement de la requête. De plus, nous pouvons ajouter des informations contextuelles aux erreurs, telles que l'ID utilisateur, l'URL de la demande, etc. Ces informations peuvent être utilisées pour une journalisation et un rapport d'erreurs plus détaillés.

Conclusion

En utilisant la gestion des erreurs basée sur un middleware dans Gin, nous pouvons centraliser et simplifier la gestion des erreurs, améliorer la lisibilité du code et améliorer capacités de journalisation des erreurs. Cette approche est plus idiomatique et offre la flexibilité nécessaire pour gérer les erreurs personnalisées et accumuler plusieurs erreurs pendant le cycle de vie de la demande.

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!