Go第三方框架--gorm框架（一）

前言

orm模型简介

orm模型全称是Object-Relational Mapping，即对象关系映射。其实就是在原生sql基础之上进行更高程度的封装。方便程序员采用面向对象的方式来操作数据库，将表映射成对象。
这种映射带来几个好处：

1. 代码简洁：不用手动编写sql
2. 安全性提高了：orm框架会自动处理参数化查询，可以有效减少sql注入的风险
3. 可读性提高了：orm更接近自然语言。
4. 可移植性提高，切换不同数据库时，不用重新编写sql，只需要更改连接字符串。

gorm模型简介

gorm顾名思义是采用go语言实现的orm框架，由jinzhu开发后开源，又融合了很多大神的思路。gorm主要是在go原生数据库包database/sql 的基础上引入orm思想来编写。所以其底层仍会调用database/sql的相关增删改查操作等dml操作和表结构修改等ddl操作。
以原生database/sql 查询为例：

要实现如下sql(gorm可以操作多种据库，我们本篇只以mysql为例来介绍)

SELECT * FROM userinfos WHERE name = "lisan” ORDER BY id ASC LIMIT 1;

则 database/sql 代码如下

	dbsql, err := sql.Open("mysql", "root:root@tcp(127.0.0.1:3306)/world?charset=utf8mb4&parseTime=True&loc=Local")if err != nil {log.Fatal(err)}defer dbsql.Close()query := "SELECT * FROM userinfos WHERE name = ? ORDER BY id ASC LIMIT 1"// 执行查询_, err = dbsql.Query(query, "lisan")if err != nil {log.Fatal(err)}

debug可以看到其调用的是database/sql的QueryContext(…)函数。

如果用gorm来实现相同功能sql，则代码如下：

	//gormdsn := "root:root@tcp(127.0.0.1:3306)/world?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})  // db是初始化的db cloen=1 或 2 时，会将初始db复制一份，避免操作污染。if err != nil {panic(err)}var userinfo Userinfo// 查询单条db.Table(...) 中由于 db.clone=1 所以复制一份 新的db.clone=0 所以后续的链式调用 (各种. . .)的状态都会累加到 db.Table()生成的新db上，// 如此保证了 原始db的纯净 和 链式调用（拼装一条完整sql）的累加。（后续会有详细讲解）if err = db.Table("userinfos").Where("name = ?", "lisan").First(&userinfo).Error; err != nil {return}

debug可以看到 其在First(…)函数内部也会调用 database/sql的QueryContext(…)函数

其调用链是

First(...)---->Execute(tx)----->f(db)----> Query(db *gorm.DB)---->db.Statement.ConnPool.QueryContext(....)---->QueryContext(....)

我们介绍gorm也是从具体的例子开始，到调用具体的database/sql函数为止。其实gorm可以看做将原生database/sql语句可配置化，自动对应表结构和sql语句进行封装。
至于database/sql调用的具体细节，后续会单独编写文章。好了明确了边界，现在我们来看下orm的几个重要结构体。

几种结构体

DB

db是gorm的核心结构体，所有操作都由它承载。

type DB struct {*Config     // 存放一些初始化的配制信息，包括连接池和执行dml的回调函数等Error        error // 执行操作的错误信息RowsAffected int64Statement    *Statement //  执行增删改查的 状态信息 ，是sql语句累加的地方。clone        int        // db克隆次数 用来克隆db实例 避免多个查询时 互相影响 保证每个操作都会复制一份初始化的db // clone值 0：表示不复制实例 每个操作都会累计， 一般在相同sql语句中使用，例如 几个 where().where()链式调用需要进行sql状态累计。//   1：不同sql语句的增删改查等操作用，会复制一份新db，避免相互之间影响。一般只有连接池，配置等初始参数会复用，操作相关参数会初始化。相同语句链式调用会操作同一份Statement，不同的sql语句执行不同的Statement//   2: 开启事务时使用，配置直接复用，Statement会复制一份。 todo
}

Config结构体如下

Config

Config有初始化db需要的一些配置和初始化后的一些属性，比如连接池和回调函数等。

type Config struct {// GORM perform single create, update, delete operations in transactions by default to ensure database data  // ... 省略一些本篇不用的属性// ClauseBuilders clause builderClauseBuilders map[string]clause.ClauseBuilder// ConnPool db conn pool  // 连接池 对应database/sql 中的sql.DB 存放连接状态等信息 防止频繁创建连接ConnPool ConnPool// Dialector database dialectorDialector //  mysql/sqlite等数据的操作接口// Plugins registered pluginsPlugins map[string]Plugincallbacks  *callbacks // 增删改查等 gorm高度封装回调database/sql函数在这里注册cacheStore *sync.Map
}

其中 Dialector主要实现各种数据库的连接等操作，其结构如下：

type Dialector interface {Name() stringInitialize(*DB) error      // 数据库连接池等的初始化 databae/sql.db的初始化 和 注册回调的原生database/sql dml 封装函数等Migrator(db *DB) Migrator  // 装载操作 也就是承接 ddl的一些功能DataTypeOf(*schema.Field) stringDefaultValueOf(*schema.Field) clause.ExpressionBindVarTo(writer clause.Writer, stmt *Statement, v interface{})QuoteTo(clause.Writer, string)Explain(sql string, vars ...interface{}) string
}

其中 ConnPool 是Config中对接各数据库操作的地方，其函数内部直接调用了database/sql的相关函数，结构体如下：

type ConnPool interface {PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error) // 执行QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)  // 查询QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row 
}

目前 gorm集合了 mysql、sqlite等数据库的实现。
Config 中 callbacks属性 其结构体如下：

type callbacks struct {processors map[string]*processor
}type processor struct {db        *DBClauses   []stringfns       []func(*DB) // 回调函数 query 等callbacks []*callback
}

Statement

Statement是状态，也就是拼接完整sql和执行sql时需要的信息。

type Statement struct {*DBTableExpr            *clause.ExprTable                string         // 操作的表名Model                interface{}   //  结构体，跟表对应 用来承接结果Unscoped             boolDest                 interface{}   //  结构体，跟表对应ReflectValue         reflect.ValueClauses              map[string]clause.Clause // gorm执行语句 存储map 例如 Where("id=?",1) 则key：Where,value ：包含 id和1，用来拼接最终sql； 累计各个dml的操作BuildClauses         []string // 某dml操作可能需要的操作关键字， SELECT ,FROM,FOR等在sql中出现的先后顺序排列。 先出现的先用来组合SQL，这样保证sql语句的合法性Distinct             boolSelects              []string // selected columnsOmits                []string // omit columnsJoins                []joinPreloads             map[string][]interface{}Settings             sync.MapConnPool             ConnPool      // 连接池Schema               *schema.Schema //  要执行操作的表对象的一些信息；比如：这张表属性列表、主键信息、表名；结构体和表名对应表。Context              context.ContextRaiseErrorOnNotFound boolSkipHooks            boolSQL                  strings.Builder // 拼接后的最终 sql语句 入参用占位符代替Vars                 []interface{}   // SQL 属性的入参CurDestIndex         intattrs                []interface{}assigns              []interface{}scopes               []func(*DB) *DB
}

现在只是大概梳理下其结构体，有疑惑很正常，接下来我们开始进入内部了解下其原理。共分为四大部分：

1. 初始化：介绍gorm.db初始化的一些操作，包括初始化db.ConnPool(也就是database/sql db的初始化)，注册回调的原生database/sql dml 封装函数等。
2. 自动装载：自动装载主要介绍表的自动创建，属性的增加等ddl操作。
3. 增删改查：这块主要讲解 gorm 如何将封装程序的可装配函数（例如where链式调用）转化为复杂的sql语句，然后通过回调函数实现原生 database/sql 的dml操作。
4. 事务： todo

初始化

初始化主要是初始化一些必要的参数，我们重点关注初始化对应数据库的连接池和注册dml操作的回调函数。
初始化代码是示例的前几行，如下：

dsn := "root:root@tcp(127.0.0.1:3306)/world?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})  // db是初始化的db cloen=1 时，会将初始db复制一份，避免操作污染。if err != nil {panic(err)}

其中mysql.Open(dsn)是按照mysql数据库的链接逻辑解析dsn，然后赋值给mysql的Dialector实现结构体，用来初始化mysql连接池用。
我们来看下gorm.Open(…)函数的实现：

func Open(dialector Dialector, opts ...Option) (db *DB, err error) {// ...// clone=1时  会复制一份 db的核心属性 包括 statement、config等db = &DB{Config: config, clone: 1}// 回调函数初始化 db.callbacks = initializeCallbacks(db)if config.ClauseBuilders == nil {config.ClauseBuilders = map[string]clause.ClauseBuilder{}}// 这块 调用database/sql 根据不同的Dialector初始化不同数据库的ConnPool（就是database/db 的sql.db参数）等参数;并将dml回调函数填入callbacksif config.Dialector != nil {err = config.Dialector.Initialize(db)if err != nil {if db, _ := db.DB(); db != nil {_ = db.Close()}}}// ...// 初始化Statement db.Statement = &Statement{DB:       db,ConnPool: db.ConnPool,Context:  context.Background(),Clauses:  map[string]clause.Clause{},}// ...
}

其中核心逻辑在config.Dialector.Initialize(db)中，我们来看下：

func (dialector Dialector) Initialize(db *gorm.DB) (err error) {// ...if dialector.Conn != nil {db.ConnPool = dialector.Conn} else {// 这边对接 database/sql 开始初始化连接池操作db.ConnPool, err = sql.Open(dialector.DriverName, dialector.DSN)if err != nil {return err}}// ...// register callbacks// 加载dml操作的关键字，用来定位sql关键字的先后顺序，以便生成合法的sql。callbackConfig := &callbacks.Config{CreateClauses: CreateClauses,QueryClauses:  QueryClauses,UpdateClauses: UpdateClauses,DeleteClauses: DeleteClauses,}// ...// dml的callbacks函数在这里执行callbacks.RegisterDefaultCallbacks(db, callbackConfig)for k, v := range dialector.ClauseBuilders() {db.ClauseBuilders[k] = v}return
}

我们看到这里主要完成了 mysql连接池的和dml回调函数的初始化。

其中 callbacks.RegisterDefaultCallbacks(…)函数如下：

func RegisterDefaultCallbacks(db *gorm.DB, config *Config) {// ...// 注册执行的回调函数会在 First()中 最后一行的Execute()执行函数的 fns列表调用 // Create() 返回create对应的 *processor指针 对此指针的修改会反映在 db.config.callbacks属性上createCallback := db.Callback().Create()// *processor.callbacks （[]*callback） 在这边初始化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)createCallback.Match(enableTransaction).Register("gorm:commit_or_rollback_transaction", CommitOrRollbackTransaction)createCallback.Clauses = config.CreateClauses// 查询回调函数注册 也就是后续DML章节讲解的 查询函数的注册queryCallback := db.Callback().Query()queryCallback.Register("gorm:query", Query)// ...// 删除deleteCallback := db.Callback().Delete()deleteCallback.Match(enableTransaction).Register("gorm:begin_transaction", BeginTransaction)// ...// 更新updateCallback := db.Callback().Update()updateCallback.Match(enableTransaction).Register("gorm:begin_transaction", BeginTransaction)updateCallback.Register("gorm:setup_reflect_value", SetupUpdateReflectValue)// ...// gorm可以对增删改查进行 封装操作，使得操作更简单。也支持原生sql的查询rowCallback := db.Callback().Row() rowCallback.Register("gorm:row", RowQuery)rowCallback.Clauses = config.QueryClauses// ...
}

我们来看下涉及的结构体之间的关系图：

到这里初始化我们需要关注的两个领域已将讲解完毕。

自动装载（ddl操作）

自动装载主要是用来实现ddl相关的此操作，比如表的创建，属性的增加，属性参数的修改，添加约束条件，添加索引等。其会动态感知结构体的字段变化，从而将其映射到表结构上。我们来看下其源码。先看下下面的例子：

type Userinfo struct {Id     uintName   stringGender stringHobby  stringAddr   stringAge    uint8
}func TestGorm(t *testing.T) {//gormdsn := "root:root@tcp(127.0.0.1:3306)/world?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})if err != nil {panic(err)}//自动迁移 ddl相关的操作 调用 excute函数执行操作,调用"row"或者"raw"对应的 processor 执行查询 执行原生操作err = db.AutoMigrate(&Userinfo{})if err != nil {return}
}

执行如上语句后会创建 表名为 userinfos的表

其代码比较简单，但内部有复杂的逻辑，我们来简单梳理下。

自动装载源码如下：

// AutoMigrate run auto migration for given models
func (db *DB) AutoMigrate(dst ...interface{}) error {return db.Migrator().AutoMigrate(dst...)
}

其中 **Migrator()**方法返回值是Migrator 接口，其承载着自动装载需要的所有方法。todo

func (db *DB) Migrator() Migrator {tx := db.getInstance()  // apply scopes to migratorfor len(tx.Statement.scopes) > 0 {tx = tx.executeScopes()}// 调用 Dialector 的 Migrator 方法，传入一个 Session 实例。Session 包含了当前的事务信息，用于执行迁移操作 return tx.Dialector.Migrator(tx.Session(&Session{}))
}

Migrator 接口如下：

// ddl相关操作 可以增删 表 表的属性 视图 限制条件 索引 等；可以查看数据库
type Migrator interface {// AutoMigrateAutoMigrate(dst ...interface{}) error // Database 数据库相关操作CurrentDatabase() stringFullDataTypeOf(*schema.Field) clause.ExprGetTypeAliases(databaseTypeName string) []string// Tables 表相关操作CreateTable(dst ...interface{}) errorDropTable(dst ...interface{}) error// ...// Columns 列相关操作AddColumn(dst interface{}, field string) errorDropColumn(dst interface{}, field string) error// ...// Views 视图相关操作CreateView(name string, option ViewOption) errorDropView(name string) error// Constraints 限制条件相关操作CreateConstraint(dst interface{}, name string) errorDropConstraint(dst interface{}, name string) errorHasConstraint(dst interface{}, name string) bool// Indexes 索引相关操作CreateIndex(dst interface{}, name string) errorDropIndex(dst interface{}, name string) error// ...
}

AutoMigrate(value …interface{})承载着，自动装载的核心逻辑，包括对表、属性、索引等的操作；源码如下：

// AutoMigrate auto migrate values
func (m Migrator) AutoMigrate(values ...interface{}) error {for _, value := range m.ReorderModels(values, true) {queryTx, execTx := m.GetQueryAndExecTx()// 没有找到对应表 需要创建表if !queryTx.Migrator().HasTable(value) {// 创建表if err := execTx.Migrator().CreateTable(value); err != nil {return err}} else {// 将结构体名映射成表名 然后执行回调函数if err := m.RunWithValue(value, func(stmt *gorm.Statement) error {columnTypes, err := queryTx.Migrator().ColumnTypes(value)if err != nil {return err}var (parseIndexes          = stmt.Schema.ParseIndexes()parseCheckConstraints = stmt.Schema.ParseCheckConstraints())// DBNames 结构体 属性 按照 规则转换成 表属性 格式for _, dbName := range stmt.Schema.DBNames {var foundColumn gorm.ColumnType// columnTypes： 从数据库获得 表的 属性名信息 columnTypesfor _, columnType := range columnTypes {if columnType.Name() == dbName {foundColumn = columnTypebreak}}// 表中没有对应列if foundColumn == nil {// not found, add column 创建列if err = execTx.Migrator().AddColumn(value, dbName); err != nil {return err}} else {// found, smartly migrate 找到了结构体属性对应列名  对属性的参数（类型，注释等）进行 更新field := stmt.Schema.FieldsByDBName[dbName]if err = execTx.Migrator().MigrateColumn(value, field, foundColumn); err != nil {return err}}}// 对表约束条件进行更新if !m.DB.DisableForeignKeyConstraintWhenMigrating && !m.DB.IgnoreRelationshipsWhenMigrating {// ...}// 对表索引进行更新for _, idx := range parseIndexes {if !queryTx.Migrator().HasIndex(value, idx.Name) {if err := execTx.Migrator().CreateIndex(value, idx.Name); err != nil {return err}}}return nil}); err != nil {return err}}}return nil
}

AutoMigrate函数中需要的核心调用函数 都来自 Migrator 结构体 ，我们选择HasTable()函数来简单梳理下。
**HasTable(…)**用来判断是否存在特定表。其源码如下：

func (m Migrator) HasTable(value interface{}) bool {var count int64m.RunWithValue(value, func(stmt *gorm.Statement) error {currentDatabase := m.DB.Migrator().CurrentDatabase()// 原生sql执行（所谓执行原生sql，就是直接写原生sql，来调用database/sql方法，不使用gorm来组装sql），执行逻辑在Row()中，这边会调用已经注册的回调函数return m.DB.Raw("SELECT count(*) FROM information_schema.tables WHERE table_schema = ? AND table_name = ? AND table_type = ?", currentDatabase, stmt.Table, "BASE TABLE").Row().Scan(&count)})return count > 0
}

自动装载中所有对sql的调用的都是原生sql，因为查表、添加属性这种ddl sql语句比较固定，所以没必要采用组装的形式;而增删改查等 复杂的dml可以采用gorm来组装(比如：where(…).where(…)这种gorm最终会组合成sql语句。对database/sql的调用可以看做是接口调用，自动装载中的dml操作就简单的处理下得到了入参），再啰嗦一句，增删改等复杂的dml操作为用户提供了链式组合的方式来编写复杂的sql，它将组合的sql语句链，经过一些列的操作转换成调用原生sql的入参（原生sql和sql语句入参）。
自动装载函数AutoMigrate中还有好多值得深挖的点，由于篇幅原因不做介绍，感兴趣的大神可以深挖下。