Assoziationen
Beziehungen modellieren
Assoziationen ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.
Beziehungen modellieren
GORM bildet Assoziationen zwischen Tabellen auf Strukturfelder ab. Die vier Arten sind Has One, Has Many, Belongs To und Many To Many.
- Fremdschlüssel als Strukturfelder ausdrücken
- Zugehörige Daten automatisch laden
- Zugehörige Datensätze gemeinsam erstellen
Has Many
Ein Benutzer hat viele Beiträge. Das übergeordnete Objekt enthält eine Slice der untergeordneten Objekte, und das untergeordnete Objekt enthält einen Fremdschlüssel zurück zum übergeordneten Objekt.
type User struct {
gorm.Model
Name string
Posts []Post
}
type Post struct {
gorm.Model
Title string
UserID uint
}Belongs To
Aus der Perspektive des untergeordneten Objekts gehört ein Beitrag zu einem Benutzer. Fügen Sie ein User-Feld sowie den Fremdschlüssel UserID hinzu, um diese Beziehung auszudrücken.
type Post struct {
gorm.Model
Title string
UserID uint
User User
}Has One
Has One ähnelt Has Many, bezieht sich aber auf genau einen zugehörigen Datensatz, etwa wenn ein Benutzer ein Profil besitzt. Der Fremdschlüssel befindet sich im untergeordneten Objekt.
type User struct {
gorm.Model
Profile Profile
}
type Profile struct {
gorm.Model
UserID uint
Bio string
}Many To Many
Benutzer und Rollen stehen über eine Join-Tabelle in einer Many-to-Many-Beziehung. Das many2many-Tag benennt diese Join-Tabelle und wird nach dem Feld Roles in Backticks als gorm:"many2many:user_roles;" geschrieben.
type User struct {
gorm.Model
// Roles field tag: gorm:"many2many:user_roles;"
Roles []Role
}
type Role struct {
gorm.Model
Name string
}Preload
Standardmäßig werden zugehörige Daten nicht geladen. Preload weist GORM an, die Assoziationen in einer separaten Abfrage abzurufen, sodass Sie keine eigene Abfrage dafür schreiben müssen.
var user User
db.Preload("Posts").First(&user, 1)
fmt.Println(len(user.Posts))Verschachteltes Preload
Mit einem durch Punkte getrennten Pfad können Sie über mehrere Ebenen hinweg vorladen und in einer Aufrufkette die Beiträge eines Benutzers sowie die Kommentare zu jedem Beitrag laden.
db.Preload("Posts.Comments").First(&user, 1)Eine ausführbare Simulation von Assoziationen
GORM benötigt eine Datenbank. Dieses ausführbare Beispiel bildet daher eine Has-Many-Beziehung und das Vorladen mit In-Memory-Slices nach.
package main
import "fmt"
type Post struct {
ID int
UserID int
Title string
}
type User struct {
ID int
Name string
Posts []Post
}
func preload(u *User, all []Post) {
for _, p := range all {
if p.UserID == u.ID {
u.Posts = append(u.Posts, p)
}
}
}
func main() {
u := User{ID: 1, Name: "Ada"}
all := []Post{{1, 1, "Hello"}, {2, 1, "World"}, {3, 2, "Other"}}
preload(&u, all)
fmt.Printf("%s has %d posts\n", u.Name, len(u.Posts))
}Erstellen mit Assoziationen
Wenn Sie das Slice-Feld vor Create setzen, fügt GORM das übergeordnete Objekt und seine untergeordneten Objekte gemeinsam ein und verknüpft die Fremdschlüssel automatisch.
user := User{Name: "Ada", Posts: []Post{{Title: "Hi"}}}
db.Create(&user)Das N+1-Problem
Wenn Sie über übergeordnete Objekte iterieren und für jedes davon die untergeordneten Objekte abfragen, entsteht eine Abfrage pro übergeordnetem Objekt – das N+1-Problem. Preload löst es, indem die zugehörigen Daten mit einer einzigen zusätzlichen Abfrage gesammelt abgerufen werden.
Der Association-Modus
Die Association-API fügt zugehörige Datensätze hinzu, ersetzt oder löscht sie beziehungsweise entfernt alle, ohne dass Sie Fremdschlüssel manuell verwalten müssen, zum Beispiel mit db.Model(&user).Association("Posts").Append(&post).
Kurzer Test
Testen Sie Ihr Wissen über Assoziationen.
Zusammenfassung
Sie haben Assoziationen kennengelernt:
- Has One, Has Many, Belongs To und Many2many modellieren Beziehungen zwischen Daten
- Fremdschlüssel sind Strukturfelder wie UserID
- Preload lädt Assoziationen und vermeidet das N+1-Problem
- Beim Erstellen eines übergeordneten Objekts mit untergeordneten Objekten werden die Fremdschlüssel verknüpft
- Der Association-Modus fügt Beziehungen hinzu, ersetzt sie oder entfernt sie
Lerne Go mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 51
- Lektionen
- 203
Häufig gestellte Fragen
Ist die Lektion „Assoziationen“ kostenlos?
Ja — der vollständige Text von „Assoziationen“ 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 „Assoziationen“?
Beziehungen modellieren 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 3 von 4.
Wie lange dauert die Lektion „Assoziationen“?
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.