gorm 教程二

过去日记

墨衍会员 · AI 创作全网分发码龄3年

关注

原创最新推荐文章于 2026-04-15 09:04:25 发布 895 阅读 AI 写同款· GEO 优化 ›

Gorm教程 - 关联嵌套预加载。阅读详情

关联

Belongs To

属于

belongs to 关联建立一个和另一个模型的一对一连接，使得模型声明每个实例都「属于」另一个模型的一个实例。

例如，如果你的应用包含了用户和用户资料，并且每一个用户资料只分配给一个用户

type User struct {
  gorm.Model
  Name string
}

// `Profile` 属于 `User`， `UserID` 是外键
type Profile struct {
  gorm.Model
  UserID int
  User   User
  Name   string
}

外键

为了定义从属关系，外键是必须存在的，默认的外键使用所有者类型名称加上其主键。

像上面的例子，为了声明一个模型属于 User，它的外键应该为 UserID。

GORM 提供了一个定制外键的方法，例如:

type User struct {
    gorm.Model
    Name string
}

type Profile struct {
    gorm.Model
  Name      string
  User      User `gorm:"foreignkey:UserRefer"` // 使用 UserRefer 作为外键
  UserRefer string
}

关联外键

对于从属关系， GORM 通常使用所有者的主键作为外键值，在上面的例子中，就是 User 的 ID。

当你分配一个资料给一个用户， GORM 将保存用户表的 ID 值到用户资料表的 UserID 字段里。

你可以通过改变标签 association_foreignkey 来改变它，例如：

type User struct {
    gorm.Model
  Refer int
    Name string
}

type Profile struct {
    gorm.Model
  Name      string
  User      User `gorm:"association_foreignkey:Refer"` // use Refer 作为关联外键
  UserRefer string
}

使用属于

你能找到 belongs to 和 Related 的关联

db.Model(&user).Related(&profile)
//// SELECT * FROM profiles WHERE user_id = 111; // 111 is user's ID

Has One

has one 关联也是与另一个模型建立一对一的连接，但语义（和结果）有些不同。此关联表示模型的每个实例包含或拥有另一个模型的一个实例。

例如，如果你的应用程序包含用户和信用卡，并且每个用户只能有一张信用卡。

// 用户有一个信用卡，CredtCardID 外键
type User struct {
    gorm.Model
    CreditCard   CreditCard
}

type CreditCard struct {
    gorm.Model
    Number   string
    UserID    uint
}

外键

对于一对一关系，一个外键字段也必须存在，所有者将保存主键到模型关联的字段里。

这个字段的名字通常由 belongs to model 的类型加上它的 primary key 产生的，就上面的例子而言，它就是 CreditCardID

当你给用户一个信用卡，它将保存一个信用卡的 ID 到 CreditCardID 字段中。

如果你想使用另一个字段来保存这个关系，你可以通过使用标签 foreignkey 来改变它，例如：

type User struct {
  gorm.Model
  CreditCard CreditCard `gorm:"foreignkey:CardRefer"`
}

type CreditCard struct {
    gorm.Model
    Number      string
    UserName string
}

关联外键

通常，所有者会保存 belogns to model 的主键到外键，你可以改为保存其他字段，就像下面的例子使用 Number 。

type User struct {
  gorm.Model
  CreditCard CreditCard `gorm:"association_foreignkey:Number"`
}

type CreditCard struct {
    gorm.Model
    Number string
    UID       string
}

多态关联

支持多态的一对多和一对一关联。

  type Cat struct {
    ID    int
    Name  string
    Toy   Toy `gorm:"polymorphic:Owner;"`
  }

  type Dog struct {
    ID   int
    Name string
    Toy  Toy `gorm:"polymorphic:Owner;"`
  }

  type Toy struct {
    ID        int
    Name      string
    OwnerID   int
    OwnerType string
  }

注意：多态属于和多对多是明确的不支持并将会抛出错误。

使用一对一

你可以通过 Related 找到 has one 关联。

var card CreditCard
db.Model(&user).Related(&card, "CreditCard")
//// SELECT * FROM credit_cards WHERE user_id = 123; // 123 是用户表的主键
// CreditCard  是用户表的字段名，这意味着获取用户的信用卡关系并写入变量 card。
// 像上面的例子，如果字段名和变量类型名一样，它就可以省略， 像：
db.Model(&user).Related(&card)

Has Many

一对多

has many 关联就是创建和另一个模型的一对多关系，不像 has one，所有者可以拥有0个或多个模型实例。

例如，如果你的应用包含用户和信用卡，并且每一个用户都拥有多张信用卡。

// 用户有多张信用卡，UserID 是外键
type User struct {
    gorm.Model
    CreditCards []CreditCard
}

type CreditCard struct {
    gorm.Model
    Number   string
    UserID  uint
}

外键

为了定义一对多关系，外键是必须存在的，默认外键的名字是所有者类型的名字加上它的主键。

就像上面的例子，为了定义一个属于User 的模型，外键就应该为 UserID。

使用其他的字段名作为外键，你可以通过 foreignkey 来定制它，例如:

type User struct {
    gorm.Model
    CreditCards []CreditCard `gorm:"foreignkey:UserRefer"`
}

type CreditCard struct {
    gorm.Model
    Number    string
  UserRefer uint
}

外键关联

GORM 通常使用所有者的主键作为外键的值，在上面的例子中，它就是 User 的 ID。

当你分配信用卡给一个用户， GORM 将保存用户 ID 到信用卡表的 UserID 字段中。

你能通过 association_foreignkey 来改变它，例如:

type User struct {
    gorm.Model
  MemberNumber string
    CreditCards  []CreditCard `gorm:"foreignkey:UserMemberNumber;association_foreignkey:MemberNumber"`
}

type CreditCard struct {
    gorm.Model
    Number           string
  UserMemberNumber string
}

多态关联

支持多态的一对多和一对一关联。

  type Cat struct {
    ID    int
    Name  string
    Toy   []Toy `gorm:"polymorphic:Owner;"`
  }

  type Dog struct {
    ID   int
    Name string
    Toy  []Toy `gorm:"polymorphic:Owner;"`
  }

  type Toy struct {
    ID        int
    Name      string
    OwnerID   int
    OwnerType string
  }

注意：多态属于和多对多是明确不支持并会抛出错误的。

使用一对多

你可以通过Related 找到 has many 关联关系。

db.Model(&user).Related(&emails)
//// SELECT * FROM emails WHERE user_id = 111; // 111 是用户表的主键

Many To Many

多对多

多对多为两个模型增加了一个中间表。

例如，如果你的应用包含用户和语言，一个用户会说多种语言，并且很多用户会说一种特定的语言。

// 用户拥有并属于多种语言， 使用  `user_languages` 作为中间表
type User struct {
    gorm.Model
    Languages         []Language `gorm:"many2many:user_languages;"`
}

type Language struct {
    gorm.Model
    Name string
}

反向关联

// 用户拥有并且属于多种语言，使用 `user_languages` 作为中间表
type User struct {
    gorm.Model
    Languages         []*Language `gorm:"many2many:user_languages;"`
}

type Language struct {
    gorm.Model
    Name string
    Users               []*User     `gorm:"many2many:user_languages;"`
}

db.Model(&language).Related(&users)
//// SELECT * FROM "users" INNER JOIN "user_languages" ON "user_languages"."user_id" = "users"."id" WHERE  ("user_languages"."language_id" IN ('111'))

外键

type CustomizePerson struct {
  IdPerson string             `gorm:"primary_key:true"`
  Accounts []CustomizeAccount `gorm:"many2many:PersonAccount;association_foreignkey:idAccount;foreignkey:idPerson"`
}

type CustomizeAccount struct {
  IdAccount string `gorm:"primary_key:true"`
  Name      string
}

外键会为两个结构体创建一个多对多的关系，并且这个关系将通过外键customize_person_id_person 和 customize_account_id_account 保存到中间表 PersonAccount。

中间表外键

如果你想改变中间表的外键，你可以用标签 association_jointable_foreignkey, jointable_foreignkey

type CustomizePerson struct {
  IdPerson string             `gorm:"primary_key:true"`
  Accounts []CustomizeAccount `gorm:"many2many:PersonAccount;foreignkey:idPerson;association_foreignkey:idAccount;association_jointable_foreignkey:account_id;jointable_foreignkey:person_id;"`
}

type CustomizeAccount struct {
  IdAccount string `gorm:"primary_key:true"`
  Name      string
}

自引用

为了定义一个自引用的多对多关系，你不得不改变中间表的关联外键。

和来源表外键不同的是它是通过结构体的名字和主键生成的，例如：

type User struct {
  gorm.Model
  Friends []*User `gorm:"many2many:friendships;association_jointable_foreignkey:friend_id"`
}

GORM 将创建一个带外键 user_id 和 friend_id 的中间表，并且使用它去保存用户表的自引用关系。

然后你可以像普通关系一样操作它，例如：

DB.Preload("Friends").First(&user, "id = ?", 1)

DB.Model(&user).Association("Friends").Append(&User{Name: "friend1"}, &User{Name: "friend2"})

DB.Model(&user).Association("Friends").Delete(&User{Name: "friend2"})

DB.Model(&user).Association("Friends").Replace(&User{Name: "new friend"})

DB.Model(&user).Association("Friends").Clear()

DB.Model(&user).Association("Friends").Count()

使用多对多

db.Model(&user).Related(&languages, "Languages")
//// SELECT * FROM "languages" INNER JOIN "user_languages" ON "user_languages"."language_id" = "languages"."id" WHERE "user_languages"."user_id" = 111

//  当查询用户时预加载 Language
db.Preload("Languages").First(&user)

关联

自动创建/更新

GORM 将在创建或保存一条记录的时候自动保存关联和它的引用，如果关联有一个主键， GORM 将调用 Update 来更新它，不然，它将会被创建。

user := User{
    Name:            "jinzhu",
    BillingAddress:  Address{Address1: "Billing Address - Address 1"},
    ShippingAddress: Address{Address1: "Shipping Address - Address 1"},
    Emails:          []Email{
        {Email: "jinzhu@example.com"},
        {Email: "jinzhu-2@example@example.com"},
    },
    Languages:       []Language{
        {Name: "ZH"},
        {Name: "EN"},
    },
}

db.Create(&user)
//// BEGIN TRANSACTION;
//// INSERT INTO "addresses" (address1) VALUES ("Billing Address - Address 1");
//// INSERT INTO "addresses" (address1) VALUES ("Shipping Address - Address 1");
//// INSERT INTO "users" (name,billing_address_id,shipping_address_id) VALUES ("jinzhu", 1, 2);
//// INSERT INTO "emails" (user_id,email) VALUES (111, "jinzhu@example.com");
//// INSERT INTO "emails" (user_id,email) VALUES (111, "jinzhu-2@example.com");
//// INSERT INTO "languages" ("name") VALUES ('ZH');
//// INSERT INTO user_languages ("user_id","language_id") VALUES (111, 1);
//// INSERT INTO "languages" ("name") VALUES ('EN');
//// INSERT INTO user_languages ("user_id","language_id") VALUES (111, 2);
//// COMMIT;

db.Save(&user)

关闭自动更新

如果你的关联记录已经存在在数据库中，你可能会不想去更新它。

你可以设置 gorm:association_autoupdate 为 false

// 不更新有主键的关联，但会更新引用
db.Set("gorm:association_autoupdate", false).Create(&user)
db.Set("gorm:association_autoupdate", false).Save(&user)
或者使用 GORM 的标签， gorm:"association_autoupdate:false"

type User struct {
  gorm.Model
  Name       string
  CompanyID  uint
  // 不更新有主键的关联，但会更新引用
  Company    Company `gorm:"association_autoupdate:false"`
}

关闭自动创建

即使你禁用了 AutoUpdating, 仍然会创建没有主键的关联，并保存它的引用。

你可以通过把 gorm:association_autocreate 设置为 false 来禁用这个行为。

// 不创建没有主键的关联，不保存它的引用。
db.Set("gorm:association_autocreate", false).Create(&user)
db.Set("gorm:association_autocreate", false).Save(&user)
或者使用 GORM 标签， gorm:"association_autocreate:false"

type User struct {
  gorm.Model
  Name       string
  // 不创建没有主键的关联，不保存它的引用。
  Company1   Company `gorm:"association_autocreate:false"`
}

关闭自动创建/更新

禁用 AutoCreate 和 AutoUpdate，你可以一起使用它们两个的设置。

db.Set("gorm:association_autoupdate", false).Set("gorm:association_autocreate", false).Create(&user)

type User struct {
  gorm.Model
  Name    string
  Company Company `gorm:"association_autoupdate:false;association_autocreate:false"`
}

或者使用 gorm:save_associations

db.Set("gorm:save_associations", false).Create(&user)
db.Set("gorm:save_associations", false).Save(&user)

type User struct {
  gorm.Model
  Name    string
  Company Company `gorm:"association_autoupdate:false"`
}

关闭保存引用

如果你不想当更新或保存数据的时候保存关联的引用，你可以使用下面的技巧

db.Set("gorm:association_save_reference", false).Save(&user)
db.Set("gorm:association_save_reference", false).Create(&user)
或者使用标签

type User struct {
  gorm.Model
  Name       string
  CompanyID  uint
  Company    Company `gorm:"association_save_reference:false"`
}

关联模式

关联模式包含一些可以轻松处理与关系相关的事情的辅助方法。

// 开启关联模式
var user User
db.Model(&user).Association("Languages")
// `user` 是源表，必须包含主键
// `Languages` 是源表关系字段名称。
// 只有上面两个条件都能匹配，关联模式才会生效， 检查是否正常：
// db.Model(&user).Association("Languages").Error

查找关联

查找匹配的关联

db.Model(&user).Association("Languages").Find(&languages)

增加关联

为 many to many， has many 新增关联，为 has one, belongs to 替换当前关联

db.Model(&user).Association("Languages").Append([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Append(Language{Name: "DE"})

替换关联

用一个新的关联替换当前关联

db.Model(&user).Association("Languages").Replace([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Replace(Language{Name: "DE"}, languageEN)

删除关联

删除源和参数对象之间的关系，只会删除引用，不会删除他们在数据库中的对象。

db.Model(&user).Association("Languages").Delete([]Language{languageZH, languageEN})
db.Model(&user).Association("Languages").Delete(languageZH, languageEN)

清理关联

删除源和当前关联之间的引用，不会删除他们的关联

db.Model(&user).Association("Languages").Clear()

统计关联
返回当前关联的统计数

db.Model(&user).Association("Languages").Count()

预加载

db.Preload("Orders").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4);

db.Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4) AND state NOT IN ('cancelled');

db.Where("state = ?", "active").Preload("Orders", "state NOT IN (?)", "cancelled").Find(&users)
//// SELECT * FROM users WHERE state = 'active';
//// SELECT * FROM orders WHERE user_id IN (1,2) AND state NOT IN ('cancelled');

db.Preload("Orders").Preload("Profile").Preload("Role").Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4); // has many
//// SELECT * FROM profiles WHERE user_id IN (1,2,3,4); // has one
//// SELECT * FROM roles WHERE id IN (4,5,6); // belongs to

自动预加载

始终自动预加载的关联

type User struct {
  gorm.Model
  Name       string
  CompanyID  uint
  Company    Company `gorm:"PRELOAD:false"` //没有预加载
  Role       Role                           // 已经预加载
}

db.Set("gorm:auto_preload", true).Find(&users)

嵌套预加载

db.Preload("Orders.OrderItems").Find(&users)
db.Preload("Orders", "state = ?", "paid").Preload("Orders.OrderItems").Find(&users)

自定义预加载 SQL

您可以通过传入func（db * gorm.DB）* gorm.DB来自定义预加载SQL，例如：

db.Preload("Orders", func(db *gorm.DB) *gorm.DB {
    return db.Order("orders.amount DESC")
}).Find(&users)
//// SELECT * FROM users;
//// SELECT * FROM orders WHERE user_id IN (1,2,3,4) order by orders.amount DESC;