go-zero 中使用 gorm gen

由于go-zero自带的sqlx太难用, 是在无法忍受写这么多的魔法字符串, 所以这边在go-zero中引入gorm

代码

• cmd/gen.go

package main

import (
    "fmt"
    "path"

    "gorm.io/driver/mysql"
    "gorm.io/gen"
    "gorm.io/gen/field"
    "gorm.io/gorm"
)

var (
    // 生成别的服务时修改以下配置, 数据库连接, 输出目录, 模型目录
    // do 是生成的, 自定义可以用作 dao
    mysqlDsn  = "xxx:xxx@tcp(127.0.0.1:3306)/xxx?charset=utf8mb4&loc=Local&parseTime=true"
    outPath   = path.Join("..", "app", "account", "model", "do")
    modelPath = "entity"
)

func main() {

    // 连接数据库
    db, err := gorm.Open(mysql.Open(mysqlDsn))
    if err != nil {
        panic(fmt.Errorf("cannot establish db connection: %w", err))
    }

    // 生成实例
    g := gen.NewGenerator(gen.Config{
        // 相对执行`go run`时的路径, 会自动创建目录
        OutPath:      outPath,
        ModelPkgPath: modelPath,

        // WithDefaultQuery 生成默认查询结构体(作为全局变量使用), 即`Q`结构体和其字段(各表模型)
        // WithoutContext 生成没有context调用限制的代码供查询
        // WithQueryInterface 生成interface形式的查询代码(可导出), 如`Where()`方法返回的就是一个可导出的接口类型
        Mode: gen.WithDefaultQuery | gen.WithoutContext,

        // 表字段可为 null 值时, 对应结体字段使用指针类型
        FieldNullable: true,

        // 表字段默认值与模型结构体字段零值不一致的字段, 在插入数据时需要赋值该字段值为零值的, 结构体字段须是指针类型才能成功, 即`FieldCoverable:true`配置下生成的结构体字段.
        // 因为在插入时遇到字段为零值的会被GORM赋予默认值. 如字段`age`表默认值为10, 即使你显式设置为0最后也会被GORM设为10提交.
        // 如果该字段没有上面提到的插入时赋零值的特殊需要, 则字段为非指针类型使用起来会比较方便.
        FieldCoverable: false,
        // 模型结构体字段的数字类型的符号表示是否与表字段的一致, `false`指示都用有符号类型
        FieldSignable: true,
        // 生成 gorm 标签的字段索引属性
        FieldWithIndexTag: true,
        // 生成 gorm 标签的字段类型属性
        FieldWithTypeTag: true,
    })
    // 设置目标 db
    g.UseDB(db)

    // 自定义模型结体字段的标签
    // 将特定字段名的 json 标签加上`string`属性,即 MarshalJSON 时该字段由数字类型转成字符串类型

    // 将非默认字段名的字段定义为自动时间戳和软删除字段;
    // 自动时间戳默认字段名为:`updated_at`、`created_at, 表字段数据类型为: INT 或 DATETIME
    // 软删除默认字段名为:`deleted_at`, 表字段数据类型为: DATETIME
    autoUpdateTimeField := gen.FieldGORMTag("updated_at", func(tag field.GormTag) field.GormTag {
        tag.Set("column", "updated_at")
        tag.Set("type", "timestamp")
        tag.Set("autoUpdateTime", "")
        return tag
    })
    autoCreateTimeField := gen.FieldGORMTag("created_at", func(tag field.GormTag) field.GormTag {
        tag.Set("column", "created_at")
        tag.Set("type", "timestamp")
        tag.Set("autoCreateTime", "")
        return tag
    })
    // 使用时间戳作为软删除字段
    softDeleteField := gen.FieldType("deleted_at", "gorm.DeletedAt")
    // 模型自定义选项组
    fieldOpts := []gen.ModelOpt{autoCreateTimeField, autoUpdateTimeField, softDeleteField}

    // 创建全部模型文件, 并覆盖前面创建的同名模型
    allModel := g.GenerateAllTable(fieldOpts...)

    // 创建模型的方法,生成文件在 query 目录; 先创建结果不会被后创建的覆盖
    g.ApplyBasic(allModel...)

    g.Execute()
}

• 然后运行cd cmd && go run gen.go生成文件

  目录结构大致如下

• model下我会自定义分为三层
  • dao是我自己写的查询代码
  • do是gorm gen生成的查询代码
  • entity是gorm model代码
• cmd下的gen.go是gorm gen的配置
• pkg下的gorm.go是自定义日志驱动以及配置连接池

+---app
|   +---account
|   |   +---admin
|   |   +---api
|   \   +---model
|           +---dao
|           +---do
|           +---entity
|   |   +---rpc
|   \---id
|       +---rpc
|   \---other
|       +---rpc
|       +---api
+---cmd
|   \---gen.go
+---pkg
|   \---gorm.go
go.mod

• pkg/gorm.go

package pkg

import (
    "context"
    "errors"
    "fmt"
    "time"

    "github.com/zeromicro/go-zero/core/logx"
    "github.com/zeromicro/go-zero/core/service"
    "gorm.io/gorm"
    "gorm.io/gorm/logger"
)

// 可以在配置引用
type GormConnPoolConf struct {
    MaxIdleConns int `json:",default=20"`
    MaxOpenConns int `json:",default=20"`
    MaxLifeTime  int `json:",default=300"`
}

// 自定义日志
type GormLogger struct {
    SlowThreshold time.Duration
    Mode          string
}

func NewGormLogger(mode string) *GormLogger {
    return &GormLogger{
        SlowThreshold: 200 * time.Millisecond, // 一般超过200毫秒就算慢查所以不使用配置进行更改
        Mode:          mode,
    }
}

var _ logger.Interface = (*GormLogger)(nil)

func (l *GormLogger) LogMode(lev logger.LogLevel) logger.Interface {
    return &GormLogger{}
}

func (l *GormLogger) Info(ctx context.Context, msg string, data ...interface{}) {
    logx.WithContext(ctx).Infof(msg, data)
}

func (l *GormLogger) Warn(ctx context.Context, msg string, data ...interface{}) {
    logx.WithContext(ctx).Errorf(msg, data)
}

func (l *GormLogger) Error(ctx context.Context, msg string, data ...interface{}) {
    logx.WithContext(ctx).Errorf(msg, data)
}

func (l *GormLogger) Trace(
    ctx context.Context,
    begin time.Time,
    fc func() (sql string, rowsAffected int64),
    err error,
) {
    // 获取运行时间
    elapsed := time.Since(begin)
    // 获取 SQL 语句和返回条数
    sql, rows := fc()
    // 通用字段
    logFields := []logx.LogField{
        logx.Field("sql", sql),
        logx.Field("time", microsecondsStr(elapsed)),
        logx.Field("rows", rows),
    }

    // Gorm 错误
    if err != nil {
        // 记录未找到的错误使用 warning 等级
        if errors.Is(err, gorm.ErrRecordNotFound) {
            logx.WithContext(ctx).Infow("Database ErrRecordNotFound", logFields...)
        } else {
            // 其他错误使用 error 等级
            logFields = append(logFields, logx.Field("catch error", err))
            logx.WithContext(ctx).Errorw("Database Error", logFields...)
        }
    }

    // 慢查询日志
    if l.SlowThreshold != 0 && elapsed > l.SlowThreshold {
        logx.WithContext(ctx).Sloww("Database Slow Log", logFields...)
    }

    // 非生产模式下，记录所有 SQL 请求
    if l.Mode != service.ProMode {
        logx.WithContext(ctx).Infow("Database Query", logFields...)
    }
}

func microsecondsStr(elapsed time.Duration) string {
    return fmt.Sprintf("%.3fms", float64(elapsed.Nanoseconds())/1e6)
}

• app/account/rpc/internal/svc/servicecontext.go

package svc

import (
    "time"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

type ServiceContext struct {
    // 本来在单独的文件, 这里为了解释方便, 复制代码过来
    Config struct {
        zrpc.RpcServerConf
        MysqlConnPool pkg.GormConnPoolConf
        DataSource string
    }

    // dao 层
    AppsDao      *dao.AppsDao
    XxxxDao      *dao.XxxxDao
}

func NewServiceContext(c config.Config) (*ServiceContext, error) {

    // 使用自定义日志
    conn, err := gorm.Open(
        mysql.Open(c.DataSource),
        &gorm.Config{Logger: pkg.NewGormLogger(c.Mode)},
    )
    if err != nil {
        return nil, err
    }

    if sqlDB, err := conn.DB(); err == nil {
        // SetMaxIdleConns 设置空闲连接池中连接的最大数量
        sqlDB.SetMaxIdleConns(c.MysqlConnPool.MaxIdleConns)
        sqlDB.SetMaxOpenConns(c.MysqlConnPool.MaxOpenConns)
        sqlDB.SetConnMaxLifetime(time.Duration(c.MysqlConnPool.MaxLifeTime) * time.Second)
    }

    // 设置 gorm 数据库连接
    do.SetDefault(conn)

    return &ServiceContext{
        Config:             c,
        AppsDao: dao.NewAppsDao(),
        XxxxDao: dao.NewXxxxDao(),
    }, nil
}

• app/account/model/dao/apps.go 使用示例

package dao

import (
    "context"
)

type AppsDao struct {
}

func NewAppsDao() *AppsDao {
    return &AppsDao{}
}

func (dao *AppsDao) Find(ctx context.Context, id uint64) (*entity.App, error) {

    return do.
        App.
        WithContext(ctx).
        Where(do.App.ID.Eq(id)).
        Take()
}

本作品采用《CC 协议》，转载必须注明作者和本文链接