Middleware in Go schreiben

Hast du dich schon mal gefragt, wie du die Funktionalität deiner Go-Anwendungen verbessern und erweitern kannst? Hier kommt die Middleware ins Spiel.

Eine Middleware ist eine leistungsstarke Technik, die du als Zwischenschicht zwischen dem HTTP-Server und den Endpunkten deiner Anwendung einfügst. So kannst du Aufgaben wie Logging, Authentifizierung, Caching und vieles mehr verwalten. 

In diesem Artikel werden wir gemeinsam die Grundlagen der Go Middleware erforschen und praktische Anwendungsfälle kennenlernen. Egal, ob du dich noch in den Anfängen deiner Go-Reise befindest oder bereits vertraut mit der Sprache bist, hier lernst du die Welt der Go Middleware besser kennen.

Du startest gerade erst mit der Programmiersprache Go? Dann empfehle ich dir mit dem Artikel Erste Schritte mit Go anzufangen.

• Was ist eine Middleware
• Grundlagen der Go Middleware
• Implementierung der Go Middleware
• Fazit

Was ist eine Middleware

Die Middleware ist ein wichtiges Konzept in der Softwareentwicklung. Sie hilft dabei, komplexe Anwendungen zu vereinfachen und stabile Software zu entwickeln.

Messaging-Systeme, Web-Services oder Datenbanktreiber sind einige Beispiele für verschiedene Arten von Middlewares.

Webentwicklung

In der Webentwicklung kannst du die Middleware als Zwischenschicht zwischen dem HTTP-Server und den Endpunkten deiner Anwendung nutzen:

Die Middleware nimmt den HTTP-Request entgegen, führt Anpassungen oder Verarbeitungen durch und leitet den HTTP-Response weiter.

Ihre Aufgabe ist es, bestimmte Funktionen oder Dienste bereitzustellen, die von vielen Teilen deiner Anwendung benötigt wird.

Grundlagen der Go Middleware

Go bietet eine gute Unterstützung für Middleware. Du kannst damit spezielle Funktionen implementieren wie etwa:

• das Routing von Anfragen
• die Überprüfung von Benutzer:innen
• das Protokollieren von Ereignissen
• die Behandlung von Fehlern

Vorteile

Mit der Verwendung von Middleware, kannst du deinen Code übersichtlich und wiederverwendbar gestalten.

Du kannst verschiedene Middleware-Teile unabhängig voneinander entwickeln und sie dann in deiner Anwendungen kombinieren.

Das macht den Code sauber und erleichtert es dir, deine Anwendung zu warten und zu erweitern.

Grundlegende Komponenten

Grundlegende Komponenten der Go Middleware sind:

• Eine Funktion die den HTTP-Request und den HTTP-Response-Writer entgegennimmt. 
• Diese Funktion kann vor, nach oder um den Aufruf des nächsten Handlers ausgeführt werden. 
• Die Kombination mehrerer Middleware-Funktionen bildet eine Middleware-Kette, in der der Request durchläuft.

Implementierung der Go Middleware

In Go wird die Middleware typischerweise als Funktion implementiert. Diese Funktion empfängt einen HTTP-Handler und gibt eine modifizierte Version davon zurück.

type Middleware func(http.Handler) http.Handler

Ähnlich wie bei einer Zwiebel, wird die Anfrage von außen durch alle Schichten bis nach innen gesendet. Dort dreht sich der Datenstrom um und die Antwort wird von innen nach außen zurückgegeben.

Beispiel

Dieses Beispiel zeigt dir eine einfache Middleware. Sie ermöglicht es dir, Anfragen in deiner Go-Anwendung zu protokollieren.

• Es wird eine Anfrage vom Client an den Go HTTP Server gesendet.
• Der Server gibt die Anfrage an die Middleware weiter, in der die aktuelle Zeit aufgenommen wird.
• Die Middleware ruft die Handler Funktion hello auf.
• Die Handler Funktion hello schreibt die Zeichenkette „Hello World!“ an den http.ResponseWriter.
• Der Datenstrom dreht sich um, die Antwort wird an die Middleware gesendet.
• Die Middleware protokolliert die Zeitdauer der Anfrage inklusive der Methode und der URL.
• Über den HTTP Server wird die Antwort an den Client ausgespielt.
• Im Client kommt die Antwort an und die Zeichenkette „Hello World!“ wird angezeigt.

Der zugehörige Code sieht folgendermaßen aus:

logging.go

In der Datei logging.go siehst du die Logging Middleware:

• Die Logging Funktion erzeugt und gibt eine Middleware zurück. Sie erwartet den nächsten Handler als Parameter und gibt einen neuen Handler zurück.
• Die aktuelle Zeit wird in der start Variablen abgelegt.
• Mit next.ServeHTTP(w, r) wird der nachfolgende Handler aufgerufen. Nun wird gewartet, bis der Datenstrom zurückkommt.
• Sobald der nachfolgende Handler den Datenstrom zurückschickt, wird die Zeitdauer berechnet. Hierfür wird das time Package verwendet und der Zeitpunkt übergeben, der unter der Variablen start abgelegt wurde.
• Mit dem log Package wird die Methode, Url und Zeitdauer der Anfrage ausgegeben.

main.go

In der Datei main.go siehst du die Hauptanwendung und den hello Handler:

hello Handler:

• Der hello Handler schreibt die Zeichenkette „Hello World!“ an den http.ResponseWriter.

main Funktion:

• In der main Funktion wird der Server gestartet und die Logging Middleware aufgerufen.
• Zunächst wird über das http Standard Package ein neuer Server-Multiplexer erstellt und der Variablen mux übergeben. Der Server-Multiplexer dient der Verwaltung der Routen.
• Beim Aufruf der Route „/hello“ wird der hello Handler angesprochen.
• Die Logging Middleware wird der Variablen loggingMiddleware zugeordnet.
• Zuletzt wird der Server mit http.ListenAndServe gestartet. Der Server horcht auf den Port 8080.
  Die ListenAndServe Funktion erwartet als zweiten Wert einen Handler. Hier wird die loggingMiddleware Variable übergeben. Diese Middleware wird nun bei jedem Aufruf angewendet.
• Sobald nun eine Anfrage über http://localhost:8080/hello ankommt, wird die Logging Middleware ausgeführt und der hello Handler aufgerufen.

Den vollständigen Code findest du in meinem GitHub Repository.

Du kannst weitere Routen neben „/hello“ hinzufügen. Dabei wirst du merken, dass die Middleware immer aufgerufen wird.

Es gibt auch die Möglichkeit, eine Middleware nur bestimmten Routen zuzuordnen. Das sprengt jedoch den Umfang dieses Artikels.

Fazit

Zusammenfassend lässt sich sagen, dass die Middleware eine leistungsstarke Technik ist. Du kannst mit ihr die Funktionalität und Erweiterbarkeit deiner Go Anwendungen verbessern.

Die Middleware kannst du als Zwischenschicht zwischen dem HTTP-Server und den Endpunkten deiner Anwendung einbauen. So kannst du Aufgaben wie Logging, Authentifizierung und Caching effizient verwalten.

Einmal geschrieben, kannst du die Middleware in alle Endpunkte deiner Anwendung einbinden.

Quelle Hintergrund des Titelbilds: kostenlose Hintergrundfotos von .pngtree.com