Kurze Anmerkung: Wenn Sie meinen vorherigen Beitrag zur JWT-Authentifizierung gelesen haben und einige Rendering-Probleme bemerkt haben, wurden diese jetzt behoben! Sehen Sie sich das Ganze unbedingt noch einmal an, denn diese Beispiele bauen auf diesem Tutorial auf. :)

Okay Leute, wir haben unsere Go-API am Laufen, wir haben die JWT-Authentifizierung hinzugefügt und wir haben sie sogar mit einer PostgreSQL-Datenbank verbunden. Aber wir sind noch nicht fertig! Diese Woche werden wir noch einen Schritt weiter gehen und unsere API intelligenter und entwicklerfreundlicher machen, indem wir benutzerdefinierte Middleware für die Protokollierung und hinzufügen. ]Fehlerbehandlung.

Was ist nochmal Middleware? ?

Middleware ist wie ein Türsteher in Ihrem Lieblingsclub – sie fängt Anfragen ab, bevor sie Ihre API-Endpunkte erreichen. Sie können über Middleware verfügen, die die Authentifizierung überprüft (wie wir es mit JWT getan haben), Informationen protokolliert oder Fehler behandelt, wenn etwas schief geht.

Heute werden wir Middleware erstellen, die:

• Protokolle: Jede eingehende Anfrage, damit wir wissen, wer an die Tür unserer API klopft.
• Behandelt Fehler: Elegant, damit Ihre Benutzer diese hässlichen 500 Fehler nicht sehen.

Lass uns eintauchen!

Schritt 1: Erstellen einer Protokollierungs-Middleware?

Die Protokollierung ist Ihr bester Freund, wenn es um das Debuggen und Verstehen der Vorgänge in Ihrer API geht. Wir werden eine Middleware erstellen, die jede eingehende Anfrage protokolliert – Methode, URL und benötigte Zeit.

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // Log the method and the requested URL
        log.Printf("Started %s %s", r.Method, r.URL.Path)

        // Call the next handler in the chain
        next.ServeHTTP(w, r)

        // Log how long it took
        log.Printf("Completed in %v", time.Since(start))
    })
}

Für diejenigen, die tiefer in die Protokollierungs-Middleware eintauchen möchten, empfehle ich einen Blick auf Matt Silverlocks fantastischen Leitfaden zum Schreiben von Protokollierungs-Middleware in Go. Er erklärt, wie wiederverwendbare Middleware für verschiedene Anwendungsfälle wie Authentifizierung, Nachverfolgung und natürlich Protokollierung strukturiert werden kann!

Schritt 2: Fehlerbehandlungs-Middleware?

Reden wir über Fehler. Fehler passieren, oder? Aber anstatt zuzulassen, dass sie einen Absturz verursachen oder eine vage Fehlermeldung senden, gehen wir lieber elegant damit um.

func errorHandlingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                // Log the error and send a user-friendly message
                log.Printf("Error occurred: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

Schritt 3: Middleware in Ihre API integrieren?

Da wir nun unsere Protokollierungs- und Fehlerbehandlungs-Middleware erstellt haben, verbinden wir sie mit unserer API. Wir wenden sie global an, sodass jede Anfrage protokolliert und Fehler abgefangen werden.

func main() {
    db = connectDB()
    defer db.Close()

    r := mux.NewRouter()

    // Apply middleware globally
    r.Use(loggingMiddleware)
    r.Use(errorHandlingMiddleware)

    r.HandleFunc("/login", login).Methods("POST")
    r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")
    r.Handle("/books", authenticate(http.HandlerFunc(createBook))).Methods("POST")

    fmt.Println("Server started on port :8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

Schritt 4: Ausprobieren?

Um sicherzustellen, dass alles funktioniert, starten Sie Ihre API:

go run main.go

Versuchen Sie nun, einen Ihrer Endpunkte (z. B. /books) zu erreichen, und überprüfen Sie Ihr Terminal. Sie sollten Protokolle wie:

Started GET /books
Completed in 1.2ms

Und wenn es einen Fehler gibt, sehen Sie:

Error occurred: some error details

Ihr Benutzer sieht jedoch nur eine saubere „500 Internal Server Error“-Meldung. ?

Warum ist das wichtig?

1. Logging hilft Ihnen, Fehler aufzuspüren und das Verhalten Ihrer API zu überwachen. Wenn etwas schief geht, wissen Sie genau, welcher Endpunkt getroffen wurde und wie lange die Anfrage gedauert hat.

2. Fehlerbehandlung verhindert, dass Ihre API abstürzt, wenn etwas Unerwartetes passiert. Stattdessen wird die Wiederherstellung ordnungsgemäß durchgeführt und eine saubere Fehlermeldung an den Client gesendet.

Was kommt als nächstes?

Nächstes Mal gehen wir einen Schritt weiter und dockerisieren unsere Go-API! Dadurch wird Ihre App portabel und kann auf jedem Computer oder Cloud-Dienst bereitgestellt werden. Machen Sie sich bereit für etwas Containermagie! ?