Gorm 基础

Gorm 快速入门

GORM github地址: https://github.com/go-gorm/gorm GORM 官网地址： https://gorm.io/zh_CN/docs/

主操作： MYSQL

安装

//安装MySQL驱动、gorm包
go get -u gorm.io/driver/mysql
go get -u gorm.io/gorm

增删改查

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 语句

result := db.Debug().Where("username = ?", "tizi365").First(&u)

GORM 高并发

提高数据库连接的使用率，避免重复建立数据库连接带来的性能消耗，会经常使用数据库连接池技术来维护数据库连接。

1、定义tools包，负责数据库初始化工作

//定义一个工具包，用来管理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
}

使用例子

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 插入数据

    /* 增 */
    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

查询一条数据

db.Take(&User{}) 
// SELECT * FROM `users`   LIMIT 1

First

查询一条记录，根据主键ID排序(正序)，返回第一条记录

db.First(&User{})
// SELECT * FROM `users`   ORDER BY `users`.`id` ASC LIMIT 1

Last

查询一条记录, 根据主键ID排序(倒序)，返回第一条记录

db.Last(&User{}) 
// SELECT * FROM `users`   ORDER BY `users`.`id` DESC LIMIT 1

Find

查询多条记录，Find函数返回的是一个数组

var us []User
db.Find(&us)

// SELECT * FROM `users`

Pluck

查询一列值

var username []string
db.Model(&User{}).Pluck("username", &username)

where

语法：db.Where(query interface{}, args ...interface{})

// 传递单值
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子句, 指定返回的字段

// 返回指定字段
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子句

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子句，分页的时候常用语句。

// 指定页的几条数据
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函数，直接返回查询匹配的行数。

//这里也需要通过model设置模型，让gorm可以提取模型对应的表名
var total int64 = 0
db.Model(User{}).Count(&total)
fmt.Println(total)   // 6
// SELECT count(*) FROM `users`

group by

//例子:
//统计每个商品分类下面有多少个商品
//定一个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执行查询。

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，更新所有模型字段值。

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

更新单个字段值

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

自定义条件更新记录

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 的多个记录

// 根据 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

更新符合条件的记录

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 代替结构体去更新

// 定义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函数用于设置表达式

//等价于: UPDATE `foods` SET `stock` = stock + 1  WHERE `foods`.`id` = '2'
db.Model(&food).Update("stock", gorm.Expr("stock + 1"))

GORM 删除数据

删除单条数据

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

删除符合条件数据

db.Where("id = ?", 8).Delete(&u)

GORM事务处理

自动事务

通过db.Transaction函数实现事务，如果闭包函数返回错误，则回滚事务。

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
})

手动事务

在开发中经常需要数据库事务来保证多个数据库写操作的原子性。例如电商系统中的扣减库存和保存订单。

/ 开启事务
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()
}

共用: 多表关联测试

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())
    }

    // 一对多
    ...
    // 一多一
    ...
    // 多对多
    ...
}

一对多

继承共用代码

一对多测试模型

// 用户
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{})

添加测试数据

// 先添加一些测试数据
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)})

查询某用户拥有几张信用卡

查询某个用户名下有几张信用卡

var user []User

query := db.Where("name = ?", "张三").Preload("CreditCards").Find(&user)
if query.Error != nil {
    panic(query.Error)
}
fmt.Println(MapToJson(user))

[{"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的信用卡和归属用户

var c CreditCard

db.Where("id = ?", 2).First(&c)
db.Joins("User").First(&c)
fmt.Println(MapToJson(c))

{"id":2,"name":"中信信用卡银行","user_id":1,"user":{"id":1,"name":"张三","card":null}}

查询所有用户和所属信用卡

var u []User

db.Preload("CreditCards").Find(&u)
fmt.Println(MapToJson(u))

[{"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":[]}]

查询所有信用卡和归属用户

var c []CreditCard

db.Joins("User").Find(&c)
fmt.Println(MapToJson(c))
for key, value := range c {
    fmt.Println(key, value)
}

[{"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 设置为空

var u User
db.First(&u, "id = ?", 1)
db.Delete(&u)

一对一

一对一模型

// 用户
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 连表方式

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"}]

身份证反向查询用户

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

// 账户表
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

添加测试数据

// 添加测试数据
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`

通过用户查询角色

var accountList []AccountEntity
db.Preload("Roles").Find(&accountList)

fmt.Println(MapToJson(accountList))

[
    {
        "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}]
    }
]

通过角色反查用户

var roleList []RoleEntity
db.Preload("Accounts").Find(&roleList)

fmt.Println(MapToJson(roleList))

[
    {
        "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}
        ]
    }
]

参考地址

Beforce

GORM 模型定义

内置模型约定

默认情况下： GORM 倾向于约定，而不是配置。默认情况下，GORM 使用 ID 作为主键，使用结构体名的蛇形复数作为表名，字段名的蛇形作为列名，并使用 CreatedAt、UpdatedAt 字段追踪创建、更新时间

例如:

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, 但是我不想用，我想自定义，让所有表中都携带我自定义的字段

// 建立 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
}

自定义正常字段模型约定

比如某些公共的字段，可以被其他结构体调用

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

表字段标签

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 读写会忽略该字段
}

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

复数表名(表名)

表名是结构体名称的复数形式

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

官方通往: https://gorm.io/zh_CN/docs/connecting_to_the_database.html
或者参考: 惯例 - 人人学go 惯例 - 人人学go

MYSQL 官方指南配置

// 简单配置
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的源码

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调试模式

result := db.Debug().Where("username = ?", "tizi365").First(&u)

MYSQL 单机测试使用

示例一

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

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 （测试使用）

// 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 get github.com/spf13/viper

Viper 作用

设置默认值
读取 JSON、TOML、YAML（YML）、HCL、envfile 和 Java properties 属性配置文件
实时查看和重读配置文件（可选）
从环境变量中读取
从远程配置系统（etcd 或 Consor）读取数据，并观察变化
从命令行标志读取
从缓冲区读取
设置显式值

Viper获取值

每一个Get方法在找不到值的时候都会返回零值。为了检查给定的键是否存在，提供了IsSet()方法。

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{}

// 例如
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配置写入给定的文件路径。不会覆盖给定的文件(如果它存在的话)。

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提供一个回调函数，以便在每次发生更改时运行。

viper.WatchConfig()
viper.OnConfigChange(func(e fsnotify.Event) {
  // 配置文件发生变更之后会调用的回调函数
    fmt.Println("Config file changed:", e.Name)
})

从io.Reader读取配置

Viper预先定义了许多配置源，如文件、环境变量、标志和远程K/V存储，但你不受其约束。你还可以实现自己所需的配置源并将其提供给viper。

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存储示例

// 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)

当前路径下有两个文件

// 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}

// 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 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

PreviousGo 基础 NextGo中&与的区别以及使用

Last updated 2 years ago

Gorm 快速入门

GORM 调试模式

GORM 高并发

GORM 插入数据

GORM 查询数据

GORM 更新数据

GORM 删除数据

GORM事务处理

共用: 多表关联测试

一对多

一对多测试模型

添加测试数据

查询某用户拥有几张信用卡

查询某ID的信用卡和归属用户

查询所有用户和所属信用卡

查询所有信用卡和归属用户

一对多，级联删除

一对一

一对一模型

用户查询自身份证

身份证反向查询用户

多对多

添加测试数据

通过用户查询角色

通过角色反查用户

参考地址

Beforce

GORM 模型定义

内置模型约定

自定义匿名字段模型约定

自定义正常字段模型约定

表字段标签

表关联标签

复数表名(表名)

GORM 数据库连接

MYSQL 官方指南配置

gorm调试模式

MYSQL 单机测试使用

MYSQL 封装测试调用

viper

安装 Viper

Viper 作用

Viper获取值

读取配置文件

写入配置文件

监控配置文件热加载

从io.Reader读取配置

远程Key/Value存储示例

更多其他方法参考

示例读取(ini,yaml)