# Gorm 基础 ### Gorm 快速入门 > GORM github地址: GORM 官网地址： 主操作： MYSQL * 安装 ```go //安装MySQL驱动、gorm包 go get -u gorm.io/driver/mysql go get -u gorm.io/gorm ``` 增删改查 ```go package main import ( "errors" "fmt" "time" "gorm.io/driver/mysql" "gorm.io/gorm" ) type User struct { gorm.Model // gorm 自带模型继承 Username string `gorm:"column:username;not null"` // 列名（字段名)为username,不为空 Password string `gorm:"column:password;not null"` } // 设置表名，可以通过给struct类型定义 TableName函数，返回当前struct绑定的mysql表名是什么 func (u User) TableName() string { return "users" } func main() { //配置MySQL连接参数 username := "root" //账号 password := "123456" //密码 host := "127.0.0.1" //数据库地址，可以是Ip或者域名 port := 3306 //数据库端口 Dbname := "tizi365" //数据库名 /* 通过前面的数据库参数，拼接 MYSQL DSN， 其实就是数据库连接串（数据源名称） MYSQL dsn格式： {username}:{password}@tcp({host}:{port})/{Dbname}?charset=utf8&parseTime=True&loc=Local */ dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname) db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) if err != nil { panic("连接数据库失败, error=" + err.Error()) } // 自动创建表 users, 也就是上面模型 User db.AutoMigrate(&User{}) /* 增 */ u := User{ Username: "tizi365", Password: "123456", } // 错误处理,默认gorm.DB的Error属性为 nil, 检测 Error 是否为nil if err := db.Create(&u).Error; err != nil { fmt.Println("插入失败", err) return } /* 查 */ u = User{} result := db.Where("username = ?", "tizi365").First(&u) if errors.Is(result.Error, gorm.ErrRecordNotFound) { fmt.Println("找不到记录") return } fmt.Println(u.Username, u.Password) /* 改 */ db.Model(&User{}).Where("username = ?", "tizi365").Update("password", "654321") /* 删 */ db.Where("username = ?", "tizi365").Delete(&User{}) } ``` ### GORM 调试模式 > 会打印执行的 sql 语句 ```go result := db.Debug().Where("username = ?", "tizi365").First(&u) ``` ### GORM 高并发 > 提高数据库连接的使用率，避免重复建立数据库连接带来的性能消耗，会经常使用数据库连接池技术来维护数据库连接。 * 1、定义tools包，负责数据库初始化工作 ```go //定义一个工具包，用来管理gorm数据库连接池的初始化工作。 package tools //定义全局的db对象，我们执行数据库操作主要通过他实现。 var _db *gorm.DB //包初始化函数，golang特性，每个包初始化的时候会自动执行init函数，这里用来初始化gorm。 func init() { ...忽略dsn配置，请参考上面例子... // 声明err变量，下面不能使用:=赋值运算符，否则_db变量会当成局部变量，导致外部无法访问_db变量 var err error //连接MYSQL, 获得DB类型实例，用于后面的数据库读写操作。 _db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{}) if err != nil { panic("连接数据库失败, error=" + err.Error()) } sqlDB, _ := db.DB() //设置数据库连接池参数 sqlDB.SetMaxOpenConns(100) //设置数据库连接池最大连接数 sqlDB.SetMaxIdleConns(20) //连接池最大允许的空闲连接数，如果没有sql任务需要执行的连接数大于20，超过的连接会被连接池关闭。 } //获取gorm db对象，其他包需要执行数据库查询的时候，只要通过tools.getDB()获取db对象即可。 //不用担心协程并发使用同样的db对象会共用同一个连接，db对象在调用他的方法的时候会从数据库连接池中获取新的连接 func GetDB() *gorm.DB { return _db } ``` * 使用例子 ```go package main //导入tools包 import tools func main() { //获取DB db := tools.GetDB() //执行数据库查询操作 u := User{} //自动生成sql： SELECT * FROM `users` WHERE (username = 'tizi365') LIMIT 1 db.Where("username = ?", "tizi365").First(&u) } ``` ### GORM 插入数据 ```go /* 增 */ u := User{ Username: "张三", Password: "00000", } // db.Debug().Create(&u) // INSERT INTO `users` (`created_at`,`updated_at`,`deleted_at`,`username`,`password`,`id`) VALUES ('2022-08-23 18:32:01.618','2022-08-23 18:32:01.618',NULL,'张三','00000',1) if err := db.Create(&u).Error; err != nil { fmt.Println(err) return } // fmt.Println(u.ID) fmt.Println(u.Username) ``` ### GORM 查询数据 * Take > 查询一条数据 ```go db.Take(&User{}) // SELECT * FROM `users` LIMIT 1 ``` * First > 查询一条记录，根据主键ID排序(正序)，返回第一条记录 ```go db.First(&User{}) // SELECT * FROM `users` ORDER BY `users`.`id` ASC LIMIT 1 ``` * Last > 查询一条记录, 根据主键ID排序(倒序)，返回第一条记录 ```go db.Last(&User{}) // SELECT * FROM `users` ORDER BY `users`.`id` DESC LIMIT 1 ``` * Find > 查询多条记录，Find函数返回的是一个数组 ```go var us []User db.Find(&us) // SELECT * FROM `users` ``` * Pluck > 查询一列值 ```go var username []string db.Model(&User{}).Pluck("username", &username) ``` * where > 语法：db.Where(query interface{}, args ...interface{}) ```go // 传递单值 db.Where("id = ?", 10).Take(&User{}) // SELECT * FROM `users` WHERE (id = '10') LIMIT 1 // 传递数组 db.Where("id in (?)", []int{1,2,5,6}).Take(&User{}) // SELECT * FROM `users` WHERE (id in ('1','2','5','6')) LIMIT 1 // 传递两个占位符,返回数组 var us []User db.Where("created_at >= ? and created_at <= ?", "2018-11-06 00:00:00", "2018-11-06 23:59:59").Find(&us) // SELECT * FROM `users` WHERE (created_at >= '2018-11-06 00:00:00' and created_at <= '2018-11-06 23:59:59') // 通配符,返回数组 var us []User db.Where("username ?", "%可乐%").Find(&us) // SELECT * FROM `users` WHERE (username like '%可乐%') ``` * select > 设置select子句, 指定返回的字段 ```go // 返回指定字段 db.Select("username").Where("id = ?", 1).Take(&User{}) // SELECT id,title FROM `users` WHERE `username`.`id` = '1' AND ((id = '1')) LIMIT 1 // 返回指定多个字段 db.Select([]string{"username", "password"}).Where("id = ?", 1).Take(&User{}) // 聚合查询，统计数量 total := []int{} db.Debug().Model(&User{}).Select("count(*) as total").Pluck("total", &total) fmt.Println(total[0]) // SELECT count(*) as total FROM `users` WHERE `users`.`deleted_at` IS NULL ``` * order > 设置排序语句，order by子句 ```go var us []User db.Where("created_at >= ?", "2018-11-06 00:00:00").Order("created_at desc").Find(&us) // SELECT * FROM `users` WHERE (created_at >= '2018-11-06 00:00:00') ORDER BY created_at desc ``` * limit & Offset > 设置limit和Offset子句，分页的时候常用语句。 ```go // 指定页的几条数据 var us []User db.Order("created_at desc").Limit(10).Offset(1).Find(&us) // SELECT * FROM `users` WHERE `users`.`deleted_at` IS NULL ORDER BY created_at desc LIMIT 10 OFFSET 1 ``` * count > Count函数，直接返回查询匹配的行数。 ```go //这里也需要通过model设置模型，让gorm可以提取模型对应的表名 var total int64 = 0 db.Model(User{}).Count(&total) fmt.Println(total) // 6 // SELECT count(*) FROM `users` ``` * group by ```go //例子: //统计每个商品分类下面有多少个商品 //定一个Result结构体类型，用来保存查询结果 type Result struct { Type int Total int } var results []Result db.Model(User{}).Select("type, count(*) as total").Group("type").Having("total > 0").Scan(&results) // SELECT type, count(*) as total FROM `users` GROUP BY type HAVING (total > 0) //scan类似Find都是用于执行查询语句，然后把查询结果赋值给结构体变量，区别在于scan不会从传递进来的结构体变量提取表名. //这里因为我们重新定义了一个结构体用于保存结果，但是这个结构体并没有绑定foods表，所以这里只能使用scan查询函数。 ``` * 直接执行sql语句 > 对于复杂的查询，例如多表连接查询，我们可以直接编写sql语句，然后执行sql语句。 gorm通过db.Raw设置sql语句，通过Scan执行查询。 ```go sql := "SELECT type, count(*) as total FROM `users` where created_at > ? GROUP BY type HAVING (total > 0)" //因为sql语句使用了一个问号(?)作为绑定参数, 所以需要传递一个绑定参数(Raw第二个参数). //Raw函数支持绑定多个参数 db.Raw(sql, "2018-11-06 00:00:00").Scan(&results) fmt.Println(results) ``` ### GORM 更新数据 > 通过结构体变量更新字段值, gorm库会忽略零值字段。就是字段值等于0, nil, "", false这些值会被忽略掉，不会更新。如果想更新零值，可以使用map类型替代结构体。 * Save > 相当于根据主键id，更新所有模型字段值。 ```go u := User{} db.Where("id = ?", 1).Take(&u) u.Username = "三张" db.Save(&u) // UPDATE `users` SET `created_at`='2022-08-23 18:32:01.618',`updated_at`='2022-08-23 19:38:31.507',`deleted_at`=NULL,`username`='三张',`password`='00000' WHERE `users`.`deleted_at` IS NULL AND `id` = 1 ``` * Update > 更新单个字段值 ```go u := User{} db.Where("id = ?", 1).Take(&u) db.Model(&u).Update("password", "aabbcc") // UPDATE `users` SET `password`='aabbcc',`updated_at`='2022-08-23 20:30:24.292' WHERE `users`.`deleted_at` IS NULL AND `id` = 1 ``` > 自定义条件更新记录 ```go db.Model(&User{}).Where("created_at > ?", "2018-11-06 20:00:00").Update("password", "66666") // UPDATE `users` SET `password`='66666',`updated_at`='2022-08-24 14:33:17.06' WHERE created_at > '2018-11-06 20:00:00' AND `users`.`deleted_at` IS NULL ``` > 更新某个 id 的多个记录 ```go // 根据 ID 查询更新 data := User{ Username: "赵四", Password: "4444", } // 更新 id 为 2 的 username 和 passwor db.Debug().Model(&User{}).Where("id = ?", 2).Take(&User[]).Updates(&data) // UPDATE `users` SET `updated_at`='2022-08-24 14:48:23.084',`username`='赵四',`password`='4444' WHERE id = 2 AND `users`.`deleted_at` IS NULL LIMIT 1 ``` > 更新符合条件的记录 ```go data := User{ Username: "赵四", Password: "4444", } // 更新 id 大于 3 的字段 db.Debug().Model(&User{}).Where("id > ?", 3).Updates(&data) // UPDATE `users` SET `updated_at`='2022-08-24 14:51:36.631',`username`='赵四',`password`='4444' WHERE id > 3 AND `users`.`deleted_at` IS NULL ``` > 更新零值，使用 map 代替结构体去更新 ```go // 定义map类型，key为字符串，value为interface{}类型，方便保存任意值 data := make(map[string]interface{}) data["username"] = "王五" data["Password"] = "5555" db.Debug().Model(&User{}).Where("id = ?", 2).Updates(data) // UPDATE `users` SET `password`='5555',`username`='王五',`updated_at`='2022-08-24 14:56:54.841' WHERE id = 2 AND `users`.`deleted_at` IS NULL ``` > 计算更新表达式 *UPDATE `foods` SET `stock` = `stock` + 1 WHERE id = '2'*\ 这样的带计算表达式的更新语句gorm怎么写？ gorm提供了Expr函数用于设置表达式 ```go //等价于: UPDATE `foods` SET `stock` = stock + 1 WHERE `foods`.`id` = '2' db.Model(&food).Update("stock", gorm.Expr("stock + 1")) ``` ### GORM 删除数据 > 删除单条数据 ```go u := User{} db.Where("id = ?", 8).Take(&u).Delete(&u) // UPDATE `users` SET `deleted_at`='2022-08-24 15:04:31.893' WHERE id = 8 AND `users`.`deleted_at` IS NULL AND `users`.`id` = 8 LIMIT 1 ``` > 删除符合条件数据 ```go db.Where("id = ?", 8).Delete(&u) ``` ### GORM事务处理 * 自动事务 > 通过db.Transaction函数实现事务，如果闭包函数返回错误，则回滚事务。 ```go db.Transaction(func(tx *gorm.DB) error { // 在事务中执行一些 db 操作（从这里开始，您应该使用 'tx' 而不是 'db'） if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil { // 返回任何错误都会回滚事务 return err } if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil { return err } // 返回 nil 提交事务 return nil }) ``` * 手动事务 > 在开发中经常需要数据库事务来保证多个数据库写操作的原子性。例如电商系统中的扣减库存和保存订单。 ```go / 开启事务 tx := db.Begin() //在事务中执行数据库操作，使用的是tx变量，不是db。 //库存减一 //等价于: UPDATE `foods` SET `stock` = stock - 1 WHERE `foods`.`id` = '2' and stock > 0 //RowsAffected用于返回sql执行后影响的行数 rowsAffected := tx.Model(&food).Where("stock > 0").Update("stock", gorm.Expr("stock - 1")).RowsAffected if rowsAffected == 0 { //如果更新库存操作，返回影响行数为0，说明没有库存了，结束下单流程 //这里回滚作用不大，因为前面没成功执行什么数据库更新操作，也没什么数据需要回滚。 //这里就是举个例子，事务中可以执行多个sql语句，错误了可以回滚事务 tx.Rollback() return } err := tx.Create(保存订单).Error //保存订单失败，则回滚事务 if err != nil { tx.Rollback() } else { tx.Commit() } ``` ### 共用: 多表关联测试 ```go package main import ( "encoding/json" "fmt" "gorm.io/driver/mysql" "gorm.io/gorm" ) // 封装一个将 map 转换为字符串的方法 func MapToJson(data interface{}) string { byteStr, _ := json.Marshal(data) return string(byteStr) } func main() { //配置MySQL连接参数 username := "tizi365" //账号 password := "tizi365" //密码 host := "127.0.0.1" //数据库地址，可以是Ip或者域名 port := 3306 //数据库端口 Dbname := "tizi365" //数据库名 /* 通过前面的数据库参数，拼接 MYSQL DSN， 其实就是数据库连接串（数据源名称） MYSQL dsn格式： {username}:{password}@tcp({host}:{port})/{Dbname}?charset=utf8&parseTime=True&loc=Local */ dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname) db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) if err != nil { panic("连接数据库失败, error=" + err.Error()) } // 一对多 ... // 一多一 ... // 多对多 ... } ``` ### 一对多 > 继承共用代码 #### 一对多测试模型 ```go // 用户 type User struct { Id int `gorm:"type:int(11); autoIncrement;primaryKey;column:id;" json:"id"` // 主键id Name string `gorm:"type:varchar(30);not null;" json:"name" ` // 姓名 CreditCards []CreditCard `gorm:"foreignKey:UserID;constraint:OnUpdate:CASCADE,OnDelete:SET NULL;" json:"card"` // UserID 外键名称， 一对多的情况下，外键写在[多]的表结构下; 级联更新，删除时置空 } // 用户的多张信用卡 type CreditCard struct { Id int `gorm:"type:int(11); autoIncrement;primaryKey;column:id;" json:"id"` // 主键id Name string `gorm:"type:varchar(30);not null;" json:"name" ` // 信用卡银行 UserID uint `json:"user_id"` User User `json:"user"` // 反查使用，如通过信用卡查询到归属人 } // 设置表名，可以通过给struct类型定义 TableName函数，返回当前struct绑定的mysql表名是什么 func (u User) TableName() string { return "users" } func (u CreditCard) TableName() string { return "creditcard" } db.AutoMigrate(&User{}, &CreditCard{}) ``` #### 添加测试数据 ```go // 先添加一些测试数据 db.Create(&User{Name: "张三"}) db.Create(&User{Name: "赵四"}) db.Create(&User{Name: "王五"}) db.Create(&User{Name: "老六"}) var u1 User var u2 User db.First(&u1, "id = ?", 1) db.Create(&CreditCard{Name: "建设信用卡银行", UserID: uint(u1.Id)}) db.Create(&CreditCard{Name: "中信信用卡银行", UserID: uint(u1.Id)}) db.Create(&CreditCard{Name: "招商信用卡银行", UserID: uint(u1.Id)}) db.First(&u2, "id = ?", 2) db.Create(&CreditCard{Name: "农业信用卡银行", UserID: uint(u2.Id)}) db.Create(&CreditCard{Name: "中国信用卡银行", UserID: uint(u2.Id)}) db.Create(&CreditCard{Name: "招商信用卡银行", UserID: uint(u2.Id)}) ``` #### 查询某用户拥有几张信用卡 > 查询某个用户名下有几张信用卡 ```go var user []User query := db.Where("name = ?", "张三").Preload("CreditCards").Find(&user) if query.Error != nil { panic(query.Error) } fmt.Println(MapToJson(user)) ``` ```go [{"id":2,"name":"赵四","card":[{"id":4,"name":"农业信用卡银行","user_id":2,"user":{"id":0,"name":"","card":null}},{"id":5,"name":"中国信用卡银行","user_id":2,"user":{"id":0,"name":"","card":null}},{"id":6,"name":"招商信用卡银行","user_id":2,"user":{"id":0,"name":"","card":null}}]}] ``` #### 查询某ID的信用卡和归属用户 ```go var c CreditCard db.Where("id = ?", 2).First(&c) db.Joins("User").First(&c) fmt.Println(MapToJson(c)) ``` ```go {"id":2,"name":"中信信用卡银行","user_id":1,"user":{"id":1,"name":"张三","card":null}} ``` #### 查询所有用户和所属信用卡 ```go var u []User db.Preload("CreditCards").Find(&u) fmt.Println(MapToJson(u)) ``` ```go [{"id":1,"name":"张三","card":[{"id":1,"name":"建设信用卡银行","user_id":1,"user":{"id":0,"name":"","card":null}},{"id":2,"name":"中信信用卡银行","user_id":1,"user":{"id":0,"name":"","card":null}},{"id":3,"name":"招商信用卡银行","user_id":1,"user":{"id":0,"name":"","card":null}}]},{"id":2,"name":"赵四","card":[{"id":4,"name":"农业信用卡银行","user_id":2,"user":{"id":0,"name":"","card":null}},{"id":5,"name":"中国信用卡银行","user_id":2,"user":{"id":0,"name":"","card":null}},{"id":6,"name":"招商信用卡银行","user_id":2,"user":{"id":0,"name":"","card":null}}]},{"id":3,"name":"王五","card":[]},{"id":4,"name":"老六","card":[]}] ``` #### 查询所有信用卡和归属用户 ```go var c []CreditCard db.Joins("User").Find(&c) fmt.Println(MapToJson(c)) for key, value := range c { fmt.Println(key, value) } ``` ```go [{"id":1,"name":"建设信用卡银行","user_id":1,"user":{"id":1,"name":"张三","card":null}},{"id":2,"name":"中信信用卡银行","user_id":1,"user":{"id":1,"name":"张三","card":null}},{"id":3,"name":"招商信用卡银行","user_id":1,"user":{"id":1,"name":"张三","card":null}},{"id":4,"name":"农业信用卡银行","user_id":2,"user":{"id":2,"name":"赵四","card":null}},{"id":5,"name":"中国信用卡银行","user_id":2,"user":{"id":2,"name":"赵四","card":null}},{"id":6,"name":"招商信用卡银行","user_id":2,"user":{"id":2,"name":"赵四","card":null}}] 0 {1 建设信用卡银行 1 {1 张三 []}} 1 {2 中信信用卡银行 1 {1 张三 []}} 2 {3 招商信用卡银行 1 {1 张三 []}} 3 {4 农业信用卡银行 2 {2 赵四 []}} 4 {5 中国信用卡银行 2 {2 赵四 []}} 5 {6 招商信用卡银行 2 {2 赵四 []}} ``` #### 一对多，级联删除 > 删除用户，并会把此用户名下的信用卡所属 user\_id 设置为空 ```go var u User db.First(&u, "id = ?", 1) db.Delete(&u) ``` ### 一对一 #### 一对一模型 ```go // 用户 type User struct { Id int `gorm:"type:int(11); autoIncrement;primaryKey;column:id;" json:"id"` // 主键id Name string `gorm:"type:varchar(30);not null;" json:"name" ` // 姓名 } // 身份证号码 type IdCard struct { Id int `gorm:"type:int(11); autoIncrement;primaryKey;column:id;" json:"id"` // 主键id Number string `gorm:"type:varchar(30);not null;" json:"number" ` // 身份证号码 UserID int `gorm:"unique;" json:"user_id"` // 设置为唯一,关联外键 User User `json:"user"` // 反查使用 } // 设置表名，可以通过给struct类型定义 TableName函数，返回当前struct绑定的mysql表名是什么 func (u User) TableName() string { return "users" } func (u IdCard) TableName() string { return "idcard" } db.AutoMigrate(&User{}, &IdCard{}) ``` #### 用户查询自身份证 > Joins 连表方式 ```go var us []map[string]interface{} // 连表查询 table1.id table1.name table2.number db.Model(&User{}).Select("users.id", "users.name", "idcard.number").Joins("left join idcard on users.id = idcard.user_id").Scan(&us) fmt.Println(MapToJson(us)) // [{"id":1,"name":"张三","number":"33333333333"},{"id":2,"name":"赵四","number":"44444444444"},{"id":3,"name":"王五","number":"55555555555"}] ``` #### 身份证反向查询用户 ```go var c []IdCard db.Preload(User").Find(&c) fmt.Println(MapToJson(c)) [ {"id":1,"number":"33333333333","user_id":1,"user":{"id":1,"name":"张三"}}, {"id":2,"number":"44444444444","user_id":2,"user":{"id":2,"name":"赵四"}}, {"id":3,"number":"55555555555","user_id":3,"user":{"id":3,"name":"王五"}} ] ``` ### 多对多 > 举例账号和角色的关联关系； 一个账号可以有多个角色，一个角色也可以给多个账号的关联 如果查看数据库的话，会发现有三张表，多出的一张表是存储 角色和账户的关系： account\_role ```go // 账户表 type AccountEntity struct { Id int `json:"id"` Name string `json:"name"` Roles []*RoleEntity `json:"roles" gorm:"many2many:account_role;foreignKey:Id;joinForeignKey:accountId;joinReferences:roleId;"` } // 角色 type RoleEntity struct { Id int64 `json:"id"` Title string `json:"title"` Accounts []*AccountEntity `json:"accounts" gorm:"many2many:account_role;foreignKey:Id;joinForeignKey:RoleId;joinReferences:accountId"` } // 设置表名，可以通过给struct类型定义 TableName函数，返回当前struct绑定的mysql表名是什么 func (u AccountEntity) TableName() string { return "account" } func (u RoleEntity) TableName() string { return "role" } ``` * many2many:account\_role 定义中间表名为:account\_role * foreignKey:Id 使用当前表的id作为外键 * joinForeignKey:accountId 当前数据模型外键关联到中间件表的字段名叫accountId * joinReferences:roleId 反向引用字段，如果是账号表就要写中间表的roleId #### 添加测试数据 ```go // 添加测试数据 a1 := AccountEntity{Name: "账户一"} a2 := AccountEntity{Name: "账户二"} a3 := AccountEntity{Name: "账户三"} db.Create(&a1) db.Create(&a2) db.Create(&a3) r1 := RoleEntity{Title: "角色一"} r2 := RoleEntity{Title: "角色二"} r3 := RoleEntity{Title: "角色三"} db.Create(&r1) db.Create(&r2) db.Create(&r3) // 生成用户和角色关联语句 db.Debug().Model(&a1).Association("Roles").Append([]RoleEntity{r1, r2, r3}) db.Debug().Model(&a2).Association("Roles").Append([]RoleEntity{r1, r2}) db.Debug().Model(&a3).Association("Roles").Append([]RoleEntity{r2, r3}) // INSERT INTO `account_role` (`account_id`,`role_id`) VALUES (1,1),(1,2),(1,3) ON DUPLICATE KEY UPDATE `account_id`=`account_id` ``` #### 通过用户查询角色 ```go var accountList []AccountEntity db.Preload("Roles").Find(&accountList) fmt.Println(MapToJson(accountList)) ``` ```go [ { "id": 1, "name": "账户一", "roles": [ {"id": 1,"title": "角色一","accounts": null}, {"id": 2,"title": "角色二","accounts": null}, {"id": 3,"title": "角色三","accounts": null} ] }, { "id": 2, "name": "账户二", "roles": [ {"id": 1,"title": "角色一","accounts": null}, {"id": 2,"title": "角色二","accounts": null} ] }, { "id": 3, "name": "账户三", "roles": [ {"id": 2,"title": "角色二","accounts": null}, {"id": 3,"title": "角色三","accounts": null}] } ] ``` #### 通过角色反查用户 ```go var roleList []RoleEntity db.Preload("Accounts").Find(&roleList) fmt.Println(MapToJson(roleList)) ``` ```go [ { "id": 1, "title": "角色一", "accounts": [ {"id": 1,"name": "账户一","roles": null}, {"id": 2,"name": "账户二","roles": null} ] }, { "id": 2, "title": "角色二", "accounts": [ {"id": 1,"name": "账户一","roles": null}, {"id": 2,"name": "账户二","roles": null}, {"id": 3,"name": "账户三","roles": null} ] }, { "id": 3, "title": "角色三", "accounts": [ {"id": 1,"name": "账户一","roles": null}, {"id": 3,"name": "账户三","roles": null} ] } ] ``` ### 参考地址 * [关于gorm多表关联关系查询使用案例 - 掘金](https://juejin.cn/post/7067138794788487181#heading-0) * [gorm中的基本查询](https://www.shuzhiduo.com/A/obzbaxvMdE/) ## Beforce ### GORM 模型定义 #### 内置模型约定 * 默认情况下： GORM 倾向于约定，而不是配置。默认情况下，GORM 使用 ID 作为主键，使用结构体名的 蛇形复数 作为表名，字段名的 蛇形 作为列名，并使用 CreatedAt、UpdatedAt 字段追踪创建、更新时间 例如: ```go type User struct { // 未自定义，默认为 user 表 // ID uint // 未自定义，创建表，默认会添加ID字段，并设置为主键 Name string Email *string Age uint8 Birthday *time.Time MemberNumber sql.NullString ActivatedAt sql.NullTime // CreatedAt time.Time // 未自定义，默认添加; 添加数据，默认添加创建时间 // UpdatedAt time.Time // 未自定义，默认添加; 更新数据，默认更新为当前时间 } ``` #### 自定义匿名字段模型约定 > 默认是有一个 gorm.Model, 但是我不想用，我想自定义，让所有表中都携带我自定义的字段 ```go // 建立 gorm.Model 全局匿名字段模型(可复用到任何模型当中) type Model struct { ID uint `gorm:"primaryKey"` // 设置主键 CreatedAt time.Time // 创建时间 UpdatedAt time.Time // 更新时间 DeletedAt *time.Time // 删除时间 } // 嵌入到你自己创建的模型中， 以 用户表 为例 // 这样就可以将字段 `ID`, `CreatedAt`, `UpdatedAt`, `DeletedAt` 注入到 `User` 模型中 type User struct { gorm.Model Name string } // 上面 User 表等效于 type User struct { ID uint `gorm:"primaryKey"` Name string CreatedAt time.Time UpdatedAt time.Time DeletedAt *time.Time } ``` #### 自定义正常字段模型约定 * 比如某些公共的字段，可以被其他结构体调用 ```go type Author struct { Name string Email string } type Blog struct { ID int Author Author `gorm:"embedded"` Upvotes int32 } // 等效于 type Blog struct { ID int64 Name string Email string Upvotes int32 } ``` | 标签名 | 说明 | 示例 | | ---------------------- | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- | | column | 指定 db 列名 | `gorm:"column:username"` | | type |

数据类型
bool、int、uint、float、string、time、bytes

|

gorm:"type:int" // 设置类型为int
gorm:"type:varchar(20);not null "

| | size | 指定列大小 | `gorm:"size:255"` // 设置字段大小为255 | | primaryKey | 指定列为主键 | `gorm:"primaryKey"` | | unique | 指定列为唯一 | `gorm:"unique"` // 唯一 | | default | 指定列的默认值 | `gorm:"default:0"` // 默认值为0 | | precision | 指定列的精度 | | | scale | 指定列大小 | | | not null | 指定列为 NOT NULL | `gorm:"not null"` // 不为空 | | autoIncrement | 指定列为自动增长 | `gorm:"AUTO_INCREMENT"` | | autoIncrementIncrement | 自动步长，控制连续记录之间的间隔 | | | embedded | 嵌套字段 | `gorm:"embedded"` | | embeddedPrefix | 嵌入字段的列名前缀 | | | autoCreateTime | 创建时追踪当前时间,对于 int 字段，它会追踪秒级时间戳,使用 nano/milli 来追踪纳秒、毫秒时间戳 | `gorm:"embedded;embeddedPrefix:xxxx_"` | | autoUpdateTime | 创建/更新时追踪当前时间,对于 int 字段，它会追踪秒级时间戳，您可以使用 nano/milli 来追踪纳秒、毫秒时间戳，例如：autoUpdateTime:milli | | | index | 根据参数创建索引，多个字段使用相同的名称则创建复合索引，查看 索引 获取详情 |

gorm:"index"
gorm:"index:addr"// 给address字段创建名为addr的索引

| | uniqueIndex | 与 index 相同，但创建的是唯一索引 | | | check | 创建检查约束 | check:age > 13 | | <- | 设置字段写入的权限， <-:create 只创建、<-:update 只更新、<-:false 无写入权限、<- 创建和更新权限 | \`gorm:"<-:create" | | -> | 设置字段读的权限，->:false 无读权限 | | | - | 忽略该字段，- 无读写权限 | `gorm:"-"` // 忽略本字段 | | comment | 迁移时为字段添加注释 | `gorm:"column:beast_id"` // 设置列名为 `beast_id` | #### 表字段标签 ```go type User struct { Name string `gorm:"<-:create"` // 允许读和创建 Name string `gorm:"<-:update"` // 允许读和更新 Name string `gorm:"<-"` // 允许读和写（创建和更新） Name string `gorm:"<-:false"` // 允许读，禁止写 Name string `gorm:"->"` // 只读（除非有自定义配置，否则禁止写） Name string `gorm:"->;<-:create"` // 允许读和写 Name string `gorm:"->:false;<-:create"` // 仅创建（禁止从 db 读） Name string `gorm:"-"` // 通过 struct 读写会忽略该字段 } ``` ```go type User struct { CreatedAt time.Time // 在创建时，如果该字段值为零值，则使用当前时间填充 UpdatedAt int // 在创建时该字段值为零值或者在更新时，使用当前时间戳秒数填充 Updated int64 `gorm:"autoUpdateTime:nano"` // 使用时间戳填纳秒数充更新时间 Updated int64 `gorm:"autoUpdateTime:milli"` // 使用时间戳毫秒数填充更新时间 Created int64 `gorm:"autoCreateTime"` // 使用时间戳秒数填充创建时间 } ``` #### 表关联标签 | 标签 | 描述 | | ---------------- | ----------------------------- | | foreignKey | 指定当前模型的列作为连接表的外键 | | references | 指定引用表的列名，其将被映射为连接表外键 | | polymorphic | 指定多态类型，比如模型名 | | polymorphicValue | 指定多态值、默认表名 | | many2many | 指定连接表表名 | | joinForeignKey | 指定连接表的外键列名，其将被映射到当前表 | | joinReferences | 指定连接表的外键列名，其将被映射到引用表 | | constraint | 关系约束，例如：`OnUpdate`、`OnDelete` | #### 复数表名(表名) > 表名是结构体名称的复数形式 ```go type User struct {} // 默认的表名是 `users` // 设置 `User` 的表名为 `profiles` func (User) TableName() string { return "profiles" } func (u User) TableName() string { if u.Role == "admin" { return "admin_users" } else { return "users" } } // 如果设置禁用表名复数形式属性为 true，`User` 的表名将是 `user` db.SingularTable(true) ``` ### GORM 数据库连接 > GORM 官方支持的数据库类型有： MySQL, PostgreSQL, SQlite, SQL Server > 官方通往: > > 或者参考: [惯例 - 人人学go](http://www.golang.ren/article/5446)[惯例 - 人人学go](http://www.golang.ren/article/5446) #### MYSQL 官方指南配置 ```go // 简单配置 import ( "gorm.io/driver/mysql" "gorm.io/gorm" ) func main() { dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local" db, err := gorm.Open(mysql.Open(dsn)) } // 使用 mysql.New 函数, 传递一个mysql.Config进行详细配置 dsn := "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=true&loc=UTC" db, err := gorm.Open(mysql.New(mysql.Config{ DSN: dsn, // DSN data source name DefaultStringSize: 256, // string 类型字段的默认长度 DisableDatetimePrecision: true, // 禁用 datetime 精度，MySQL 5.6 之前的数据库不支持 DontSupportRenameIndex: true, // 重命名索引时采用删除并新建的方式，MySQL 5.7 之前的数据库和 MariaDB 不支持重命名索引 DontSupportRenameColumn: true, // 用 `change` 重命名列，MySQL 8 之前的数据库和 MariaDB 不支持重命名列 SkipInitializeWithVersion: false, // 根据当前 MySQL 版本自动配置 })) ``` **mysql.Config的源码** ```go type Config struct { DriverName string DSN string Conn gorm.ConnPool SkipInitializeWithVersion bool DefaultStringSize uint DefaultDatetimePrecision *int DisableDatetimePrecision bool DontSupportRenameIndex bool DontSupportRenameColumn bool DontSupportForShareClause bool } ``` #### gorm调试模式 ```go result := db.Debug().Where("username = ?", "tizi365").First(&u) ``` #### MYSQL 单机测试使用 * 示例一 ```go package main import ( "fmt" //_ "github.com/go-sql-driver/mysql" //"github.com/jinzhu/gorm" "gorm.io/driver/mysql" "gorm.io/gorm" ) type Students struct { gorm.Model Username string `gorm:"type:varchar(20);not null " ` Password string `gorm:"type:varchar(500);not null" ` Age int `gorm:"type:int;DEFAULT:18" ` } func main() { // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情 dsn := "luffyapi:Luffy123?@tcp(127.0.0.1:3306)/luffyapi?charset=utf8mb4&parseTime=True&loc=Local" db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) if err != nil { fmt.Println("连接数据库出错：", err) } db.AutoMigrate(&Students{}) user := Students{Username: "Jinzhu", Age: 18, Password: "123456"} result := db.First(&user) fmt.Println(result) db.Take(&user) //result := db.Create(&user) // 通过数据的指针来创建 //fmt.Println(result) } ``` #### MYSQL 封装测试调用 * main ```go package main import ( "day01/tools" //day01,是初始化项目名，导入tools包 "fmt" "gorm.io/gorm" ) type Students struct { gorm.Model Username string `gorm:"type:varchar(20);not null " ` Password string `gorm:"type:varchar(500);not null" ` Age int `gorm:"type:int;DEFAULT:18" ` } func main() { db := tools.GetDB() // 自动创建表 db.AutoMigrate(&Students{}) // 创建一条数据 user := Students{Username: "Jinzhu", Age: 18, Password: "123456"} result := db.Create(&user) // 通过数据的指针来创建 fmt.Println(result) } ``` * tools/tools.go 封装 mysql （测试使用） ```go // 1、package tools 定义一个工具包，用来管理 gorm 数据连接池的初始化工作 // 2、var _db *gorm.DB 定义全局的 db 对象, 执行数据库操作通过它实现 // 3、初始化 gorm； golang特性，每个包初始化的时候会自动执行 init 函数 // 4、启用数据库连接池，千万不要使用完db后调用db.Close关闭数据库连接，这样会导致整个数据库连接池关闭，导致连接池没有可用的连接。 package tools import ( "fmt" "time" "gorm.io/driver/mysql" "gorm.io/gorm" ) var _db *gorm.DB func init() { username := "go_test" // 账号 password := "go_test" // 密码 host := "127.0.0.1" // 数据库地址 port := 3306 // 数据库端口 Dbname := "go_test" // 数据库名 charset := "utf8" // 字符集 parseTime := true // 是否支持时间类型转换 loc := "Local" // 使用系统本地时区 timeout := "10s" // 连接超时，10秒 readTimeout := "30s" // 读超时时间 writeTimeout := "60s" // 写超时时间 // 拼接数据库 dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=%s&parseTime=%v&loc=%s&timeout=%s&readTimeout=%s&writeTimeout=%s", username, password, host, port, Dbname, charset, parseTime, loc, timeout, readTimeout, writeTimeout) // 声明err变量，下面不能使用:=赋值运算符，否则_db变量会当成局部变量，导致外部无法访问_db变量 var err error _db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{}) if err != nil { panic("连接数据库失败, error=" + err.Error()) } sqlDB, _ := _db.DB() sqlDB.SetConnMaxLifetime(time.Second * 10) // 5秒内连接没有活跃的话则自动关闭连接 sqlDB.SetMaxOpenConns(100) // 设置数据库连接池最大连接数 sqlDB.SetMaxIdleConns(20) // 连接池最大允许的空闲连接数，如果没有sql任务需要执行的连接数大于20，超过的连接会被连接池关闭。 } // 获取gorm db对象，其他包需要执行数据库查询的时候，只要通过tools.getDB()获取db对象即可。 func GetDB() *gorm.DB { return _db } ``` ### viper #### 安装 Viper ```go go get github.com/spf13/viper ``` #### Viper 作用 * 设置默认值 * 读取 JSON、TOML、YAML（YML）、HCL、envfile 和 Java properties 属性配置文件 * 实时查看和重读配置文件（可选） * 从环境变量中读取 * 从远程配置系统（etcd 或 Consor）读取数据，并观察变化 * 从命令行标志读取 * 从缓冲区读取 * 设置显式值 #### Viper获取值 > 每一个Get方法在找不到值的时候都会返回零值。为了检查给定的键是否存在，提供了IsSet()方法。 ```go Get(key string) : interface{} GetBool(key string) : bool GetFloat64(key string) : float64 GetInt(key string) : int GetIntSlice(key string) : []int GetString(key string) : string GetStringMap(key string) : map[string]interface{} GetStringMapString(key string) : map[string]string GetStringSlice(key string) : []string GetTime(key string) : time.Time GetDuration(key string) : time.Duration IsSet(key string) : bool AllSettings() : map[string]interface{} ``` ```go // 例如 viper.GetString("logfile") // 不区分大小写的设置和获取 if viper.GetBool("verbose") { fmt.Println("verbose enabled") } ``` #### 读取配置文件 ``` viper.SetDefault("ContentDir", "content") // 设置默认值 viper.SetDefault("Taxonomies", map[string]string{"tag": "tags", "category": "categories"}) viper.SetConfigFile("./config.yaml") // 指定配置文件路径 viper.SetConfigName("config") // 配置文件名称(无扩展名) viper.SetConfigType("yaml") // 如果配置文件的名称中没有扩展名，则需要配置此项 viper.AddConfigPath("/etc/appname/") // 查找配置文件所在的路径 viper.AddConfigPath("$HOME/.appname") // 多次调用以添加多个搜索路径 viper.AddConfigPath(".") // 还可以在工作目录中查找配置 err := viper.ReadInConfig() // 查找并读取配置文件 if err != nil { // 处理读取配置文件的错误 panic(fmt.Errorf("Fatal error config file: %s \n", err)) } // 或者处理加载配置文件出错时 if err := viper.ReadInConfig(); err != nil { if _, ok := err.(viper.ConfigFileNotFoundError); ok { // 配置文件未找到错误；如果需要可以忽略 } else { // 配置文件被找到，但产生了另外的错误 } } // 配置文件找到并成功解析 ``` #### 写入配置文件 * WriteConfig - 将当前的viper配置写入预定义的路径并覆盖（如果存在的话）。如果没有预定义的路径，则报错。 * SafeWriteConfig - 将当前的viper配置写入预定义的路径。如果没有预定义的路径，则报错。如果存在，将不会覆盖当前的配置文件。 * WriteConfigAs - 将当前的viper配置写入给定的文件路径。将覆盖给定的文件(如果它存在的话)。 * SafeWriteConfigAs - 将当前的viper配置写入给定的文件路径。不会覆盖给定的文件(如果它存在的话)。 ```go viper.WriteConfig() // 将当前配置写入“viper.AddConfigPath()”和“viper.SetConfigName”设置的预定义路径 viper.SafeWriteConfig() // 不会覆盖任何文件，而是直接创建（如果不存在），而默认行为是创建或截断 viper.WriteConfigAs("/path/to/my/.config") viper.SafeWriteConfigAs("/path/to/my/.config") // 因为该配置文件写入过，所以会报错 viper.SafeWriteConfigAs("/path/to/my/.other_config") ``` #### 监控配置文件热加载 > 只需告诉viper实例watchConfig。可选地，你可以为Viper提供一个回调函数，以便在每次发生更改时运行。 ```go viper.WatchConfig() viper.OnConfigChange(func(e fsnotify.Event) { // 配置文件发生变更之后会调用的回调函数 fmt.Println("Config file changed:", e.Name) }) ``` #### 从io.Reader读取配置 > Viper预先定义了许多配置源，如文件、环境变量、标志和远程K/V存储，但你不受其约束。你还可以实现自己所需的配置源并将其提供给viper。 ```go viper.SetConfigType("yaml") // 或者 viper.SetConfigType("YAML") // 任何需要将此配置添加到程序中的方法。 var yamlExample = []byte(` Hacker: true name: steve hobbies: - skateboarding - snowboarding - go clothing: jacket: leather trousers: denim age: 35 eyes : brown beard: true `) viper.ReadConfig(bytes.NewBuffer(yamlExample)) viper.Get("name") // 这里会得到 "steve" ``` #### 远程Key/Value存储示例 ```go // etcd 存储 viper.AddRemoteProvider("consul", "localhost:8500", "MY_CONSUL_KEY") viper.SetConfigType("json") // 需要显示设置成json err := viper.ReadRemoteConfig() fmt.Println(viper.Get("port")) // 8080 fmt.Println(viper.Get("hostname")) // liwenzhou.com // consul 存储 viper.AddRemoteProvider("consul", "localhost:8500", "MY_CONSUL_KEY") viper.SetConfigType("json") // 需要显示设置成json err := viper.ReadRemoteConfig() fmt.Println(viper.Get("port")) // 8080 fmt.Println(viper.Get("hostname")) // liwenzhou.com // firestore viper.AddRemoteProvider("firestore", "google-cloud-project-id", "collection/document") viper.SetConfigType("json") // 配置的格式: "json", "toml", "yaml", "yml" err := viper.ReadRemoteConfig() ``` #### 更多其他方法参考 > #### 示例读取(ini,yaml) 当前路径下有两个文件 ```go // configA.ini ;MYSQL数据库配置 [db] username=admin password=123 host=127.0.0.1 port=3306 dbname=dbname ;网络配置 [web] port=8080 // configB.yaml # MYSQL数据库配置 db: username: admin password: 123 host: 127.0.0.1 port: 3306 dbname: dbname # 网络配置 web: port: 8088 # APP配置 app: {id: 10,time: 05/30} ``` ```go // main.go package main import ( "fmt" "os" "github.com/spf13/viper" ) // 当前文件路径 func getPath() string { path, err := os.Getwd() if err != nil { panic(err) } return path } // 读取文件 func ReadConfig(_path, _name, _type string) { v := viper.New() v.AddConfigPath(_path + "/") v.SetConfigName(_name) v.SetConfigType(_type) err := v.ReadInConfig() if err != nil { if _, ok := err.(viper.ConfigFileNotFoundError); ok { fmt.Println("找不到配置文件..") } else { fmt.Println("配置文件出错..") } } username := v.GetString("db.username") password := v.GetString("db.password") host := v.GetString("db.host") port := v.GetInt("db.port") dbname := v.GetString("db.dbname") dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, dbname) fmt.Printf("dsn: %v\n", dsn) } // 每个 go 文件内都有 init 初始化函数，默认先执行 func init() { path := getPath() ReadConfig(path, "configA", "ini") // 读取 configA.ini ReadConfig(path, "configB", "yaml") // 读取 configB.yaml } func main() { } ``` ```go $ go run main.go dsn: admin1:123@tcp(127.0.0.1:3306)/dbname?charset=utf8&parseTime=True&loc=Local dsn: admin2:123@tcp(127.0.0.1:3306)/dbname?charset=utf8&parseTime=True&loc=Local ```