AI 助理
备案控制台
开发者社区 数据库 文章 正文

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

2024-06-19 57
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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的学习就告一段落了，大家下篇文章见，拜拜！

文章标签：
Go
数据库
关键词：
Go语言
Go数据类型
Go框架
Go事务
Go gorm
落雨便归尘
目录
相关文章
听风de歌
|
1天前
|
Ubuntu 编译器 Linux
go语言中SQLite3驱动安装
【11月更文挑战第2天】
听风de歌
16 7
听风de歌
|
1天前
|
关系型数据库 Go 网络安全
go语言中PostgreSQL驱动安装
【11月更文挑战第2天】
听风de歌
15 5
叫个什么名字
|
1天前
|
存储 设计模式 安全
Go语言中的并发编程：从入门到精通###
本文深入探讨了Go语言中并发编程的核心概念与实践技巧，旨在帮助读者从理论到实战全面掌握Go的并发机制。不同于传统的技术文章摘要，本部分将通过一系列生动的案例和代码示例，直观展示Go语言如何优雅地处理并发任务，提升程序性能与响应速度。无论你是Go语言初学者还是有一定经验的开发者，都能在本文中找到实用的知识与灵感。 ###
叫个什么名字
14 3
左诗右码
|
1天前
|
安全 Go
用 Zap 轻松搞定 Go 语言中的结构化日志
在现代应用程序开发中，日志记录至关重要。Go 语言中有许多日志库，而 Zap 因其高性能和灵活性脱颖而出。本文详细介绍如何在 Go 项目中使用 Zap 进行结构化日志记录，并展示如何定制日志输出，满足生产环境需求。通过基础示例、SugaredLogger 的便捷使用以及自定义日志配置，帮助你在实际开发中高效管理日志。
左诗右码
9 1
叫个什么名字
|
2天前
|
JavaScript Java Go
探索Go语言在微服务架构中的优势
在微服务架构的浪潮中，Go语言以其简洁、高效和并发处理能力脱颖而出。本文将深入探讨Go语言在构建微服务时的性能优势，包括其在内存管理、网络编程、并发模型以及工具链支持方面的特点。通过对比其他流行语言，我们将揭示Go语言如何成为微服务架构中的一股清流。
叫个什么名字
76 53
vohelon
|
7天前
|
网络协议 安全 Go
Go语言进行网络编程可以通过**使用TCP/IP协议栈、并发模型、HTTP协议等**方式
【10月更文挑战第28天】Go语言进行网络编程可以通过**使用TCP/IP协议栈、并发模型、HTTP协议等**方式
vohelon
33 13
听风de歌
|
1天前
|
SQL 关系型数据库 MySQL
go语言数据库中mysql驱动安装
【11月更文挑战第2天】
听风de歌
13 4
听风de歌
|
2天前
|
SQL 关系型数据库 MySQL
go语言中安装数据库驱动
【11月更文挑战第1天】
听风de歌
16 5
听风de歌
|
2天前
|
编译器 Go 开发者
go语言中导入相关包
【11月更文挑战第1天】
听风de歌
11 3
听风de歌
|
3天前
|
测试技术 Go
go语言中测试工具
【10月更文挑战第22天】
听风de歌
14 4

热门文章

最新文章

  • 1
    go语言多态接口样例
  • 2
    Go语言之基准测试
  • 3
    go语言方法实例
  • 4
    golang开发:类库篇(四)配置文件解析器goconfig的使用
  • 5
    go8---函数function
  • 6
    基于类型系统的面向对象编程语言Go
  • 7
    go并发访问map的坑 fatal error: concurrent map read and map write
  • 8
    Grumpy：Google 用 Go 开发的 Python 运行时
  • 9
    Go语言之函数详解
  • 10
    Go语言之反射
  • 1
    Go语言：多重返回值的神奇之处
    114
  • 2
    什么是协程（Goroutine）？探索Go语言并发的奇妙世界
    81
  • 3
    Go语言中如何判断map中是否包含某个key？
    791
  • 4
    Go语言中tag的用处及详细介绍
    199
  • 5
    Go语言中的int和int32：同一个概念吗？
    556
  • 6
    Go语言的接口比较：两个interface能否比较？
    488
  • 7
    Go语言GC(垃圾回收)的工作原理
    151
  • 8
    Go语言协程泄漏(Goroutine Leak)：原因和解决方案
    531
  • 9
    Go面向对象是如何实现的？
    85
  • 10
    Go中的GMP状态详解
    120

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • Python语言基础 - 函数、面向对象、异常处理

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 对象和接口-2：常见用法
  • 使用交互方式创建数据表
  • 使用Java面向对象编写网络通信程序应用
    • 下一篇
    DataWorks售前咨询