Go语言之GORM框架(四)——预加载，关联标签与多态关联，自定义数据类型与事务(完结篇)

前言

本来是想着写多表关系的，不过写了一半发现重复的部分太多了，想了想与其做一些重复性工作，不如把一些当时觉得抽象的东西记录一下，就当用一篇杂记完成专栏的最后一篇文章吧。

预加载

简单示例

预加载主要用于在多表关系中加载关联表的信息，在讲解预加载的类型之前我们先来看一个预加载的示例：

• 相关表结构

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

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

我们尝试往里面插入数据：

// 创建语言对象
	languages := []Language{
		{Name: "Golang"},
		{Name: "Python"},
		{Name: "Java"},
	}

	// 创建用户对象
	users := []User{
		{Name: "Alice", Languages: []Language{languages[0], languages[1]}},   // Alice 会说 Golang 和 Python
		{Name: "Bob", Languages: []Language{languages[1], languages[2]}},     // Bob 会说 Python 和 Java
		{Name: "Charlie", Languages: []Language{languages[0], languages[2]}}, // Charlie 会说 Golang 和 Java
	}

	// 将语言和用户数据插入到数据库中
	for _, lang := range languages {
		db.Create(&lang)
	}

	for _, user := range users {
		db.Create(&user)
	}

然后我们尝试利用预加载来查询：

users := []User{}
	db.Preload("Languages").Find(&users)
	fmt.Println(users)

这样我们不仅能搜寻到user，还能把user相关联的Languages打印出来，像这样：

Joins预加载

Joins预加载会使用left join加载关联数据，与其说是预加载其实更像一个关联查询，常用与ONE TO ONE或Belongs To的多表关系中：

• 表结构：

type Student struct {
	ID   uint        `gorm:"size:8"`
	Name string      `gorm:"size:20"`
	Info StudentInfo `gorm:"foreignKey:StudentID"` // 明确指定关联关系
}

type StudentInfo struct {
	ID        uint `gorm:"size:8"`
	Age       int  `gorm:"size:4"`
	Sex       bool `gorm:"size:4"`
	Email     *string
	StudentID uint `gorm:"size:8"`
}

• 示例：

	var student Student
	db.Joins("Info").Take(&student)
	db.Joins("Info", db.Where("Info.Age = ?", 18)) //带条件的Joins
	fmt.Println(student)

条件预加载

	var student Student
	db.Where("age > ?", 18).Preload("Info").First(&student)  //方式一
	db.Preload("Info", "age > ?", 18).Find(&student)   //方式二
	fmt.Println(student)

自定义预加载

	var student Student
	db.Preload("Info", func(db *gorm.DB) *gorm.DB{
		return db.Where("age > ?", 18)
	}).Find(&student)
	fmt.Println(student)

嵌套预加载

这里我们来看一下官方给的示例：

// Customize Preload conditions for `Orders`
// And GORM won't preload unmatched order's OrderItems then
db.Preload("Orders", "state = ?", "paid").Preload("Orders.OrderItems").Find(&users)

这段代码的意思是，在加载用户信息时，只预加载订单状态为 “paid” 的订单数据，并且同时预加载这些订单的订单项信息。这样做可以确保在查询用户数据时，只加载特定状态的订单及其订单项数据，而不会加载其他状态的订单信息。

#关联标签与多态关联

多态关联

关于多态关联我们先来看一个实例：

package main

import (
	"gorm.io/gorm"
	"gorm/ConnectDB"
)

type Boy struct {
	gorm.Model
	Name string
	Toys []Toy `gorm:"polymorphic:Owner"`
}

type Girl struct {
	gorm.Model
	Name string
	Toys []Toy `gorm:"polymorphic:Owner"`
}

type Toy struct {
	gorm.Model
	Name      string
	OwnerID   uint
	OwnerType string
}

func main() {
	db, err := ConnectDB.Connect()
	if err != nil {
		panic(err)
	}

	err = db.AutoMigrate(&Boy{}, &Girl{}, &Toy{})
	if err != nil {
		panic(err)
	}

	db.Create(&Boy{
		Name: "张三",
		Toys: []Toy{
			{Name: "玩具1"},
			{Name: "玩具2"},
		},
	})

	db.Create(&Girl{
		Name: "三玖",
		Toys: []Toy{
			{Name: "玩具3"},
			{Name: "玩具4"},
		},
	})
}

它创建出来的表：

我们可以看到在toys表中我们仅仅用owner_type与owner_id就完成了对boys与gils表的区分，避免了不必要的麻烦

补充：
可以使用标签 polymorphicValue 来更改多态类型的值，像下面这样：

type Boy struct {
	gorm.Model
	Name string
	Toys []Toy `gorm:"polymorphic:Owner;polymorphicValue:bbbb"`
}

type Girl struct {
	gorm.Model
	Name string
	Toys []Toy `gorm:"polymorphic:Owner;polymorphicValue:gggg"`
}

type Toy struct {
	gorm.Model
	Name      string
	OwnerID   uint
	OwnerType string
}

创建出来的表：

关联标签

前言

关联标签这里我们主要介绍四个：

• foreignKey:
• references :
• joinForeignKey
• joinReferences

foreignKey与references

这里我们用一对多的多表关系来解释

type Boy struct {
	gorm.Model
	Name string
	Toys []Toy `gorm:"polymorphic:Owner;foreign:Name;references:BoyName"`
}

type Toy struct {
	gorm.Model
	ToyName   string
	BoyName   string
	OwnerID   uint
	OwnerType string
}

如上面所示：
foreignKey：用来指定连接表的外键。
references：用来指定引用表的列名与连接表的外键映射。

joinForeignKey与joinReferences

joinForeignKey：指定Many to Many产生的连接表中关联外键映射字段的名称。
joinReferences：指定Many to Many产生的连接表中关联外键字段的名称。

这里的演示我们用多对多的多表关系来演示：

package main

import (
	"gorm.io/gorm"
	"gorm/ConnectDB"
)

type Girl struct {
	gorm.Model
	ToyName string
	Name    string
	Toys    []Toy `gorm:"many2many:girls_toys;foreign:ToyName;joinForeignKey:a;joinReferences:b"`
}

type Toy struct {
	gorm.Model
	ToyName string
}

func main() {
	db, err := ConnectDB.Connect()
	if err != nil {
		panic(err)
	}

	err = db.AutoMigrate(&Girl{}, &Toy{})
	if err != nil {
		panic(err)
	}

	db.Create(&Girl{
		Name: "三玖",
		Toys: []Toy{
			{ToyName: "玩具3"},
			{ToyName: "玩具4"},
		},
	})
}

它创建出来的连接表是这样的：

用通俗的方式来说，其实它们的作用就是决定了连接表的列名。

自定义数据类型

前言

在GORM中允许我们去使用自定义的数据类型，但是我们必须要实现Scanner与Value接口，以便让GORM知道如何接收并保存该类型到数据库中。

自定义结构体

package main

import (
	"database/sql/driver"
	"encoding/json"
	"errors"
	"fmt"
	"gorm/ConnectDB"
)

type User struct {
	ID   uint
	Info UserInfo
}

type UserInfo struct {
	Name string
	Age  int
}

func (u *UserInfo) Scan(value interface{}) error {
	bytes, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprintf("Scan failed: %v", value))
	}
	info := UserInfo{}
	err := json.Unmarshal(bytes, &info)
	*u = info
	return err
}

func (u UserInfo) Value() (driver.Value, error) {
	return json.Marshal(u)
}

func main() {
	db, err := ConnectDB.Connect()
	if err != nil {
		fmt.Println("数据库连接失败,err:", err)
		return
	}

	err = db.AutoMigrate(&User{})
	if err != nil {
		fmt.Println("表创建失败,err:", err)
		return
	}

	user := User{
		Info: UserInfo{
			Name: "张三",
			Age:  18,
		},
	}
	db.Create(&user)

	db.First(&user)
	fmt.Println(user)
}

自定义数组

func (a *Args) Scan(value interface{}) error {
	str, ok := value.([]byte)
	if !ok {
		return errors.New(fmt.Sprintf("Scan failed: %v", value))
	}
	*a = strings.Split(string(str), ",")
	return nil
}

func (a Args) Value() (driver.Value, error) {
	if len(a) > 0 {
		var str string
		str = a[0]
		for i := 1; i < len(a); i++ {
			str += "," + a[i]
		}
		return str, nil
	}
	return "", nil
}

事务

前言

事务就是用户定义的一系列数据库操作，这些操作可以视为一个完成的逻辑处理工作单元，要么全部执行，要么全部不执行，是不可分割的工作单元。很形象的一个例子，张三给李四转账100元，在程序里面，张三的余额就要-100，李四的余额就要+100 整个事件是一个整体，哪一步错了，整个事件都是失败的
gorm事务默认是开启的。为了确保数据一致性，GORM 会在事务里执行写入操作（创建、更新、删除）。如果没有这方面的要求，我们可以在初始化时禁用它，这将获得大约 30%+ 性能提升。但是一般不推荐禁用。

相关表结构

我们这里相关表结构

type User struct {
  ID    uint   `json:"id"`
  Name  string `json:"name"`
  Money int    `json:"money"`
}

事务的使用

现在有一个场景：，张三给李四转账100元，在程序里面，张三的余额就要-100，李四的余额就要+100

如果不使用事务，是这样的：

var zhangsan, lisi User
DB.Take(&zhangsan, "name = ?", "张三")
DB.Take(&lisi, "name = ?", "李四")

// 先给张三-100
zhangsan.Money -= 100
DB.Model(&zhangsan).Update("money", zhangsan.Money)

// 再给李四+100
lisi.Money += 100
DB.Model(&lisi).Update("money", lisi.Money)

在失败的情况下，要么张三白白损失了100，要么李四凭空拿到100元这显然是不合逻辑的，并且不合法的，而这就需要我们来使用事务了，事务一共分为两种：

• 自动事务
• 手动事务

我们分别来看一下它们的写法:

• 自动事务：

var zhangsan, lisi User
DB.Take(&zhangsan, "name = ?", "张三")
DB.Take(&lisi, "name = ?", "李四")
// 张三给李四转账100元
DB.Transaction(func(tx *gorm.DB) error {

  // 先给张三-100
  zhangsan.Money -= 100
  err := tx.Model(&zhangsan).Update("money", zhangsan.Money).Error
  if err != nil {
    fmt.Println(err)
    return err
  }

  // 再给李四+100
  lisi.Money += 100
  err = tx.Model(&lisi).Update("money", lisi.Money).Error
  if err != nil {
    fmt.Println(err)
    return err
  }
  // 提交事务
  return nil
})

• 手动事务：

  • 执行流程：

  //开始事务
  tx := db.Begin()
  
  // 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'）
  tx.Create(...)
  
  // ...
  
  // 遇到错误时回滚事务
  tx.Rollback()
  
  // 否则，提交事务
  tx.Commit()
  

var zhangsan, lisi User
DB.Take(&zhangsan, "name = ?", "张三")
DB.Take(&lisi, "name = ?", "李四")

// 张三给李四转账100元
tx := DB.Begin()

// 先给张三-100
zhangsan.Money -= 100
err := tx.Model(&zhangsan).Update("money", zhangsan.Money).Error
if err != nil {
  tx.Rollback()
}

// 再给李四+100
lisi.Money += 100
err = tx.Model(&lisi).Update("money", lisi.Money).Error
if err != nil {
  tx.Rollback()
}
// 提交事务
tx.Commit()

结语

至此，GORM的学习就告一段落了，大家下篇文章见，拜拜！