Mit der zunehmenden Beliebtheit von Go als Sprache für Webanwendungen häufen sich in den entsprechenden Foren bei Slack, StackOverflow oder Reddit die Fragen nach dem Multiplexing, also dem Verteilen der Anfragen auf die hierfür zuständigen Funktionen. Für diese Aufgabe gibt es inzwischen diverse stark verbreitete Lösungen, beispielsweise gorilla/mux. Doch sie bringen neben ihren Features auch einige Nachteile mit sich. Etwa ein für viele Aufgaben zu großer Codeumfang mit vielen Abhängigkeiten zu externen Bibliotheken sowie eine hohe Komplexität. Dabei enthält die Standardbibliothek in net/http [1] doch bereits einen flexiblen Ansatz. Einfache Funktionen, flexible Typen und auch ein geschachteltes Multiplexing lassen sich zur Verarbeitung der Requests einsetzen.
Wer nun jedoch einen umfänglichen Ansatz wie in Rails erwartet, wird enttäuscht. Diesen Abstraktionsgrad bietet Go (zumindest von Haus aus) nicht. Besser ist hier der klassische Weg, Geschäftslogik und hierin genutzte Persistenz sauber über Interfaces zu definieren und diese zu nutzen. Neben den produktiven Implementierungen können so auch Stubs [2] für Tests elegant implementiert oder Datenbanksysteme ausgetauscht werden. Doch das ist ein anderes Thema.
Anfragen verarbeiten
Das Paket net/http bringt einen Server mit, der eintreffende HTTP Requests auf diese verarbeitenden Funktionen in Goroutinen verteilt. So sind die Funktionen http.ListenAndServe() für HTTP und http.ListenAndServeTLS() für HTTPS die einfachsten Varianten. Ebenso gibt es http.Serve() und http.ServeTLS(), die jeweils mit individuellen Instanzen eines net.Listener arbeiten und so mehr Flexibilität in dessen Konfiguration bieten. Der dritte Weg und derjenige mit der größten Flexibilität ist die Erzeugung einer eigenen Instanz des http.Server, die sich in vielen Parametern konfigurieren lässt.
Allen drei Varianten ist gemein, dass sie eine Implementierung des Interface http.Handler für die Verarbeitung der Requests benötigen. Diese Schnittstelle definiert nur die eine Methode ServeHTTP(w http.ResponseWriter, r *http.Request). In dieser Methode ist nun je nach Bedarf der Request r zu analysieren und eine Antwort an den Writer w zu schreiben. Beide Typen stellen hierfür unterschiedliche Felder und Methoden zur Verfügung.
Eine einfache und praktische Spielform des Interface ist http.HandlerFunc. Es ist der einfache Funktionstyp func(w http.ResponseWriter, r *http.Request), dessen Methode func (f HandlerFunc) ServeHTTP(w, r) als Aufruf von f(w, r) definiert ist. Und so lässt sich ein ganz einfacher Server wie folgt definieren:
h := func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
w.Write([]byte("Hello, World!"))
}
http.ListenAndServe(":8080", h)
Die Analyse des Pfads eines Requests und die Verteilung auf entsprechende Funktionen innerhalb des Handlers sind dabei allerdings recht umständlich. Ein Weg ist zum Beispiel die Auswertung über ein switch (Listing 1). Spaß macht das aber nicht.
Listing 1
func (api *ShopAPI) ServeHTTP(w http.ResponseWriter, r *http.Request) {
switch {
case strings.HasPrefix(r.URL.Path, "/api/customers/"):
api.customersServeHTTP(w, r)
case strings.HasPrefix(r.URL.Path, "/api/orders/"):
api.ordersServeHTTP(w, r)
default:
http.Error(w, "cannot handle request", http.StatusNotFound)
}
}Bei sehr kleinen APIs mag es noch gehen. Doch mit zunehmender Anzahl möglicher Pfade wird dieser Ansatz zu statisch und die Wartung zunehmend unmöglich. Zudem ist das Beispiel bewusst einfach gehalten. Für Pfade wie /posts/../api/customers oder /api/customers ohne den abschlie...

