Gorm 是一款 ORM 框架，当我们想把一个对象/struct 持久化的时候，我们可以直接操作对象/struct 而不需要编写 SQL 语句，如下：
package main
import (
_ "github.com/go-sql-driver/mysql"
"github.com/jinzhu/gorm"
"xg-temp/service/proto"
)
func main() {
db, _ := gorm.Open("mysql",
"root:123456" + "@/xg?charset=utf8&parseTime=true&loc=Local")
ma := &xgtmp_srv_app.MobileApplication{
AppName: "第一个应用",
OtherInfo: "第一个应用的信息",
}
db.Create(ma)
}
db 中的结果:
mysql> use xg;
Database changed
mysql> select * from mobile_applications;
+-----------------+--------------------------+------------------+---------------+
| app_name | other_info | xxx_unrecognized | xxx_sizecache |
+-----------------+--------------------------+------------------+---------------+
| 第一个应用 | 第一个应用的信息 | NULL | 0 |
+-----------------+--------------------------+------------------+---------------+
1 row in set (0.00 sec)
mysql>
很方便，但是 Create 操作背后的逻辑究竟是什么，只是简单的字段映射吗？还是有别的逻辑，我们只能深入源码去探究一番。
1 Create(value interface{}) *DB
首先创建了一个新的 scope，scope 用要持久化的对象来初始化。然后调用 scope 的 creates 回调函数，返回 db 对象，符合链式语法。
// Create insert the value into database
func (s *DB) Create(value interface{}) *DB {
scope := s.NewScope(value)
return scope.callCallbacks(s.parent.callbacks.creates).db
}
scope 是一个局部上下文，表示当前操作，如创建操作，涉及到的一些信息。
// Scope contain current operation's information when you perform any operation on the database
type Scope struct {
Search *search // 查询条件
Value interface{} // 对于 Create 来说即要持久化的对象
SQL string // 具体执行的 SQL 语句
SQLVars []interface{} // 要替换掉占位符的具体参数
db *DB // 数据库连接
instanceID string
primaryKeyField *Field // 主键字段
skipLeft bool
fields *[]*Field // 所有字段
selectAttrs *[]string
}
newScope 操作，先是复制了当前连接的上下文，然后把要持久化的对象分别赋值给连接和 scope，如果当前连接有 search 则赋值给 scope 中的 search 属性。search 也是一个 struct，用来描述 SQL 查询语句的各种条件，比如 where, or, join, limit 等等。这里不深入研究。
// NewScope create a scope for current operation
func (s *DB) NewScope(value interface{}) *Scope {
dbClone := s.clone()
dbClone.Value = value
scope := &Scope{db: dbClone, Value: value}
if s.search != nil {
scope.Search = s.search.clone()
} else {
scope.Search = &search{}
}
return scope
}
完成元数据的创建后，我们发现，后续操作直接委托给了 scope.callCallbacks(s.parent.callbacks.creates)。
2. scope.callCallbacks(s.parent.callbacks.creates)
callCallbacks 上来就以 defer 的形式定义了错误处理函数，我们在里面看见了 db.Rollback() 操作，肯定是事务回滚操作，但是我们并没有看见在哪里开启了事务，这个后面会解释。
主体部分很简单，funcs 是一个函数指针数组，函数的入参为 Scope 指针，遍历并执行每一个函数。skipLeft 属性的意义暂不清楚。
func (scope *Scope) callCallbacks(funcs []*func(s *Scope)) *Scope {
defer func() {
if err := recover(); err != nil {
if db, ok := scope.db.db.(sqlTx); ok {
db.Rollback()
}
panic(err)
}
}()
for _, f := range funcs {
(*f)(scope)
if scope.skipLeft {
break
}
}
return scope
}
callCallbacks 的实参是 s.parent.callbacks.creates，s.parent 表示的是数据库连接的一些共有属性，全局共享。callbacks 的定义如下:
// Callback is a struct that contains all CRUD callbacks
// Field `creates` contains callbacks will be call when creating object
// Field `updates` contains callbacks will be call when updating object
// Field `deletes` contains callbacks will be call when deleting object
// Field `queries` contains callbacks will be call when querying object with query methods like Find, First, Related, Association...
// Field `rowQueries` contains callbacks will be call when querying object with Row, Rows...
// Field `processors` contains all callback processors, will be used to generate above callbacks in order
type Callback struct {
logger logger
creates []*func(scope *Scope)
updates []*func(scope *Scope)
deletes []*func(scope *Scope)
queries []*func(scope *Scope)
rowQueries []*func(scope *Scope)
processors []*CallbackProcessor
}
可见，creates 是一组函数，在我们执行 Create 操作的时候都会执行，那么 creates 具体是哪些函数呢？
在 gorm.callback_create 里定义了 init 函数，我们知道 init() 函数是一种特殊的函数，会在 package 被导入的时候有且仅执行一次。
func init() {
// 开启事务
DefaultCallback.Create().Register("gorm:begin_transaction", beginTransactionCallback)
// Create 前的操作
DefaultCallback.Create().Register("gorm:before_create", beforeCreateCallback)
// saveBeforeAssocations
DefaultCallback.Create().Register("gorm:save_before_associations", saveBeforeAssociationsCallback)
// 更新时间
DefaultCallback.Create().Register("gorm:update_time_stamp", updateTimeStampForCreateCallback)
// 执行 Create
DefaultCallback.Create().Register("gorm:create", createCallback)
// 强制触发重新加载
DefaultCallback.Create().Register("gorm:force_reload_after_create", forceReloadAfterCreateCallback)
// saveAfterAssociations
DefaultCallback.Create().Register("gorm:save_after_associations", saveAfterAssociationsCallback)
// Create 后的操作
DefaultCallback.Create().Register("gorm:after_create", afterCreateCallback)
// 提交或回滚事务
DefaultCallback.Create().Register("gorm:commit_or_rollback_transaction", commitOrRollbackTransactionCallback)
}
一上来就注册了这么多回调？是的，你没看错。官方文档里也简单提了一下这部分，没被注释掉的是暴露出来的接口。
// begin transaction 开始事物
BeforeSave
BeforeCreate
// save before associations 保存前关联
// update timestamp `CreatedAt`, `UpdatedAt` 更新`CreatedAt`, `UpdatedAt`时间戳
// save self 保存自己
// reload fields that have default value and its value is blank 重新加载具有默认值且其值为空的字段
// save after associations 保存后关联
AfterCreate
AfterSave
// commit or rollback transaction 提交或回滚事务
下面我们一一来看
2.1 beginTransactionCallback
就一行，scope.Begin()，具体的工作委托给了 scope，而 scope 实际上直接把操作转发给了自己的 gorm.DB.db，这是一个 SQLCommon 接口类型，在初始化的过程中，实际类型就是 sql.DB。
sqlDB 接口暴露了 Begin 方法，所以，scope 开启事务，实际上调用的还是 sql.DB 里定义的相关方法。这部分操作在另一篇博客中有说明。
sqlDb 和 SQLCommon 是两个接口，虽然实际类型都是 sql.DB，但是需要转换一下。db.Begin() 后，scope 里就是开启了事务的连接了。
func beginTransactionCallback(scope *Scope) {
scope.Begin()
}
// Begin start a transaction
func (scope *Scope) Begin() *Scope {
if db, ok := scope.SQLDB().(sqlDb); ok {
if tx, err := db.Begin(); scope.Err(err) == nil {
scope.db.db = interface{}(tx).(SQLCommon)
scope.InstanceSet("gorm:started_transaction", true)
}
}
return scope
}
// SQLDB return *sql.DB
func (scope *Scope) SQLDB() SQLCommon {
return scope.db.db
}
Begin 后 driverConn 已经绑定
2.2 beforeCreateCallback
beforeCreateCallback 会调用 BeforeSave 和 BeforeCreate 两个方法，
// beforeCreateCallback will invoke `BeforeSave`, `BeforeCreate` method before creating
func beforeCreateCallback(scope *Scope) {
if !scope.HasError() {
scope.CallMethod("BeforeSave")
}
if !scope.HasError() {
scope.CallMethod("BeforeCreate")
}
}
这两个方法是定义在我们的 struct 上的，即接收者为要被 Create 的 struct。如下：
func (m *MobileApplication) BeforeSave() {
println("MobileApplication BeforeSave")
}
func (m *MobileApplication) BeforeCreate() {
println("MobileApplication BeforeCreate")
}
在执行 Create 操作的时候会触发这两个方法。但是，这个方法不能参与到事务中，因为没有事务句柄。Gorm的官网给了下面的示例来解决这个问题：
gorm中的保存/删除操作正在事务中运行，因此在该事务中所做的更改不可见，除非提交。 如果要在回调中使用这些更改，则需要在同一事务中运行SQL。 所以你需要传递当前事务到回调，像这样：
func (u *User) AfterCreate(tx *gorm.DB) (err error) {
tx.Model(u).Update("role", "admin")
return
}
func (u *User) AfterCreate(scope *gorm.Scope) (err error) {
scope.DB().Model(u).Update("role", "admin")
return
}
2.3 saveBeforeAssociationsCallback
// TODO 没看懂
func saveBeforeAssociationsCallback(scope *Scope) {
for _, field := range scope.Fields() {
autoUpdate, autoCreate, saveReference, relationship := saveAssociationCheck(scope, field)
if relationship != nil && relationship.Kind == "belongs_to" {
fieldValue := field.Field.Addr().Interface()
newScope := scope.New(fieldValue)
if newScope.PrimaryKeyZero() {
if autoCreate {
scope.Err(scope.NewDB().Save(fieldValue).Error)
}
} else if autoUpdate {
scope.Err(scope.NewDB().Save(fieldValue).Error)
}
if saveReference {
if len(relationship.ForeignFieldNames) != 0 {
// set value's foreign key
for idx, fieldName := range relationship.ForeignFieldNames {
associationForeignName := relationship.AssociationForeignDBNames[idx]
if foreignField, ok := scope.New(fieldValue).FieldByName(associationForeignName); ok {
scope.Err(scope.SetColumn(fieldName, foreignField.Field.Interface()))
}
}
}
}
}
}
}
if scope.changeableField(field) && !field.IsBlank && !field.IsIgnored {
if r = field.Relationship; r != nil {
autoUpdate, autoCreate, saveReference = true, true, true
if value, ok := scope.Get("gorm:save_associations"); ok {
autoUpdate = checkTruth(value)
autoCreate = autoUpdate
saveReference = autoUpdate
} else if value, ok := field.TagSettingsGet("SAVE_ASSOCIATIONS"); ok {
autoUpdate = checkTruth(value)
autoCreate = autoUpdate
saveReference = autoUpdate
}
if value, ok := scope.Get("gorm:association_autoupdate"); ok {
autoUpdate = checkTruth(value)
} else if value, ok := field.TagSettingsGet("ASSOCIATION_AUTOUPDATE"); ok {
autoUpdate = checkTruth(value)
}
if value, ok := scope.Get("gorm:association_autocreate"); ok {
autoCreate = checkTruth(value)
} else if value, ok := field.TagSettingsGet("ASSOCIATION_AUTOCREATE"); ok {
autoCreate = checkTruth(value)
}
if value, ok := scope.Get("gorm:association_save_reference"); ok {
saveReference = checkTruth(value)
} else if value, ok := field.TagSettingsGet("ASSOCIATION_SAVE_REFERENCE"); ok {
saveReference = checkTruth(value)
}
}
}
2.4 updateTimeStampForCreateCallback
这个很简单，就是在创建的时候设置 CreatedAt 和 UpdatedAt 字段
// updateTimeStampForCreateCallback will set `CreatedAt`, `UpdatedAt` when creating
func updateTimeStampForCreateCallback(scope *Scope) {
if !scope.HasError() {
now := scope.db.nowFunc()
if createdAtField, ok := scope.FieldByName("CreatedAt"); ok {
if createdAtField.IsBlank {
createdAtField.Set(now)
}
}
if updatedAtField, ok := scope.FieldByName("UpdatedAt"); ok {
if updatedAtField.IsBlank {
updatedAtField.Set(now)
}
}
}
}
2.5 createCallback
执行真正的 INSERT 操作，也就是 ORM 逻辑。代码太长这里就不贴了。
需要注意的是，当字段为零值的时候，只有设置了 default 才会执行操作，而不是直接置为 NULL
if scope.changeableField(field) {
if field.IsNormal && !field.IsIgnored {
if field.IsBlank && field.HasDefaultValue {
blankColumnsWithDefaultValue = append(blankColumnsWithDefaultValue, scope.Quote(field.DBName))
scope.InstanceSet("gorm:blank_columns_with_default_value", blankColumnsWithDefaultValue)
} else if !field.IsPrimaryKey || !field.IsBlank {
columns = append(columns, scope.Quote(field.DBName))
placeholders = append(placeholders, scope.AddToVars(field.Field.Interface()))
}
} else if field.Relationship != nil && field.Relationship.Kind == "belongs_to" {
for _, foreignKey := range field.Relationship.ForeignDBNames {
if foreignField, ok := scope.FieldByName(foreignKey); ok && !scope.changeableField(foreignField) {
columns = append(columns, scope.Quote(foreignField.DBName))
placeholders = append(placeholders, scope.AddToVars(foreignField.Field.Interface()))
}
}
}
}
2.6 forceReloadAfterCreateCallback
把设置了 default 标识的字段赋值为当前对象的对应字段值
// forceReloadAfterCreateCallback will reload columns that having default value, and set it back to current object
func forceReloadAfterCreateCallback(scope *Scope) {
if blankColumnsWithDefaultValue, ok := scope.InstanceGet("gorm:blank_columns_with_default_value"); ok {
db := scope.DB().New().Table(scope.TableName()).Select(blankColumnsWithDefaultValue.([]string))
for _, field := range scope.Fields() {
if field.IsPrimaryKey && !field.IsBlank {
db = db.Where(fmt.Sprintf("%v = ?", field.DBName), field.Field.Interface())
}
}
db.Scan(scope.Value)
}
}
2.7 saveAfterAssociationsCallback
// TODO 没看懂
2.8 afterCreateCallback
与前面的 beforeCreateCallback 类似
2.9 commitOrRollbackTransactionCallback
这个方法会调用 scope.CommitOrRollback()
// CommitOrRollback commit current transaction if no error happened, otherwise will rollback it
func (scope *Scope) CommitOrRollback() *Scope {
if _, ok := scope.InstanceGet("gorm:started_transaction"); ok {
if db, ok := scope.db.db.(sqlTx); ok {
if scope.HasError() {
db.Rollback()
} else {
scope.Err(db.Commit())
}
scope.db.db = scope.db.parent.db
}
}
return scope
}