Direkt zum Hauptinhalt springen
eLearner.app
Modul 10 · Lektion 5 von 550/50 im Kurs~18 min
Lektionen des Moduls (5/5)

Miniprojekt: ein HTTP-Server

Das net/http-Stdlib-Paket reicht aus, um einen produktionsbereiten HTTP-Server zu erstellen: Routing, Handler, Middleware, ordnungsgemäßes Herunterfahren. Kein Rahmen erforderlich. Für typische REST-APIs ist dies die Grundlage.

Hallo Welt

Go
package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "hello %s", r.URL.Path[1:])
    })
    if err := http.ListenAndServe(":8080", nil); err != nil {
        panic(err)
    }
}

http.ListenAndServe blockiert und kehrt nur bei Fehler zurück. nil als zweites Argument = „verwende den DefaultServeMux“.

Die Handler-Signatur

Alle Handler haben die gleiche Signatur:

Go
func(w http.ResponseWriter, r *http.Request)
  • w http.ResponseWriter – Ausgabe: Header, Statuscode, Text.
  • r *http.Request – Eingabe: Methode, URL, Header, Text, Kontext.

Typisches Muster:

Go
func ping(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
        http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK) // optional, defaults to 200
    fmt.Fprintln(w, `{"ok":true}`)
}

Routing mit ServeMux

*http.ServeMux ist der Basisrouter. Seit Go 1.22 unterstützt es Muster mit Methoden- und Pfadparametern:

Go
mux := http.NewServeMux()
mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")
    fmt.Fprintln(w, "user", id)
})
mux.HandleFunc("POST /users", createUser)

http.ListenAndServe(":8080", mux)

Für anspruchsvollere Router (Gruppen, integrierte Middleware, Regex) gibt es chi, gorilla/mux, gin, echo. Die stdlib deckt 90 % der Fälle ab.

Middleware als Dekorateur

Eine Middleware ist eine Funktion func(http.Handler) http.Handler:

Go
func logMW(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %s", r.Method, r.URL.Path, time.Since(start))
    })
}

http.ListenAndServe(":8080", logMW(mux))

Um sie zu verketten: logMW(authMW(rateLimitMW(mux))). Jede Middleware schmückt die nächste.

http.Server zur Feinsteuerung

http.ListenAndServe(addr, h) ist eine Abkürzung. Für Zeitüberschreitungen, TLS und ordnungsgemäßes Herunterfahren müssen Sie http.Server instanziieren:

Go
srv := &http.Server{
    Addr:              ":8080",
    Handler:           mux,
    ReadHeaderTimeout: 5 * time.Second,
    ReadTimeout:       30 * time.Second,
    WriteTimeout:      30 * time.Second,
    IdleTimeout:       2 * time.Minute,
}
log.Fatal(srv.ListenAndServe())

Ordentliches Herunterfahren mit Kontext

Wenn der Prozess SIGINT/SIGTERM empfängt, möchten Sie die laufenden Anfragen vor dem Schließen abschließen:

Go
ctx, stop := signal.NotifyContext(context.Background(),
    os.Interrupt, syscall.SIGTERM)
defer stop()

srv := &http.Server{Addr: ":8080", Handler: mux}
go func() {
    if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        log.Fatal(err)
    }
}()

<-ctx.Done() // wait for the signal

shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := srv.Shutdown(shutdownCtx); err != nil {
    log.Println("shutdown:", err)
}

srv.Shutdown akzeptiert keine neuen Verbindungen mehr und wartet auf den Abschluss aktiver Verbindungen (bis zum Ablauf der eingegebenen Frist).

Den JSON-Body lesen

Go
type CreateUserReq struct {
    Name string `json:"name"`
}

func createUser(w http.ResponseWriter, r *http.Request) {
    var req CreateUserReq
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    // ... use req.Name
    w.WriteHeader(http.StatusCreated)
}

r.Body ist ein io.ReadCloser: Der Server schließt es automatisch, aber json.NewDecoder liest nicht über das erste JSON-Objekt hinaus (nützlich zur Validierung von Eingaben).

Übungen

Übung#go.m10.l5.e1
Versuche: 0Wird geladen…

Registrieren Sie den Handler hallo auf der Route '/' mit http.HandleFunc.

Editor wird geladen…

Lösung nach 3 Versuchen verfügbar

Übung#go.m10.l5.e2
Versuche: 0Wird geladen…

Rufen Sie den Server unter :8080 mit http.ListenAndServe auf und der Fehler ist nicht gleich Null.

Editor wird geladen…

Lösung nach 3 Versuchen verfügbar

Quiz#go.m10.l5.e3
Bereit

Was ist die feste Sprache eines HTTP-Handlers in Go?

Go
func H(???) { ... }
Antwortoptionen