Modul 8: Fehlerbehandlung: Idiomatische Patterns
Robuste Go-Programme durch idiomatische Fehlerbehandlung: error-Interface, Sentinel-Errors, Wrapping mit %w, Custom Error-Types, panic/recover und HTTP-Mapping.
Das error-Interface & Sentinel-Errors
Lektion 36 von 100
Fehler als Werte: Go's größter Vorteil
In Go ist ein Fehler ein Wert wie jeder andere. Das klingt simpel, ist aber revolutionär: Es gibt keine Exceptions, die die Kontrolle an eine höhere Hierarchie-Ebene delegieren. Stattdessen zwingt uns Go, jeden Fehler explizit zu behandeln. Das error-Interface ist dabei die Grundlage — es definiert eine einzige Methode: Error() string.
Diese Einfachheit ermöglicht immense Flexibilität. Wir können eigene Error-Typen erstellen, die das Interface implementieren, oder bestehende Fehler erweitern. Der Clou: Jeder Typ, der Error() string hat, ist ein error. Das macht das Interface zu einem der elegantesten Entwürfe in Go.
Das error-Interface als Vertrag
Das error-Interface ist Go's Mechanismus, um Fehler als erste Klasse zu behandeln. Es ist ein Interface mit einer einzigen Methode Error() string, was bedeutet, dass jeder Typ mit dieser Methode als error verwendet werden kann. Das ermöglicht die Erstellung reichhaltiger, typisierter Fehler, die sich nahtlos in die Standard-Fehlerbehandlung integrieren.
Hier ist die Grundstruktur, wie Go Fehler behandelt — explizit und vorhersehbar:
package main
import (
"fmt"
"errors"
)
// Standardfehler mit errors.New erstellen
var ErrNotFound = errors.New("Ressource nicht gefunden")
func findUser(id int) (string, error) {
if id == 0 {
return "", ErrNotFound
}
return fmt.Sprintf("Benutzer%d", id), nil
}
func main() {
user, err := findUser(0)
if err != nil {
fmt.Println("Fehler:", err)
// → Fehler: Ressource nicht gefunden
return
}
fmt.Println("Gefunden:", user)
}
Sentinel-Errors: Bekannte Fehler als Paket-Variablen
Ein Muster, das sich in der Go-Standardbibliothek durchzieht, sind Sentinel-Errors — vordefinierte Fehler, die als Paket-Variablen exportiert werden. Diese dienen als Sentinel (Wächter), die spezifische, erwartete Fehlerzustände markieren. Der große Vorteil: Code, der die Funktion aufruft, kann explizit auf diese bekannten Fehler prüfen.
Sentinel-Errors sind nicht für dynamische Fehler gedacht. Sie sollten nur für Zustände verwendet werden, die der Aufrufer explizit abfragen und anders behandeln möchte.
package main
import (
"errors"
"fmt"
)
// Sentinel Error: vordefiniert und dokumentiert
var ErrInvalidInput = errors.New("ungültige Eingabe")
func parse(input string) (int, error) {
if input == "" {
return 0, ErrInvalidInput
}
// Vereinfachte Parsing-Logik
return 42, nil
}
func process(input string) error {
num, err := parse(input)
if err != nil {
// Explizite Prüfung auf bekannten Sentinel-Error
if errors.Is(err, ErrInvalidInput) {
fmt.Println("Bitte gültige Eingabe bereitstellen")
// → Bitte gültige Eingabe bereitstellen
return nil // Graceful handling
}
return err
}
fmt.Println("Ergebnis:", num)
return nil
}
func main() {
process("")
}
⚠ Häufiger Fehler: Entwickler neigen dazu,
errors.Newinnerhalb von Funktionen aufzurufen, um dynamische Fehlermeldungen zu erstellen. Das führt zu neuen Fehlerinstanzen bei jedem Aufruf —errors.Is(err, ErrSomething)scheitert dann, selbst wenn die Meldung identisch ist. Sentinel-Errors müssen als Paket-Variablen definiert sein, damit Identitätsprüfungen funktionieren.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Wrapping mit %w & errors.Is/As
Lektion 37 von 100
Die Wrapping-Revolution: Go 1.13 bringt Kontext
Vor Go 1.13 gab es ein großes Problem: Wenn eine Funktion einen Fehler von einer tieferen Funktion zurückgab, ging der Kontext verloren. Man konnte den Fehler zwar weiterreichen, aber nicht mehr erkennen, welcher Ursprungsfehler dahintersteckte. Go 1.13 führte das %w-Verb für fmt.Errorf ein, mit dem man Fehler umhüllen (wrap) kann, während der ursprüngliche Fehler erhalten bleibt.
Das Wrapping ist essenziell, um Stacktraces nachzubilden und Ursprungsfehler in tiefen Aufrufketten identifizierbar zu halten. Statt fmt.Errorf("das hat nicht funktioniert: %v", err) schreibt man nun fmt.Errorf("das hat nicht funktioniert: %w", err).
Fehler-Wrapping vs. Fehler-Ersetzen
Wrapping bedeutet, einen bestehenden Fehler in einen neuen Fehler mit zusätzlichem Kontext einzubetten. Der ursprüngliche Fehler bleibt als Ursache erhalten und kann mit errors.Is() und errors.As() extrahiert werden. Ersetzen (z.B. mit %v oder %s) bricht diese Kette und macht den Ursprungsfehler unsichtbar für die Standard-Introspektion.
Hier sehen wir, wie Wrapping in der Praxis funktioniert:
package main
import (
"errors"
"fmt"
)
var ErrNotFound = errors.New("nicht gefunden")
func readFile(name string) (string, error) {
if name == "missing.txt" {
return "", ErrNotFound
}
return "Inhalt", nil
}
func processFile(name string) (string, error) {
content, err := readFile(name)
if err != nil {
return "", fmt.Errorf("Fehler beim Verarbeiten von %s: %w", name, err)
}
return content, nil
}
func main() {
_, err := processFile("missing.txt")
if err != nil {
fmt.Println("Wrapped Error:", err)
// → Wrapped Error: Fehler beim Verarbeiten von missing.txt: nicht gefunden
}
}
Introspektion: errors.Is und errors.As
Mit dem Wrapping allein ist es nutzlos — wir brauchen Werkzeuge, um den ursprünglich Fehler zu finden. errors.Is(err, target error) bool durchsucht die Fehlerkette nach dem gegebenen Fehler (per Identität oder via Unwrapping). errors.As(err, target interface{}) bool macht dasselbe, aber für Typen — perfekt für Custom Error-Types.
Diese beiden Funktionen sind der Schlüssel, um idiomatische Fehlerhochholung in Go zu implementieren.
package main
import (
"errors"
"fmt"
)
var ErrNotFound = errors.New("nicht gefunden")
func findFile(name string) (string, error) {
if name == "" {
return "", ErrNotFound
}
return "found", nil
}
func openFile(name string) (string, error) {
content, err := findFile(name)
if err != nil {
return "", fmt.Errorf("kann Datei nicht öffnen: %w", err)
}
return content, nil
}
func readFile(name string) (string, error) {
content, err := openFile(name)
if err != nil {
return "", fmt.Errorf("kann Datei %s nicht lesen: %w", name, err)
}
return content, nil
}
func main() {
_, err := readFile("")
if err != nil {
if errors.Is(err, ErrNotFound) {
fmt.Println("Ursprünglicher Fehler erkannt: Nicht gefunden")
// → Ursprünglicher Fehler erkannt: Nicht gefunden
}
fmt.Println("Voller Fehler:", err)
// → Voller Fehler: kann Datei nicht lesen: kann Datei nicht öffnen: nicht gefunden
}
}
⚠ Häufiger Fehler: Entwickler verwenden
errors.Is()mit einem neu erzeugten Fehler —errors.New("nicht gefunden")bewirkt, dass die Prüfung scheitert, weil es sich um eine andere Instanz handelt. Der zweite Parameter muss die exakte Paket-Variable oder ein gewrappter Fehler sein, der diese enthalten.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Custom Error-Types mit strukturierten Infos
Lektion 38 von 100
Wenn String nicht reicht: Strukturierte Fehler
Ein einfacher errors.New oder fmt.Errorf liefert nur einen String. Aber was, wenn wir zusätzliche Informationen benötigen? Ein HTTP-Handler möchte vielleicht den Statuscode wissen. Ein Datenbank-Fehler könnte den betroffenen Tabellennamen enthalten. Hier kommen Custom Error-Types ins Spiel.
Indem wir einen eigenen Typ erstellen, der das error-Interface implementiert, können wir beliebige zusätzliche Felder hinzufügen und behalten dabei gleichzeitig die Kompatibilität mit der Standard-Fehlerbehandlung.
Custom Error-Types als Domain-Spezifische Fehler
Ein Custom Error-Type ist ein Struct, das das error-Interface implementiert, zusammen mit zusätzlichen Methoden und Feldern. Dies ermöglicht typisierte Fehler, die über reine Textmeldungen hinausgehen und domänenspezifische Informationen transportieren können.
Hier ist ein klassisches Beispiel für einen strukturierten Fehler:
package main
import "fmt"
type DomainError struct {
Code int
Message string
Detail string
}
func (e *DomainError) Error() string {
return fmt.Sprintf("%s (Code: %d) — %s", e.Message, e.Code, e.Detail)
}
func validateInput(input string) error {
if input == "" {
return &DomainError{
Code: 400,
Message: "Validierungsfehler",
Detail: "Eingabe darf nicht leer sein",
}
}
return nil
}
func main() {
err := validateInput("")
if err != nil {
fmt.Println("Fehler:", err)
// → Fehler: Validierungsfehler (Code: 400) — Eingabe darf nicht leer sein
}
}
Typensichere Fehler abfragen mit errors.As
Der wahre Vorteil von Custom Error-Types zeigt sich in Kombination mit errors.As(). Diese Funktion erlaubt es uns, einen Fehler auf einen bestimmten Typ zu casten — ähnlich wie Type Assertions für Interfaces. Das ist besonders nützlich, wenn wir auf spezifische Felder oder Methoden des Fehlertyps zugreifen wollen.
In Go 1.13+ können wir auch die Unwrap() error Methode implementieren, um die Fehlerkette für das Wrapping zu unterstützen.
package main
import (
"errors"
"fmt"
)
type DatabaseError struct {
Table string
Err error
}
func (e *DatabaseError) Error() string {
return fmt.Sprintf("Datenbankfehler bei Tabelle %s: %v", e.Table, e.Err)
}
func (e *DatabaseError) Unwrap() error {
return e.Err
}
func query(table string) error {
baseErr := errors.New("Verbindung fehlgeschlagen")
return &DatabaseError{Table: table, Err: baseErr}
}
func getUsers() error {
err := query("users")
if err != nil {
return fmt.Errorf("Benutzer abrufen fehlgeschlagen: %w", err)
}
return nil
}
func main() {
err := getUsers()
if err != nil {
var dbErr *DatabaseError
if errors.As(err, &dbErr) {
fmt.Printf("Fehler bei Tabelle: %s\n", dbErr.Table)
// → Fehler bei Tabelle: users
}
}
}
⚠ Häufiger Fehler: Das Implementieren des
error-Interfaces reicht nicht aus, umerrors.Is()odererrors.As()durch die Wrapping-Kette zu erweitern. Ohne dieUnwrap() errorMethode kann die Fehlerkette nicht durchsucht werden. Jeder Custom Error-Type, der gewrapped werden soll, muss diese Methode implementieren, wenn er andere Fehler einbettet.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
panic/recover: wann (nicht) & defers Rolle
Lektion 39 von 100
Panic: Der Notausgang
Go's Philosophie ist klar: Fehler sind Werte, und normale Fehler sollten als error zurückgegeben werden. Panic ist der Mechanismus für katastrophale Fehler, von denen sich das Programm nicht erholen kann — oder für Programmierfehler, die nie im Betrieb auftreten sollten. Ein panic bricht die normale Ausführung ab und beginnt das Stack-Unwinding.
Wichtig: panic ist nicht für erwartete Fehler! Ein fehlgeschlagener Netzwerk-Request? Eine normale Datei nicht gefunden? Das sind alles Fälle für error. Ein nil-Pointer-Dereferenzierung oder eine nicht erreichbare Code-Pfad? Das kann ein Anzeichen für ein panic sein.
panic vs error: Die Entscheidung-Regel
Verwende panic, wenn das Programm in einem ungültigen Zustand ist, von dem es sich nicht erholen kann. Verwende error, wenn ein erwartbarer Fehlerzustand aufgetreten ist, der vom Aufrufer behandelt werden muss. Die Regel: "Don't panic" — außer in außergewöhnlichen Umständen.
Hier sehen wir, wie panic funktioniert und wann es angemessen ist:
package main
import "fmt"
func divide(a, b int) int {
if b == 0 {
panic("Division durch Null nicht erlaubt")
}
return a / b
}
func safeDivide(a, b int) (result int, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("Panic abgefangen: %v", r)
}
}()
return divide(a, b), nil
}
func main() {
result, err := safeDivide(10, 0)
if err != nil {
fmt.Println("Behandelter Fehler:", err)
// → Behandelter Fehler: Panic abgefangen: Division durch Null nicht erlaubt
}
}
Recover: Den Absturz abfangen
Eine panic propagiert nach oben durch die Aufrufstacks, bis sie entweder den main-Goroutine erreicht (was zum Programm-Crash führt) oder von einem recover abgefangen wird. recover ist eine Built-in-Funktion, die nur innerhalb von deferred Funktionen aufgerufen werden kann.
Das klassische Muster ist defer/recover am Anfang von Goroutines oder in main-Funktionen, um Panics abzufangen und in Fehler umzuwandeln.
package main
import (
"fmt"
"log"
)
func processWithRecovery(task string) {
defer func() {
if r := recover(); r != nil {
log.Printf("Panic in %s abgefangen: %v", task, r)
// → Panic in fehlgeschlagen abgefangen: etwas ist schief gelaufen
}
}()
if task == "fehlgeschlagen" {
panic("etwas ist schief gelaufen")
}
fmt.Println("Aufgabe", task, "erfolgreich")
}
func main() {
processWithRecovery("erfolgreich")
processWithRecovery("fehlgeschlagen")
fmt.Println("Programm läuft weiter")
// → Aufgabe erfolgreich erfolgreich
// → Panic in fehlgeschlagen abgefangen: etwas ist schief gelaufen
// → Programm läuft weiter
}
⚠ Häufiger Fehler: Entwickler versuchen,
recover()außerhalb einer deferred Funktion aufzurufen. Das ist ein Compile-Fehler.recoverfunktioniert nur innerhalb vondeferund fängt nur Panics ab, die nach dem Beginn der defer-Funktion auftreten — nicht die, die in der gleichen Funktion vor dem defer auftreten.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Fehler-Design: HTTP-Mapping, Logs vs Errors
Lektion 40 von 100
Fehler spiegeln Domain: HTTP-Statuscodes mappen
Wenn wir eine HTTP-API bauen, müssen wir Go-Fehler auf HTTP-Statuscodes abbilden. Die Herausforderung: Ein Go-Fehler kann je nach Kontext unterschiedliche HTTP-Statuscodes bedeuten. Ein ErrNotFound könnte 404 (Not Found) sein, aber auch 400 (Bad Request), wenn die Eingabe ungültig war.
Eine bewährte Praxis ist das Erstellen eines Error-Handlers, der Domain-Fehler in HTTP-Responses übersetzt. Dabei ist es wichtig, nicht zu viele Details an den Client zu geben (Sicherheit!) aber gleichzeitig genug Information fürs Debugging zu loggen.
Error to HTTP-Status Mapping als Übersetzungs-Schicht
Die Abbildung von Domain-Fehlern auf HTTP-Statuscodes ist eine Übersetzungsaufgabe. Dabei müssen wir berücksichtigen: Sicherheit (keine internen Details preisgeben), Konsistenz (gleiche Fehler = gleiche Codes) und Benutzerfreundlichkeit (klare, handhabbare Fehlermeldungen).
Hier sehen wir, wie eine saubere HTTP-Fehlerbehandlung aussieht:
package main
import (
"errors"
"fmt"
"net/http"
)
var (
ErrNotFound = errors.New("Ressource nicht gefunden")
ErrInvalidInput = errors.New("ungültige Eingabe")
ErrInternal = errors.New("interner Fehler")
)
func handleError(w http.ResponseWriter, err error) {
switch {
case errors.Is(err, ErrNotFound):
http.Error(w, "Ressource nicht gefunden", http.StatusNotFound)
case errors.Is(err, ErrInvalidInput):
http.Error(w, "Ungültige Anfrage", http.StatusBadRequest)
case errors.Is(err, ErrInternal):
fmt.Println("Interner Fehler:", err)
http.Error(w, "Interner Serverfehler", http.StatusInternalServerError)
default:
http.Error(w, "Interner Serverfehler", http.StatusInternalServerError)
}
}
func getResourceHandler(w http.ResponseWriter, r *http.Request) {
id := r.URL.Query().Get("id")
if id == "" {
handleError(w, ErrInvalidInput)
return
}
resource, err := findResource(id)
if err != nil {
handleError(w, err)
return
}
fmt.Fprintf(w, "Ressource: %s", resource)
}
func findResource(id string) (string, error) {
if id == "missing" {
return "", ErrNotFound
}
return "Resource-" + id, nil
}
func main() {
http.HandleFunc("/resource", getResourceHandler)
fmt.Println("Server startet auf :8080")
// → Server startet auf :8080
http.ListenAndServe(":8080", nil)
}
Logging: Was gehört in Logs, was nicht
Ein häufiges Missverständnis: Alles in Errors packen. Aber Fehler und Logs haben unterschiedliche Zwecke. Fehler sind für den Code — sie werden programmatisch behandelt. Logs sind für Menschen — sie helfen beim Debugging und Monitoring.
Die goldene Regel: Logge die Fehler mit genug Kontext, damit ein Entwickler das Problem nachvollziehen kann. Aber gib nicht zu viele Details an den Endbenutzer weiter (Sicherheitsrisiko).
package main
import (
"errors"
"fmt"
"log"
"os"
)
var ErrOpenFile = errors.New("Datei konnte nicht geöffnet werden")
func processFile(name string) error {
f, err := os.Open(name)
if err != nil {
log.Printf("Fehler beim Öffnen von %s: %v", name, err)
// → Fehler beim Öffnen von nonexistent.txt: open nonexistent.txt: no such file or directory
return fmt.Errorf("Verarbeitung fehlgeschlagen: %w", ErrOpenFile)
}
defer f.Close()
return nil
}
func main() {
err := processFile("nonexistent.txt")
if err != nil {
log.Println("Gesamtfehler:", err)
// → Gesamtfehler: Verarbeitung fehlgeschlagen: Datei konnte nicht geöffnet werden
}
}
⚠ Häufiger Fehler: Entwickler neigen dazu, sensible Informationen (Datenbank-Verbindungsstrings, Passwörter, interne Pfade) in Fehlermeldungen oder Logs zu schreiben, die an den Client zurückgegeben werden. Das ist ein schwerwiegendes Sicherheitsrisiko. Logs sollten nur Server-seitig gespeichert werden und Fehler an den Client sollten neutral und sicher formuliert sein.
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren: