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操作,其核心流程如下:

gorm hook使用中的问题及核心源码解读_第1张图片

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
		}
	}
}

你可能感兴趣的:(go,mysql,gorm,go)