Go Academy · Lektion

Hooks und Scopes

Abfragen anpassen

Hooks und Scopes ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Hooks und Scopes

GORM bietet zwei Werkzeuge zur Anpassung: Hooks führen automatisch Code rund um Lebenszyklusereignisse aus, und Scopes bündeln wiederverwendbare Abfragelogik. Zusammen halten sie Ihren Datenzugriff sauber und konsistent.

Was sind Hooks

Hooks sind Methoden Ihres Models, die GORM vor oder nach einer Operation aufruft: BeforeCreate, AfterCreate, BeforeUpdate, BeforeDelete und weitere.

Ein BeforeCreate-Hook

Definieren Sie eine Methode mit der richtigen Signatur im Model. Hier setzen wir vor dem Einfügen des Datensatzes eine UUID.

func (u *User) BeforeCreate(tx *gorm.DB) error {
    u.UUID = uuid.NewString()
    return nil
}

Validierung in Hooks

Geben Sie aus einem Hook einen Fehler zurück, um die Operation abzubrechen. GORM führt für die umgebende Transaktion ein Rollback durch, sodass ungültige Daten niemals die Datenbank erreichen.

func (u *User) BeforeSave(tx *gorm.DB) error {
    if u.Age < 0 {
        return errors.New("age cannot be negative")
    }
    return nil
}

Hooks werden in einer Transaktion ausgeführt

Das Argument tx *gorm.DB ist die von GORM verwendete Transaktion. Wenn Sie in einem Hook zugehörige Daten schreiben, verwenden Sie dieses tx, damit die Änderungen gemeinsam mit der Hauptoperation atomar committet oder zurückgerollt werden.

Was sind Scopes

Ein Scope ist eine Funktion, die ein *gorm.DB entgegennimmt und zurückgibt und einen Teil einer Abfrage kapselt. Sie wenden ihn mit db.Scopes(...) an und verwenden ihn in vielen Abfragen wieder.

func ActiveUsers(db *gorm.DB) *gorm.DB {
    return db.Where("active = ?", true)
}

Scopes anwenden

Übergeben Sie einen oder mehrere Scopes an Scopes. Sie lassen sich kombinieren, sodass Sie Filter deklarativ zu einer abschließenden Abfrage zusammenstellen können.

db.Scopes(ActiveUsers, Recent).Find(&users)

Ausführbarer Hook und Simulation eines Scopes

GORM benötigt eine Datenbank. Daher simuliert dieses ausführbare Beispiel einen BeforeCreate-Hook und einen wiederverwendbaren, Scope-ähnlichen Filter mit einfachen Funktionen.

package main

import (
    "errors"
    "fmt"
)

type User struct {
    Name   string
    Age    int
    Active bool
}

func beforeCreate(u *User) error {
    if u.Age < 0 {
        return errors.New("age cannot be negative")
    }
    if u.Name == "" {
        u.Name = "anonymous"
    }
    return nil
}

func activeOnly(users []User) []User {
    var out []User
    for _, u := range users {
        if u.Active {
            out = append(out, u)
        }
    }
    return out
}

func main() {
    u := User{Age: 30, Active: true}
    if err := beforeCreate(&u); err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println("created:", u.Name)
    all := []User{u, {Name: "Lin", Active: false}}
    fmt.Println("active count:", len(activeOnly(all)))
}

Scopes für Paginierung

Ein häufig verwendeter Scope erzeugt anhand einer Seitennummer die Paginierung und kapselt Offset und Limit, sodass jeder Listenendpunkt auf dieselbe Weise paginiert.

func Paginate(page, size int) func(*gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
        return db.Offset((page - 1) * size).Limit(size)
    }
}

Hooks vs. Anwendungslogik

Hooks zentralisieren querschnittliche Belange wie Zeitstempel, Slugs und Audit-Felder. Umfangreiche Geschäftslogik gehört in Services und nicht in Hooks, damit das Verhalten vorhersehbar und testbar bleibt.

Hooks überspringen

Bei Massenoperationen können Sie Hooks mit db.Session(&gorm.Session{SkipHooks: true}) deaktivieren. Das beschleunigt große Importe, überspringt jedoch Ihre Validierungen. Verwenden Sie diese Option daher mit Bedacht.

Kurzer Test

Testen Sie Ihr Wissen über Hooks und Scopes.

Zusammenfassung

Sie haben Hooks und Scopes kennengelernt:

Hooks werden rund um Lebenszyklusereignisse ausgeführt; das Zurückgeben eines Fehlers bricht den Vorgang ab und führt ein Rollback aus
Hooks werden innerhalb der Transaktion über das tx-Argument ausgeführt
Scopes sind wiederverwendbare *gorm.DB-Funktionen, die mit Scopes angewendet werden
Verwenden Sie Scopes für Filter und Paginierung
SkipHooks umgeht Hooks bei Massenoperationen

Häufig gestellte Fragen

Ist die Lektion „Hooks und Scopes“ kostenlos?

Ja — der vollständige Text von „Hooks und Scopes“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Hooks und Scopes“?

Abfragen anpassen Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Hooks und Scopes“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy