Wie implementiert man eine zentralisierte Fehlerbehandlung im Gin Framework?

Bessere Fehlerbehandlung im Gin-Framework

Verbesserte Fehlerbehandlung mit benutzerdefiniertem HTTP-Router und Fehlertyp

In einer aktuellen Diskussion wurde eine Technik vorgeschlagen Verbessern Sie die Fehlerbehandlung in Golang-HTTP-Anwendungen mithilfe benutzerdefinierter Router und Fehlertypen. Das Ziel bestand darin, die Fehlerberichterstattung und -behandlung zu zentralisieren und die Notwendigkeit direkter Aufrufe von c.JSON(500, err) innerhalb bestimmter Handler zu eliminieren.

Implementierung einer zentralisierten Fehlerbehandlung in Gin

Im Gin Framework kann dies durch die Verwendung einer Middleware und der Methode gin.Context.Error() erreicht werden. So funktioniert es:

1. Fehler-Middleware erstellen: Definieren Sie eine benutzerdefinierte Middleware, die die gin.HandlerFunc-Schnittstelle implementiert. Diese Middleware dient als zentraler Punkt für die Fehlerbehandlung.

<code class="go">type AppError struct {
    Code     int    `json:"code"`
    Message  string `json:"message"`
}

func JSONAppErrorReporter(errType gin.ErrorType) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()

        errors := c.Errors.ByType(errType)

        if len(errors) > 0 {
            err := errors[0].Err
            var parsedError *AppError

            switch err.(type) {
            case *AppError:
                parsedError = err.(*AppError)
            default:
                parsedError = &AppError{
                    code: http.StatusInternalServerError,
                    message: "Internal Server Error",
                }
            }

            c.IndentedJSON(parsedError.Code, parsedError)
            c.Abort()
        }
    }
}</code>

2. Verwenden Sie die Middleware: Registrieren Sie die Fehlerbehandlungs-Middleware in Ihrer Router-Konfiguration.

<code class="go">router.Use(JSONAppErrorReporter(gin.ErrorTypeAny))</code>

3. Fehler von Handlern melden: Verwenden Sie in Ihren Pfad-Handlern gin.Context.Error(), um Fehlerinformationen an den Anforderungskontext anzuhängen, anstatt Fehler direkt zu behandeln .

<code class="go">func fetchSingleHostGroup(c *gin.Context) {
    hostgroupID := c.Param("id")

    hostGroupRes, err := getHostGroupResource(hostgroupID)

    if err != nil {
        c.Error(err)
        return
    }

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

4. Server konfigurieren: Konfigurieren Sie in Ihrem Server-Setup den Router und führen Sie den Server aus.

<code class="go">router := gin.Default()
router.GET("/hostgroups/:id", fetchSingleHostGroup)
router.Run(":3000")</code>

Zusätzliche Ressourcen zur Fehlerbehandlung

Weitere Informationen zur Fehlerbehandlung in Gin finden Sie in diesen Ressourcen:

• [Gin-Gonic-Problem: Behandlung von Fehlern](https://github.com /gin-gonic/gin/issues/403)
• [Gin-gonic-Problem: Statuscodes in der Fehlerbehandlung](https://github.com/gin-gonic/gin/issues/264)
• [Chirp](https://github.com/fengleng/chirp)
• [Gin-merry-Fehlerbehandler](https://github.com/savsgio/gin-merry)
• [Gin-frsh-showerrors](https://github.com/emicklei/go-frsh/tree/master/showerrors)

Das obige ist der detaillierte Inhalt vonWie implementiert man eine zentralisierte Fehlerbehandlung im Gin Framework?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!