Golang GORM系列：定义GORM模型及关系指南

发布于：2025-02-11 ⋅ 阅读:(28) ⋅ 点赞:(0)

使用GORM进行数据库管理的核心是定义模型的技能。模型是程序的面向对象结构和数据库的关系世界之间的纽带。本文深入研究了在GORM中创建成功模型的艺术，研究了如何设计结构化的Go结构，用标记注释字段，以及开发跨模型的链接，以便最大限度地发挥应用程序数据库交互的潜力。

在这里插入图片描述

在GORM中创建结构模型

良好定义的结构模型是基于gorm的应用程序的大脑。结构模型中的每个字段对应于数据库表中的一列，该列由结构模型表示。结构模型是这样制作的：

package models

import (
    "gorm.io/gorm"
)

type User struct {
    gorm.Model
    Name  string
    Email string `gorm:"uniqueIndex"`
    Age   int
}

上面示例中, User struct 模型定义数据库表的列： ID, CreatedAt, UpdatedAt, DeletedAt, Name, Email, Age.

为字段映射添加标签

GORM依赖于结构体标记将结构体字段映射到数据库列。标签提供指导GORM进行数据库操作的元数据。常见标签包括：

  • gorm:"primaryKey": 标记字段为 primary key.
  • gorm:"uniqueIndex": 定义字段为唯一索引.
  • gorm:"not null": 标记字段不能为空.
  • gorm:"column:custom_name": 映射字段为自定义的名称.
type Product struct {
    gorm.Model
    Name     string
    Price    float64
    Category string `gorm:"column:item_category"`
}

在这个例子中，“Category”字段被映射到“item_category”列。

模型关联和关系

GORM擅长对表之间的复杂关系进行建模。关联定义了不同的模型如何相互关联，使您能够轻松地获取相关数据。

一对一的关系:

type User struct {
    gorm.Model
    Profile Profile
}

type Profile struct {
    gorm.Model
    UserID  uint
    Address string
}

在这个例子中，一个“User”对应一个“Profile”。‘ Profile ’结构中的‘ UserID ’字段用作外键。

一对多的关系:

type User struct {
    gorm.Model
    Orders []Order
}

type Order struct {
    gorm.Model
    UserID  uint
    Product string
}

在这里，一个“User”可以有多个“Order”，每个订单都通过“UserID”外键与用户相关联。

多对多关系:

// User 定义用户模型
type User struct {
    gorm.Model
    Name  string
    Roles []Role `gorm:"many2many:user_roles;"`
}
// Role 定义角色模型
type Role struct {
    gorm.Model
    Name  string
    Users []User `gorm:"many2many:user_roles;"`
}

这个例子演示了“User”和“Role”模型之间的多对多关系。GORM处理中间表user_roles的创建。

在查询中使用关联

关联简化了对相关数据的查询。例如，获取用户的订单：

var user User
db.Preload("Orders").Find(&user, 1)

‘ Preload ’方法在查询结果中急切地加载用户的订单。

完整示例

多对多关系表示一个实体的多个实例可以关联到另一个实体的多个实例。在用户和角色的场景中，一个用户可以拥有多个角色，一个角色也可以被多个用户拥有。在数据库层面，通常需要一个中间表来维护这种关系。

1. 项目初始化

首先，确保你已经安装了 Go 和 GORM 库。可以使用以下命令初始化一个新的 Go 模块并安装 GORM：

go mod init example.com/user-role
go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite
2. 代码实现
package main

import (
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

// User 定义用户模型
type User struct {
    gorm.Model
    Name  string
    Roles []Role `gorm:"many2many:user_roles;"`
}

// Role 定义角色模型
type Role struct {
    gorm.Model
    Name  string
    Users []User `gorm:"many2many:user_roles;"`
}

func main() {
    // 连接数据库
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    // 自动迁移模型
    db.AutoMigrate(&User{}, &Role{})

    // 创建角色
    adminRole := Role{Name: "Admin"}
    userRole := Role{Name: "User"}
    db.Create(&adminRole)
    db.Create(&userRole)

    // 创建用户
    user1 := User{Name: "Alice", Roles: []Role{adminRole, userRole}}
    user2 := User{Name: "Bob", Roles: []Role{userRole}}
    db.Create(&user1)
    db.Create(&user2)

    // 查询用户及其角色
    var users []User
    db.Preload("Roles").Find(&users)
    for _, user := range users {
        printUserWithRoles(user)
    }
}

// printUserWithRoles 打印用户及其角色信息
func printUserWithRoles(user User) {
    print("User: ", user.Name, ", Roles: ")
    for _, role := range user.Roles {
        print(role.Name, " ")
    }
    println()
}
3. 代码解释
  • 模型定义：
    • User 结构体和 Role 结构体分别表示用户和角色模型。每个结构体都嵌入了 gorm.Model，这是 GORM 提供的基础模型，包含 ID、CreatedAt、UpdatedAt 和 DeletedAt 字段。
    • Roles 字段在 User 结构体中，Users 字段在 Role 结构体中，它们通过 gorm:"many2many:user_roles;" 标签指定了多对多关系，中间表名为 user_roles。
  • 数据库操作：
    • 使用 gorm.Open 方法连接到 SQLite 数据库。
    • db.AutoMigrate 方法用于自动创建数据库表结构。
    • 创建角色和用户，并将角色关联到用户。
    • 使用 db.Preload("Roles").Find(&users) 方法查询用户及其关联的角色。Preload("Roles")：这是 GORM 提供的预加载功能。预加载的目的是在查询主模型（这里是 User 模型）的同时，也将关联的模型（这里是 Role 模型）的数据一起查询出来，避免了 N + 1 查询问题。具体来说，Preload("Roles") 告诉 GORM 在查询用户时，同时查询每个用户关联的角色，并将这些角色数据填充到 User 结构体的 Roles 字段中。
  • 打印信息：
    • printUserWithRoles 函数用于打印用户及其角色的信息。
4. 运行代码

将上述代码保存为 main.go，然后在终端中运行：

go run main.go

运行后，你将看到输出的用户及其角色信息，这表明多对多关系已经成功建立和查询。

5. 关联表增加额外字段

当需要给中间表 user_roles 增加额外字段（如 status）时，就不能单纯依靠 GORM 的 many2many 标签来处理多对多关系了，而是要手动定义中间表的模型，然后通过 has many 和 belongs to 关系来建立用户、角色和中间表之间的关联。以下是修改后的完整示例：

package main

import (
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

// User 定义用户模型
type User struct {
    gorm.Model
    Name       string
    UserRoles  []UserRole
    Roles      []Role `gorm:"many2many:user_roles;foreignKey:ID;joinForeignKey:UserID;References:ID;joinReferences:RoleID"`
}

// Role 定义角色模型
type Role struct {
    gorm.Model
    Name       string
    UserRoles  []UserRole
    Users      []User `gorm:"many2many:user_roles;foreignKey:ID;joinForeignKey:RoleID;References:ID;joinReferences:UserID"`
}

// UserRole 定义中间表模型
type UserRole struct {
    gorm.Model
    UserID uint
    RoleID uint
    Status string // 新增的额外字段
}

func main() {
    // 连接数据库
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    // 自动迁移模型
    db.AutoMigrate(&User{}, &Role{}, &UserRole{})

    // 创建角色
    adminRole := Role{Name: "Admin"}
    userRole := Role{Name: "User"}
    db.Create(&adminRole)
    db.Create(&userRole)

    // 创建用户
    user1 := User{Name: "Alice"}
    db.Create(&user1)

    // 关联用户和角色，并设置中间表的额外字段
    userRole1 := UserRole{
        UserID: user1.ID,
        RoleID: adminRole.ID,
        Status: "Active",
    }
    userRole2 := UserRole{
        UserID: user1.ID,
        RoleID: userRole.ID,
        Status: "Inactive",
    }
    db.Create(&userRole1)
    db.Create(&userRole2)

    // 查询用户及其角色
    var users []User
    db.Preload("UserRoles.Role").Find(&users)
    for _, user := range users {
        printUserWithRoles(user)
    }
}

// printUserWithRoles 打印用户及其角色信息
func printUserWithRoles(user User) {
    print("User: ", user.Name, ", Roles: ")
    for _, userRole := range user.UserRoles {
        print(userRole.Role.Name, " (Status: ", userRole.Status, ") ")
    }
    println()
}
  • UserRole 结构体：这是手动定义的中间表模型，包含 UserID 和 RoleID 用于关联用户和角色，还新增了 Status 字段作为额外字段。
  • 关联用户和角色并设置额外字段：通过创建 UserRole 实例并设置 UserID、RoleID 和 Status 字段，然后将其保存到数据库，完成用户和角色的关联并设置中间表的额外信息。

最后总结

在应用程序中高效管理数据库的关键是在GORM中定义模型。通过创建模型之间的关系、用相关标记注释字段以及构建有组织的结构模型，你为平滑的数据库交互构建了坚实的基础。GORM中的一对一、一对多和多对多关系处理使您能够轻松地为复杂的数据情况建模。结构良好的基础会产生可伸缩和可维护的应用程序，使你的数据库管理之旅变得简单而富有成效。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布