• 定制 GORM Callbacks
    • 问题
      • 解决
      • 实现Callbacks
      • 注册Callbacks
      • 验证
    • 拓展
      • 实现Callbacks
      • 注册Callbacks
      • 验证
    • 小结
    • 参考
      • 本系列示例代码
      • 文档

    定制 GORM Callbacks

    GORM itself is powered by Callbacks, so you could fully customize GORM as you want

    项目地址：https://github.com/EDDYCJY/go-gin-example

    GORM 本身是由回调驱动的，所以我们可以根据需要完全定制 GORM，以此达到我们的目的

    • 注册一个新的回调
    • 删除现有的回调
    • 替换现有的回调
    • 注册回调的顺序

    在 GORM 中包含以上四类 Callbacks，我们结合项目选用 “替换现有的回调” 来解决一个小痛点

    问题

    在 models 目录下，我们包含 tag.go 和 article.go 两个文件，他们有一个问题，就是 BeforeCreate、BeforeUpdate 重复出现了，那难道 100 个文件，就要写一百次吗？

    1、tag.go

    image

    2、article.go

    image

    显然这是不可能的，如果先前你已经意识到这个问题，那挺OK，但没有的话，现在开始就要改

    解决

    在这里我们通过 Callbacks 来实现功能，不需要一个个文件去编写

    实现Callbacks

    打开 models 目录下的 models.go 文件，实现以下两个方法：

    1、updateTimeStampForCreateCallback

    1. // updateTimeStampForCreateCallback will set `CreatedOn`, `ModifiedOn` when creating
    2. func updateTimeStampForCreateCallback(scope *gorm.Scope) {
    3.     if !scope.HasError() {
    4.         nowTime := time.Now().Unix()
    5.         if createTimeField, ok := scope.FieldByName("CreatedOn"); ok {
    6.             if createTimeField.IsBlank {
    7.                 createTimeField.Set(nowTime)
    8.             }
    9.         }
    11.         if modifyTimeField, ok := scope.FieldByName("ModifiedOn"); ok {
    12.             if modifyTimeField.IsBlank {
    13.                 modifyTimeField.Set(nowTime)
    14.             }
    15.         }
    16.     }
    17. }

    在这段方法中，会完成以下功能

    • 检查是否有含有错误（db.Error）

    • scope.FieldByName 通过 scope.Fields() 获取所有字段，判断当前是否包含所需字段

      1. for _, field := range scope.Fields() {
      2.   if field.Name == name || field.DBName == name {
      3.       return field, true
      4.   }
      5.   if field.DBName == dbName {
      6.       mostMatchedField = field
      7.   }
      8. }

    • field.IsBlank 可判断该字段的值是否为空

      1. func isBlank(value reflect.Value) bool {
      2.   switch value.Kind() {
      3.   case reflect.String:
      4.       return value.Len() == 0
      5.   case reflect.Bool:
      6.       return !value.Bool()
      7.   case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
      8.       return value.Int() == 0
      9.   case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
      10.       return value.Uint() == 0
      11.   case reflect.Float32, reflect.Float64:
      12.       return value.Float() == 0
      13.   case reflect.Interface, reflect.Ptr:
      14.       return value.IsNil()
      15.   }
      17.   return reflect.DeepEqual(value.Interface(), reflect.Zero(value.Type()).Interface())
      18. }
    • 若为空则 field.Set 用于给该字段设置值，参数为 interface{}

    2、updateTimeStampForUpdateCallback

    1. // updateTimeStampForUpdateCallback will set `ModifyTime` when updating
    2. func updateTimeStampForUpdateCallback(scope *gorm.Scope) {
    3.     if _, ok := scope.Get("gorm:update_column"); !ok {
    4.         scope.SetColumn("ModifiedOn", time.Now().Unix())
    5.     }
    6. }
    • scope.Get(...) 根据入参获取设置了字面值的参数，例如本文中是 gorm:update_column ，它会去查找含这个字面值的字段属性
    • scope.SetColumn(...) 假设没有指定 update_column 的字段，我们默认在更新回调设置 ModifiedOn 的值

    注册Callbacks

    在上面小节我已经把回调方法编写好了，接下来需要将其注册进 GORM 的钩子里，但其本身自带 Create 和 Update 回调，因此调用替换即可

    在 models.go 的 init 函数中，增加以下语句

    1. db.Callback().Create().Replace("gorm:update_time_stamp", updateTimeStampForCreateCallback)
    2. db.Callback().Update().Replace("gorm:update_time_stamp", updateTimeStampForUpdateCallback)

    验证

    访问 AddTag 接口，成功后检查数据库，可发现 created_on 和 modified_on 字段都为当前执行时间

    访问 EditTag 接口，可发现 modified_on 为最后一次执行更新的时间

    拓展

    我们想到，在实际项目中硬删除是较少存在的，那么是否可以通过 Callbacks 来完成这个功能呢？

    答案是可以的，我们在先前 Model struct 增加 DeletedOn 变量

    1. type Model struct {
    2.     ID int `gorm:"primary_key" json:"id"`
    3.     CreatedOn int `json:"created_on"`
    4.     ModifiedOn int `json:"modified_on"`
    5.     DeletedOn int `json:"deleted_on"`
    6. }

    实现Callbacks

    打开 models 目录下的 models.go 文件，实现以下方法：

    1. func deleteCallback(scope *gorm.Scope) {
    2.     if !scope.HasError() {
    3.         var extraOption string
    4.         if str, ok := scope.Get("gorm:delete_option"); ok {
    5.             extraOption = fmt.Sprint(str)
    6.         }
    8.         deletedOnField, hasDeletedOnField := scope.FieldByName("DeletedOn")
    10.         if !scope.Search.Unscoped && hasDeletedOnField {
    11.             scope.Raw(fmt.Sprintf(
    12.                 "UPDATE %v SET %v=%v%v%v",
    13.                 scope.QuotedTableName(),
    14.                 scope.Quote(deletedOnField.DBName),
    15.                 scope.AddToVars(time.Now().Unix()),
    16.                 addExtraSpaceIfExist(scope.CombinedConditionSql()),
    17.                 addExtraSpaceIfExist(extraOption),
    18.             )).Exec()
    19.         } else {
    20.             scope.Raw(fmt.Sprintf(
    21.                 "DELETE FROM %v%v%v",
    22.                 scope.QuotedTableName(),
    23.                 addExtraSpaceIfExist(scope.CombinedConditionSql()),
    24.                 addExtraSpaceIfExist(extraOption),
    25.             )).Exec()
    26.         }
    27.     }
    28. }
    30. func addExtraSpaceIfExist(str string) string {
    31.     if str != "" {
    32.         return " " + str
    33.     }
    34.     return ""
    35. }
    • scope.Get("gorm:delete_option") 检查是否手动指定了delete_option
    • scope.FieldByName("DeletedOn") 获取我们约定的删除字段，若存在则 UPDATE 软删除，若不存在则 DELETE 硬删除
    • scope.QuotedTableName() 返回引用的表名，这个方法 GORM 会根据自身逻辑对表名进行一些处理
    • scope.CombinedConditionSql() 返回组合好的条件SQL，看一下方法原型很明了
      1. func (scope *Scope) CombinedConditionSql() string {
      2.   joinSQL := scope.joinsSQL()
      3.   whereSQL := scope.whereSQL()
      4.   if scope.Search.raw {
      5.       whereSQL = strings.TrimSuffix(strings.TrimPrefix(whereSQL, "WHERE ("), ")")
      6.   }
      7.   return joinSQL + whereSQL + scope.groupSQL() +
      8.       scope.havingSQL() + scope.orderSQL() + scope.limitAndOffsetSQL()
      9. }

    • scope.AddToVars 该方法可以添加值作为SQL的参数，也可用于防范SQL注入

      1. func (scope *Scope) AddToVars(value interface{}) string {
      2.   _, skipBindVar := scope.InstanceGet("skip_bindvar")
      4.   if expr, ok := value.(*expr); ok {
      5.       exp := expr.expr
      6.       for _, arg := range expr.args {
      7.           if skipBindVar {
      8.               scope.AddToVars(arg)
      9.           } else {
      10.               exp = strings.Replace(exp, "?", scope.AddToVars(arg), 1)
      11.           }
      12.       }
      13.       return exp
      14.   }
      16.   scope.SQLVars = append(scope.SQLVars, value)
      18.   if skipBindVar {
      19.       return "?"
      20.   }
      21.   return scope.Dialect().BindVar(len(scope.SQLVars))
      22. }

    注册Callbacks

    在 models.go 的 init 函数中，增加以下删除的回调

    1. db.Callback().Delete().Replace("gorm:delete", deleteCallback)

    验证

    重启服务，访问 DeleteTag 接口，成功后即可发现 deleted_on 字段有值

    小结

    在这一章节中，我们结合 GORM 完成了新增、更新、查询的 Callbacks，在实际项目中常常也是这么使用

    毕竟，一个钩子的事，就没有必要自己手写过多不必要的代码了

    （注意，增加了软删除后，先前的代码需要增加 deleted_on 的判断）

    参考

    本系列示例代码

    • go-gin-example

    文档

    • gorm