Wie kann man mit Gin eine bessere Fehlerbehandlung implementieren?

Bessere Fehlerbehandlung mit Gin

In diesem Artikel untersuchen wir, wie wir anhand eines Ansatzes eine bessere Fehlerbehandlung mit Gin implementieren können im Go-Framework eingesetzt. Unser Ziel ist es, die Fehlerbehandlung zu zentralisieren und so die Verwaltung und Reduzierung doppelten Codes zu vereinfachen.

Benutzerdefinierter Fehlertyp

Ähnlich dem benutzerdefinierten appError Geben Sie das Go-Framework ein. Definieren wir einen benutzerdefinierten Fehlertyp, um Fehlercodes und -meldungen strukturiert zu verarbeiten:

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

Middleware für die Fehlerberichterstattung

Zur Zentralisierung Fehlerbehandlung können wir eine Middleware erstellen, die Fehlerantworten verarbeitet:

<code class="go">func JSONAppErrorReporter() gin.HandlerFunc {
    return jsonAppErrorReporterT(gin.ErrorTypeAny)
}

func jsonAppErrorReporterT(errType gin.ErrorType) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()
        detectedErrors := c.Errors.ByType(errType)

        // Process errors and convert them to our custom error type
        if len(detectedErrors) > 0 {
            err := detectedErrors[0].Err
            parsedError := parseAPperror(err) 

            // Put error into response
            c.IndentedJSON(parsedError.Code, parsedError)
            c.Abort()
        }
    }
}</code>

In dieser Middleware werden erkannte Fehler in den Typ appError geparst und als JSON-Antworten zurückgegeben.

Fehlerberichterstattung im Handler

Um Fehler innerhalb von Handlerfunktionen zu melden, verwenden wir gin.Context.Error():

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

Vorteile

Dieser Ansatz bietet mehrere Vorteile:

• Zentralisierte Fehlerbehandlung vereinfacht das Fehlermanagement.
• Benutzerdefinierte Fehlertypen ermöglichen eine strukturierte und informative Fehlerberichterstattung.
• Middleware fängt Fehler ab und verhindert, dass sie sich im gesamten Anforderungszyklus verbreiten.

Zusätzliche Ressourcen

Ausführlichere Informationen und alternative Lösungen finden Sie unter zu den folgenden Ressourcen:

• [Gin-Problem: Handhabungsfehler](https://github.com/gin-gonic/gin/issues/214)
• [Gin-Problem: Statuscodes in der Fehlerbehandlung](https://github.com/gin-gonic/gin/issues/401)
• [Gin-Merry: Error Handler](https://github.com/gin- contrib/gin-merry)
• [Gin-Frsh-Showerrors](https://github.com/Double0h/gin-frsh-showerrors)

Das obige ist der detaillierte Inhalt vonWie kann man mit Gin eine bessere Fehlerbehandlung implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!