本文针对的是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 主体流程

//gorm@v1.21.9/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函数
• 以上三个函数在gorm@v1.21.9/callbacks/create.go中定义

所以，对一次Create操作，其核心流程如下:

BeforeSaveInterface, BeforeCreateInterface等，即是我们自定义的hook方法。

6.2 代码解读

BeforeCreate

//gorm@v1.21.9/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

//gorm@v1.21.9/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
        }
    }
}