Go语言之GORM框架(三)——Hook(钩子)与Gorm的高级查询

于 2024-05-28 00:41:49 发布
阅读量728 收藏 6
点赞数 4
分类专栏： Gorm 文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73924465/article/details/139248915
版权

Hook(钩子)

和我们在gin框架中讲解的Hook函数一样，我们也可以在定义Hook结构体，完成一些操作，相关接口声明如下：

type CreateUser interface {    //创建对象时使用的Hook
	BeforeCreate() error
	BeforeSave() error
	AfterCreate() error
	AfterSave() error
}


type UpdateUser interface {
	BeforeUpdate() error
	BeforeSave() error
	AfterUpdate() error
	AfterSave() error
}

type DeleteUser interface {
	BeforeDelete() error
	AfterDelete() error
}

type FindUser interface {
	AfterFind() error
}

我们可以根据自己的需求来订制我们所需要的Hook函数，示例：

func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
  u.UUID = uuid.New()

  if !u.IsValid() {
    err = errors.New("can't save invalid data")
  }
  return
}

func (u *User) AfterCreate(tx *gorm.DB) (err error) {
  if u.ID == 1 {
    tx.Model(u).Update("role", "admin")
  }
  return
}

注意：

  • Hook函数在执行过程的执行时间有规定的时间，以创建对象的Hook为例：
// 开始事务
BeforeSave
BeforeCreate
// 关联前的 save
// 插入记录至 db
// 关联后的 save
AfterCreate
AfterSave
// 提交或回滚事务

具体可以参考官方文档：
Hook

  • 在 GORM 中保存、删除操作会默认运行在事务上， 因此在事务完成之前该事务中所作的更改是不可见的，如果Hook返回了任何错误，则修改将被回滚。

高级查询

初始化相关表

package main

import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	"log"
	"os"
	"time"
)

type Employee struct {
	ID    uint    `gorm:"size:3"`
	Name  string  `gorm:"size:8"`
	Age   int     `gorm:"size:3"`
	Sex   bool    `gorm:"size:3"`
	Email *string `gorm:"size:32"`
}

var myDB *gorm.DB

func init() {
	//连接数据库
	user := "root"
	password := "ba161754"
	dbname := "gorm"
	ip := "127.0.0.1"
	port := "3306"
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", user, password, ip, port, dbname)
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println("数据库连接失败,err:", err)
		return
	}
	fmt.Println("数据库连接成功")
	myDB = db

	//初始化日志
	var mysqlLogger logger.Interface
	mysqlLogger = logger.Default.LogMode(logger.Info) //设置日志打印级别
	mysqlLogger = logger.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // （日志输出的目标，前缀和日志包含的内容）
		logger.Config{
			SlowThreshold:             time.Second, // 慢 SQL 阈值
			LogLevel:                  logger.Info, // 日志级别
			IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
			Colorful:                  true,        // 使用彩色打印
		},
	)
	myDB.Logger = mysqlLogger

	//创建所要使用的单表
	err = myDB.AutoMigrate(&Employee{})
	if err != nil {
		fmt.Println("创建表失败,err:", err)
		return
	}

	//插入测试数据
	employeeList := []Employee{
		{ID: 1, Name: "李元芳", Age: 32, Email: PtrString("lyf@yf.com"), Sex: true},
		{ID: 2, Name: "张武", Age: 18, Email: PtrString("zhangwu@lly.cn"), Sex: true},
		{ID: 3, Name: "枫枫", Age: 23, Email: PtrString("ff@yahoo.com"), Sex: true},
		{ID: 4, Name: "刘大", Age: 54, Email: PtrString("liuda@qq.com"), Sex: true},
		{ID: 5, Name: "李武", Age: 23, Email: PtrString("liwu@lly.cn"), Sex: true},
		{ID: 6, Name: "李琦", Age: 14, Email: PtrString("liqi@lly.cn"), Sex: false},
		{ID: 7, Name: "晓梅", Age: 25, Email: PtrString("xiaomeo@sl.com"), Sex: false},
		{ID: 8, Name: "如燕", Age: 26, Email: PtrString("ruyan@yf.com"), Sex: false},
		{ID: 9, Name: "魔灵", Age: 21, Email: PtrString("moling@sl.com"), Sex: true},
	}
	myDB.Create(&employeeList)
}

func PtrString(email string) *string {
	return &email
}

func main() {

}

Where查询

  • 简单示例：
	var employee Employee

	//Where
	myDB.Where("name like ?", "李%").Find(&employee) //查询姓李的
	fmt.Println(employee)
  • Not条件
	myDB.Not("name like ?", "李%").Find(&employee) //查询第一条不是姓李的
	fmt.Println(employee)
  • Or条件
	var employeeList []Employee
	myDB.Not("name like ?", "李%").Or("age>20").Find(&employeeList)  //用Where表示and
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}
  • And条件
	employeeList=[]Employee{}
	myDB.Not("name like ?", "李%").Where("age>20").Find(&employeeList)  //用Where表示and
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

select选择字段

  • 简单示例
	employeeList := []Employee{}
	myDB.Select("name", "age").Find(&employeeList)
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}
  • Scan函数
    我们可以用Scan函数将搜索结果导入带新的结构体中
type Employee1 struct {
	Name string
	Age  int
}

	//select
	employeeList := []Employee{}
	employeeList1 := []Employee1{}
	myDB.Select("name", "age").Find(&employeeList).Scan(&employeeList1)
	for _, value := range employeeList1 {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

输出为：
在这里插入图片描述

排序

	//排序
	employeeList := []Employee{}
	myDB.Order("age desc").Find(&employeeList)
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

分页查询

	//分页
	employeeList := []Employee{}
	myDB.Limit(4).Offset(0).Order("age desc").Find(&employeeList) //Limit:每页限定记录数，offset:偏移量
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

去重

	//去重
	var agelist []int
	myDB.Table("employees").Select("distinct age").Find(&agelist)
	for _, value := range agelist {
		fmt.Println(value)
	}

分组查询

	//分组查询
	var ageList []int
	// 查询男生的个数和女生的个数
	myDB.Table("employees").Select("count(id)").Group("Sex").Scan(&ageList)
	fmt.Println(ageList)

执行原生sql

	//执行原生sql
	type SexGroup struct {
		Count int `gorm:"column:count(id)"`
		Sex   bool
		Name  string `gorm:"column:group_concat(name)"`
	}
	var sexlist []SexGroup
	myDB.Raw("select count(id) ,sex,group_concat(name) from employees group by sex").Scan(&sexlist)
	for _, value := range sexlist {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}
}

子查询

	//子查询
	//select * from students where age > (select avg(age) from students); 原生sql
	myDB.Where("age > (?)", myDB.Model(&Employee{}).Select("avg(age)")).Find(&employee)
	fmt.Println(employee)

查询调用

我们可以在model层写一些通用的查询方法，让外界直接来调用：

func Age23(db *gorm.DB) *gorm.DB {
	return db.Where("age>?", 23)
}

	myDB.Scopes(Age23).Find(&employee)
	fmt.Println(employee)

完整代码

package main

import (
	"encoding/json"
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	"log"
	"os"
	"time"
)

type Employee struct {
	ID    uint    `gorm:"size:3"`
	Name  string  `gorm:"size:8"`
	Age   int     `gorm:"size:3"`
	Sex   bool    `gorm:"size:3"`
	Email *string `gorm:"size:32"`
}

type Employee1 struct {
	Name string
	Age  int
}

var myDB *gorm.DB

func init() {
	//连接数据库
	user := "root"
	password := "ba161754"
	dbname := "gorm"
	ip := "127.0.0.1"
	port := "3306"
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", user, password, ip, port, dbname)
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		fmt.Println("数据库连接失败,err:", err)
		return
	}
	fmt.Println("数据库连接成功")
	myDB = db

	//初始化日志
	var mysqlLogger logger.Interface
	mysqlLogger = logger.Default.LogMode(logger.Info) //设置日志打印级别
	mysqlLogger = logger.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // （日志输出的目标，前缀和日志包含的内容）
		logger.Config{
			SlowThreshold:             time.Second, // 慢 SQL 阈值
			LogLevel:                  logger.Info, // 日志级别
			IgnoreRecordNotFoundError: true,        // 忽略ErrRecordNotFound（记录未找到）错误
			Colorful:                  true,        // 使用彩色打印
		},
	)
	myDB.Logger = mysqlLogger

	//创建所要使用的单表
	err = myDB.AutoMigrate(&Employee{})
	if err != nil {
		fmt.Println("创建表失败,err:", err)
		return
	}

	//插入测试数据
	employeeList := []Employee{
		{ID: 1, Name: "李元芳", Age: 32, Email: PtrString("lyf@yf.com"), Sex: true},
		{ID: 2, Name: "张武", Age: 18, Email: PtrString("zhangwu@lly.cn"), Sex: true},
		{ID: 3, Name: "枫枫", Age: 23, Email: PtrString("ff@yahoo.com"), Sex: true},
		{ID: 4, Name: "刘大", Age: 54, Email: PtrString("liuda@qq.com"), Sex: true},
		{ID: 5, Name: "李武", Age: 23, Email: PtrString("liwu@lly.cn"), Sex: true},
		{ID: 6, Name: "李琦", Age: 14, Email: PtrString("liqi@lly.cn"), Sex: false},
		{ID: 7, Name: "晓梅", Age: 25, Email: PtrString("xiaomeo@sl.com"), Sex: false},
		{ID: 8, Name: "如燕", Age: 26, Email: PtrString("ruyan@yf.com"), Sex: false},
		{ID: 9, Name: "魔灵", Age: 21, Email: PtrString("moling@sl.com"), Sex: true},
	}
	myDB.Create(&employeeList)
}

func PtrString(email string) *string {
	return &email
}

func Age23(db *gorm.DB) *gorm.DB {
	return db.Where("age>?", 23)
}

func main() {
	employee := Employee{}
	employeeList:=[]Employee{}

	//Where
	myDB.Where("name like ?", "李%").Find(&employee) //查询姓李的
	fmt.Println(employee)
	
	myDB.Not("name like ?", "李%").Find(&employee) //查询第一条不是姓李的
	fmt.Println(employee)
	
	myDB.Not("name like ?", "李%").Or("age>20").Find(&employeeList) //用Where表示and
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}
	
	employeeList = []Employee{}
	myDB.Not("name like ?", "李%").Where("age>20").Find(&employeeList) //用Where表示and
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

	//select
	employeeList = []Employee{}
	employeeList1 := []Employee1{}
	myDB.Select("name", "age").Find(&employeeList).Scan(&employeeList1)
	for _, value := range employeeList1 {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

	//排序
	employeeList = []Employee{}
	myDB.Order("age desc").Find(&employeeList)
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

	//分页
	employeeList = []Employee{}
	myDB.Limit(4).Offset(0).Order("age desc").Find(&employeeList) //Limit:每页限定记录数，offset:偏移量
	for _, value := range employeeList {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

	//去重
	var agelist []int
	myDB.Table("employees").Select("distinct age").Find(&agelist)
	for _, value := range agelist {
		fmt.Println(value)
	}

	//分组查询
	var ageList []int
	// 查询男生的个数和女生的个数
	myDB.Table("employees").Select("count(id)").Group("Sex").Scan(&ageList)
	fmt.Println(ageList)

	//执行原生sql
	type SexGroup struct {
		Count int `gorm:"column:count(id)"`
		Sex   bool
		Name  string `gorm:"column:group_concat(name)"`
	}
	var sexlist []SexGroup
	myDB.Raw("select count(id) ,sex,group_concat(name) from employees group by sex").Scan(&sexlist)
	for _, value := range sexlist {
		data, _ := json.Marshal(value)
		fmt.Println(string(data))
	}

	//子查询
	//select * from students where age > (select avg(age) from students); 原生sql
	myDB.Where("age > (?)", myDB.Model(&Employee{}).Select("avg(age)")).Find(&employee)
	fmt.Println(employee)

	//查询引用Scope
	myDB.Scopes(Age23).Find(&employee)
	fmt.Println(employee)
}
落雨便归尘
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
golang工程组件篇对象关系映射gorm之Hook与Session
SMILY12138的博客
05-30 432
在使用Gorm操作数据库时，我们可能会遇到一些需要在执行某些操作前或后进行一些额外处理的情况。当然，在实际应用中，我们还需要根据具体情况进行灵活使用，并合理处理各种异常情况。在这个例子中，我们定义了一个User结构体，并为其添加了BeforeSave钩子函数。例如，在保存数据之前，我们可能需要对数据进行一些预处理或验证等操作。在这个例子中，我们首先开启了一个事务，然后分别对用户和文章进行了保存操作。Session是指在一个事务中，可以执行多个数据库操作，并且可以回滚整个事务或提交所有修改的机制。
goland gorm分组查询统计_Golang下的ORM框架gorm的介绍和使用
weixin_36081109的博客
12-23 1805
前言:gorm是Golang语言中一款性能极好的ORM库，对开发人员相对是比较友好的。当然还有另外一个xorm库也是比较出名的，感兴趣的也可以看看这个库，接下来主要介绍下gorm库的一些基本使用。GORM介绍和快速入门功能概览全功能ORM(无限接近)关联(Has One, Has Many, Belongs To, Many To Many, 多态)钩子函数Hook(在创建/保存/更新/删除/查找...
简单的钩子函数
01-21
钩子函数的简单使用 代码 入门级别的程序
Gorm框架——钩子
m0_61366135的博客
01-10 892
BeforeSave` 和 `BeforeCreate` 钩子方法用于验证记录和设置创建时间和更新时间。`AfterSave` 和 `AfterCreate` 钩子方法分别在记录保存和创建之后执行一些自定义逻辑。常用的钩子包括 `BeforeSave`、`BeforeCreate`、`AfterSave` 和 `AfterCreate` 等。2. `BeforeCreate`: 该钩子在创建新记录之前被调用。与 `BeforeSave` 相比，它只在新记录创建时才会被调用，而不会在更新现有记录时被调用。
RTMP协议视频平台EasyDSS开发中如何通过Go语言 gorm 框架钩子函数精简代码？
EasyDSS官方技术博客
02-05 298
EasyDSS视频平台除了提供网页直播外，还可上传视频进行点播，上传视频后一键生成视频地址，以供用户分享、嵌入到网站、产品软件系统中。 在EasyDSS开发过程中，将数据写入到数据库时，有大量相同的操作。如以下两个步骤设置更新时间和创建时间。 u.CreateAt = time.Now() u.UpdateAt = time.Now() 因为很多地方需要更新这两个字段，在整个项目中出现了很多相同的代码，都是以上两行代码。因此为了精简代码，优化结构，可以使用gorm 库的hooks钩子函数功能进
Golang Gorm 创建HOOK
小楼一夜听春雨，深巷明朝卖杏花
09-14 618
钩子函数比较简单，就是实现before create的一个方法。创建的时候，在插入数据之前，想要做一些事情。
GORM中钩子的简单使用
qq_43409655的博客
05-23 3792
钩子Hook Hook 是在创建、查询、更新、删除等操作之前、之后调用的函数。 示例 //定义的model type User struct { gorm.Model Username string Password string Role_name string Mobilephone string State bool } //定义的BeforeDelete钩子 func (u *User) BeforeDelete(tx *gorm.DB) (err error
golang ORM框架gorm
ymxyld的博客
05-24 3391
ORM简介 对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库（如mysql数据库）存在的互不匹配的现象的技术。简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。 安装 go get -u gorm.io/gorm 快速入门 package main import ( "gorm.io/gorm" "gorm.io/driver/mysql" ) type Product str
gorm学习
日之朝矣的博客
04-30 1543
从belongs to 后面学的就有点不清不楚了，所以直接复制粘贴了TAT 安装 go get -u gorm.io/gorm go get -u gorm.io/driver/mysql 声明模型 模型为标准的struct，由Go的基本数据类型，实现了Scanner和Value接口的自定义类型及其指针或别名组成 type User struct{ ID uint Name string Email *string Age uint8 Birthday *time.
GORM
____Se7en
03-01 439
GORM Object Relational Mapping （将一个结构体数据类型映射为数据库中的一条数据） 数据表 <-> 结构体 数据行 <-> 结构体实例 字段 <->结构体字段 优点：提高了开发效率 缺点：牺牲执行性能，牺牲灵活性，弱化SQL能力 安装 go get -u github.com/jinzhu/gorm gorm中为不同数据库包装了不同的驱动 mysql : github.com/jinzhu/gorm/dialects/mysql // impo
gohook:GoHook，Go全局键盘和鼠标侦听器挂钩
05-16
勾 package main import ( "fmt" hook "github.com/robotn/gohook" ) func main () { add () low () } func add () { fmt . Println ( "--- Please press ctrl + shift + q to stop hook ---" ) hook . Register ( hook . KeyDown , [] string { "q" , "ctrl" , "shift" }, func ( e hook. Event ) { fmt . Println ( "ctrl-shift-q" ) hook . End () }) fmt . Println ( "--- Please press w---" ) hook . Register
gohooks:GoHooks 使从 Go 应用程序发送和使用安全网络钩子变得容易
05-30
钩子 GoHooks 使从 Go 应用程序发送和使用安全网络钩子变得容易。 SHA-256 签名是用发送的数据加上加密盐创建的，用于在接收时进行验证，有效地使您的应用程序只接受来自受信任方的通信。 安装 将github.com/averageflow/gohooks/v2添加到您的go.mod文件中，然后使用以下命令将其导入到您想要使用该包的位置： import ( "github.com/averageflow/gohooks/v2/gohooks" ) 用法 这里我将列出 GoHooks 的最基本用法。 如果您希望进行更多自定义，请阅读以下部分以获取更多选项。 发送 发送的最基本用法是： // Data can be any type, accepts interface{} data := [] int { 1 , 2 , 3 , 4 } // String se
GORM 创建HOOK 钩子
kingsill的博客
11-24 580
Hook 是在创建、查询、更新、删除等操作之前、之后调用的函数。如果您已经为模型定义了指定的方法，它会在创建、更新、查询、删除时自动被调用。如果任何回调返回错误，GORM 将停止后续的操作并回滚事务。钩子方法的函数签名应该是可以看到在创建记录时的email为BeforeCreate中设置的。
钩子函数是什么？
热门推荐
smallsun
08-25 2万+
什么是钩子函数？ 先来看一段百科：钩子函数是Windows消息处理机制的一部分，通过设置“钩子”，应用程序可以在系统级对所有消息、事件进行过滤，访问在正常情况下无法访问的消息。钩子的本质是一段用以处理系统消息的程序，通过系统调用，把它挂入系统。 emmmm，认认真真读三遍。get关键词，在系统级对所有消息进行过滤，这是什么意思呢？是说钩子函数是在一个事件触发的时候，在系统级捕获到了他，然后做一...
Go钩子函数示例
最新发布
fsdfasdfasfas的博客
05-25 174
同时想支持And或Or（Hook）对过滤条件进行再筛选。以及两个自定义Hook。
Gorm 中的钩子和回调
csjds的专栏
11-08 671
在数据库管理领域，定制化是打造高效和定制化工作流程的关键。GORM，这个充满活力的 Go 对象关系映射库，为开发人员提供了钩子和回调的功能，提供了一种在数据库交互过程的各个阶段注入自定义逻辑的方式。
gorm time.Time 使用钩子函数解决反序列化问题
qq_26372385的博客
07-06 3749
问题描述： gorm中使用下面的CreatedAt 和UpdateAt，可以实现在记录创建和更新时自动更新下面两个字段。虽然使用默认的json解析，从json中到golang中，从golang中写入到数据库(mysql)都是标准的格式“2006-01-02 15:04:05”，但是从golang中解析到json中时是 “RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"”。 原因： type User struct { Id
golang gorm——hook和session配置
qq_43058348的博客
10-10 400
gorm 数据库操作hook函数实现和数据库会话
GORM_事务和HOOK
lisus2007的专栏
05-16 531
GORM_事务和HOOK
GO语言，gorm框架，起名为Shop_goods的结构体映射数据库表，查询只返回表中Status 值为2 的sql语句
03-23
可以使用以下代码实现： ```go type ShopGoods struct { ID int Name string Status int } db.Where("status = ?", 2).Find(&ShopGoods{}) ``` 这段代码使用 gorm 框架将 ShopGoods 结构体映射到数据库表，然后使用 Where 方法查询 Status 值为 2 的记录，并使用 Find 方法返回查询结果的 SQL 语句。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

落雨便归尘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值