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: Auf Ihrem Weg Anstatt Fehler direkt zu behandeln, verwenden Handler gin.Context.Error(), um Fehlerinformationen an den Anforderungskontext anzuhängen.

<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: In Ihr Server-Setup, konfigurieren Sie 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 Fehlerbehandlung Ressourcen

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 fehlerhaft Handhabung](https://github.com/gin-gonic/gin/issues/264)
• [Chirp](https://github.com/fengleng/chirp)
• [ Gin-merry-Fehler handler](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!