gorm hook使用中的问题及核心源码解读
本文针对的是gorm V2版本。hook官方文档可以点击这里，本文旨在对官方文档作一些补充说明。
下文中所有的DB均指gorm.Open返回的DB对象。
DB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
1. hook作用的对象
hook只能定义在model上，不能定义在gorm.DB上。
假设我们有User表，对应model如下，则可以定义BeforeCreate hook，用于插入数据前的检查。
type User struct {
ID int64
Name string
Age int32
IsAdmin bool
IsValid bool
LoginTime time.Time
}
func (u *User) BeforeCreate(tx *gorm.DB) (err error) {
if u.Age < 10 || u.Name == ""{
return errors.New("invalid Age or Name")
}
return nil
}
但是如果多Model上有同样的逻辑（比如插入数据后记录日志），若使用hook实现，只能在每个Model上分别实现，或者考虑改用gorm的callback机制实现。
2. 可以定义哪些hook接口？
我们能定义的所有hook接口可以在gorm/callbacks/interface.go中查到
//gorm/callbacks/interface.go
type BeforeCreateInterface interface {
BeforeCreate(*gorm.DB) error
}
type AfterCreateInterface interface {
AfterCreate(*gorm.DB) error
}
type BeforeUpdateInterface interface {
BeforeUpdate(*gorm.DB) error
}
type AfterUpdateInterface interface {
AfterUpdate(*gorm.DB) error
}
type BeforeSaveInterface interface {
BeforeSave(*gorm.DB) error
}
type AfterSaveInterface interface {
AfterSave(*gorm.DB) error
}
type BeforeDeleteInterface interface {
BeforeDelete(*gorm.DB) error
}
type AfterDeleteInterface interface {
AfterDelete(*gorm.DB) error
}
type AfterFindInterface interface {
AfterFind(*gorm.DB) error
}
3. 各hook接口在何时被调用？调用次数是怎样的
| 方法 | 调用hoook | 触发次数 |
|---|---|---|
| Save | BeforeCreate/AfterCreate/BeforeSave/AfterSave | 一次 |
| Create | BeforeCreate/AfterCreate/BeforeSave/AfterSave | 数组形式插入触发多次,create from map方式不会触发 |
| Update | BeforeUpdate/AfterUpdate/BeforeSave/AfterSave | 一次 |
| Delete | BeforeDelete/AfterDelete | 一次 |
| Find/First/Last/Take | AfterFind | 查出几条数据则触发几次 |
说明：
- create from map的例子
DB.Model(&User{}).Create(map[string]interface{}{
"Name":"nathan",
"Age":6,
})
- AfterFind只在Find时可能调多次，因为只有Find可能返回多条数据。
- 在没查出数据时，AfterFind不会触发。
- 注意BeforeSave，AfterSave在Create和Update时也会调用。这意味着，如果你同时定义了BeforeSave和BeforeCreate，那么在执行Create时，两者都会被触发。
- Save方法的作用，源码中的注释是这样说的：Save update value in database, if the value doesn’t have primary key, will insert it。无主键则插入，有主键则update。
4. hook中return error会怎样?
| hook | return error后果 |
|---|---|
| BeforeUpdate/BeforeSave/BeforeCreate | 停止之后的执行 |
| AfterUpdate/AfterSave/AfterCreate/AfterDelete | 使得之前的数据库写入操作回滚 |
| AfterFind | 继续执行 |
说明：
- 停止之后的执行是指，方法本身和之后的After**都不会被调用。比如BeforeCreate若返回error，则Create和AfterCreate都不会调用。
5. 如何跳过hook?
skipHookDB := DB.Session(&gorm.Session{
//设置跳过hook
SkipHooks:true,
})
skipHookDB.Where("age = ?", 12).Delete(&User{})
在现在的DB上定义一个不同配置的Session，用这个session来执行sql即可。
6. hook机制在源码中是如何实现的？
我们以Create为例，说明一下hook的实现方式。
gorm中对库表的操作，都是基于callback机制的（对于callback，稍后会专门写一篇来讲）。
6.1 主体流程
//[email protected]/callbacks/callbacks.go
//默认回调方法
func RegisterDefaultCallbacks(db *gorm.DB, config *Config) {
enableTransaction := func(db *gorm.DB) bool {
return !db.SkipDefaultTransaction
}
//注册Create相关的回调
createCallback := db.Callback().Create()
//对Create注册transaction回调
createCallback.Match(enableTransaction).Register("gorm:begin_transaction", BeginTransaction)
createCallback.Register("gorm:before_create", BeforeCreate)
createCallback.Register("gorm:save_before_associations", SaveBeforeAssociations(true))
createCallback.Register("gorm:create", Create(config))
createCallback.Register("gorm:save_after_associations", SaveAfterAssociations(true))
createCallback.Register("gorm:after_create", AfterCreate)
//对Create注册commit_or_rollback_transaction回调
//这也是为什么Create方法会默认开启事务
createCallback.Match(enableTransaction).Register("gorm:commit_or_rollback_transaction", CommitOrRollbackTransaction)
...
...
}
上述代码注册了mysql相关的默认回方法，这里我们只截取了Create方法相关的回调。可以看到
- gorm:before_create将调用BeforeCreate函数
- gorm:create将调用Create函数
- gorm:after_create将调用的AfterCreate函数
- 以上三个函数在[email protected]/callbacks/create.go中定义
所以，对一次Create操作，其核心流程如下:
BeforeSaveInterface, BeforeCreateInterface等，即是我们自定义的hook方法。
6.2 代码解读
BeforeCreate
//[email protected]/callbacks/create.go
func BeforeCreate(db *gorm.DB) {
if db.Error == nil && db.Statement.Schema != nil &&
//未设置跳过Hook
!db.Statement.SkipHooks &&
//定义了BeforeSave或BeforeCreate
(db.Statement.Schema.BeforeSave || db.Statement.Schema.BeforeCreate) {
callMethod(db, func(value interface{}, tx *gorm.DB) (called bool) {
//定义了BeforeSave
if db.Statement.Schema.BeforeSave {
//value即是当前要插入的数据对象，在我们例子中是User
//断言数据对象上是否实现了BeforeSaveInterface接口，即我们的hook
if i, ok := value.(BeforeSaveInterface); ok {
called = true
//调用hook方法BeforeSave
//通过db.AddError将错误加入db.Error
db.AddError(i.BeforeSave(tx))
}
}
//定义了BeforeCreate
if db.Statement.Schema.BeforeCreate {
if i, ok := value.(BeforeCreateInterface); ok {
called = true
//调用hook方法BeforeCreate
db.AddError(i.BeforeCreate(tx))
}
}
return called
})
}
}
AfterCreate的逻辑类似。
Create
func Create(config *Config) func(db *gorm.DB) {
...
return func(db *gorm.DB) {
//无错误才执行create操作
//这也是为什么BeforeCreate返回错误，Create就不会执行
if db.Error == nil {
... ...
}
}
}
}
CommitOrRollbackTransaction
//[email protected]/callbacks/transaction.go
func CommitOrRollbackTransaction(db *gorm.DB) {
if !db.Config.SkipDefaultTransaction {
//只有注册了started_transaction才会执行
//因为没有开始事务Commit和Rollback都没有意义
if _, ok := db.InstanceGet("gorm:started_transaction"); ok {
//db无Error提交
if db.Error == nil {
db.Commit()
} else {
//有Error回滚
db.Rollback()
}
db.Statement.ConnPool = db.ConnPool
}
}
}