Golang 微服框架 Kratos 与它的小伙伴系列 - ORM 框架 - GORM

什么是 ORM？

面向对象编程和关系型数据库，都是目前最流行的技术，但是它们的模型是不一样的。

面向对象编程把所有实体看成对象（object），关系型数据库则是采用实体之间的关系（relation）连接数据。很早就有人提出，关系也可以用对象表达，这样的话，就能使用面向对象编程，来操作关系型数据库。

简单说，ORM 就是通过实例对象的语法，完成关系型数据库的操作的技术，是"对象-关系映射"（Object/Relational Mapping） 的缩写。

ORM 把数据库映射成对象。

• 数据库的表（table） --> 类（class）
• 记录（record，行数据）--> 对象（object）
• 字段（field）--> 对象的属性（attribute）

举例来说，下面是一行 SQL 语句。

SELECT id, first_name, last_name, phone, birth_date, sexFROM persons WHERE id = 10

复制代码

程序直接运行 SQL，操作数据库的写法如下。

res = db.execSql(sql);name = res[0]["FIRST_NAME"];

复制代码

改成 ORM 的写法如下。

p = Person.get(10);name = p.first_name;

复制代码

一比较就可以发现，ORM 使用对象，封装了数据库操作，因此可以不碰 SQL 语言。开发者只使用面向对象编程，与数据对象直接交互，不用关心底层数据库。

ORM 有下面这些优点:

• 数据模型都在一个地方定义，更容易更新和维护，也利于重用代码。
• ORM 有现成的工具，很多功能都可以自动完成，比如数据消毒、预处理、事务等等。
• 它迫使你使用 MVC 架构，ORM 就是天然的 Model，最终使代码更清晰。
• 基于 ORM 的业务代码比较简单，代码量少，语义性好，容易理解。
• 你不必编写性能不佳的 SQL。

ORM 也有很突出的缺点：

• ORM 库不是轻量级工具，需要花很多精力学习和设置。
• 对于复杂的查询，ORM 要么是无法表达，要么是性能不如原生的 SQL。
• ORM 抽象掉了数据库层，开发者无法了解底层的数据库操作，也无法定制一些特殊的 SQL。

什么是 GORM？

GORM 是基于 Go 语言实现的 ORM 库，它是 Golang 目前比较热门的数据库 ORM 操作库，对开发者也比较友好，使用非常方便简单。

最重要的是，它是一个正经的国产开源库。支持国产！

特性

• 全功能 ORM
• 关联 (Has One，Has Many，Belongs To，Many To Many，多态，单表继承)
• Create，Save，Update，Delete，Find 中钩子方法
• 支持 Preload、Joins 的预加载
• 事务，嵌套事务，Save Point，Rollback To Saved Point
• Context、预编译模式、DryRun 模式
• 批量插入，FindInBatches，Find/Create with Map，使用 SQL 表达式、Context Valuer 进行 CRUD
• SQL 构建器，Upsert，数据库锁，Optimizer/Index/Comment Hint，命名参数，子查询
• 复合主键，索引，约束
• Auto Migration
• 自定义 Logger
• 灵活的可扩展插件 API：Database Resolver（多数据库，读写分离）、Prometheus…
• 每个特性都经过了测试的重重考验
• 开发者友好

安装库

go get -u gorm.io/gorm

复制代码

除此以外，还需要安装数据库的驱动：

# 安装SQLite驱动go get -u gorm.io/driver/sqlite
# 安装MySQL驱动go get -u gorm.io/driver/mysql
# 安装PostgreSQL驱动go get -u gorm.io/driver/postgres
# 安装SQL Server驱动go get -u gorm.io/driver/sqlserver
# 安装Clickhouse驱动（Clickhouse兼容MySQL的协议，所以直接用MySQL驱动连接也是一样的）go get -u gorm.io/driver/clickhouse

复制代码

GORM 的一些数据库基本操作

因为数据库是复杂的，SQL 是复杂的，复杂到能够出好几本书，所以是绝不可能在简单的篇幅里面讲完整，只能够将常用的一些操作（连接数据库、CURD）拿来举例讲讲。

连接数据库

MySQL

import (  "gorm.io/gorm"  "gorm.io/driver/mysql")
dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})

复制代码

PostgreSQL

import (  "gorm.io/gorm"  "gorm.io/driver/postgres")
dsn := "host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai"db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})

复制代码

SQLite

import (  "gorm.io/gorm"  "gorm.io/driver/sqlite")
db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{})

复制代码

SQL Server

import (  "gorm.io/gorm"  "gorm.io/driver/sqlserver")
dsn := "sqlserver://gorm:LoremIpsum86@localhost:9930?database=gorm"db, err := gorm.Open(sqlserver.Open(dsn), &gorm.Config{})

复制代码

Clickhouse

import (  "gorm.io/gorm"  "gorm.io/driver/clickhouse")
dsn := "tcp://localhost:9000?database=gorm&username=gorm&password=gorm&read_timeout=10&write_timeout=20"db, err := gorm.Open(clickhouse.Open(dsn), &gorm.Config{})

复制代码

自动迁移 Automatic Migration

db.AutoMigrate(&User{})

复制代码

自动迁移功能，会创建表、缺失的外键、约束、列和索引。

定义模型

type User struct {  gorm.Model  UserName string  NickName string}

复制代码

gorm.Model则是包含了通用的一些字段，比如：id、创建时间、更新时间、删除时间等……

// gorm.Model definitiontype Model struct {  ID        uint           `gorm:"primaryKey"`  CreatedAt time.Time  UpdatedAt time.Time  DeletedAt gorm.DeletedAt `gorm:"index"`}

复制代码

在默认的情况下：

• 表名，将会被转换为 复数形式 以及 蛇形命名法（snake_case），比如：User转换为users。
• 字段名，将被转换为 蛇形命名法（snake_case） 字符串，比如：UserName被转换为user_name。

当然，你也可以用column标明字段名的输出：

type User struct {  gorm.Model  UserName string `gorm:"column:username"`  NickName string `gorm:"column:nickname"`}

复制代码

定义TableName()方法控制表名的输出:

func (u User) TableName() string {  return "users"}

复制代码

增 Create

db.Create(&User{UserName: "TestUserName", NickName: "TestNickName"})

复制代码

删 Delete

// 软删除// UPDATE users SET deleted_at="2020-03-13 10:23" WHERE id = user.id;db.Delete(&user, 1)
db.Delete(&user)
// 批量软删除db.Where("age = ?", 20).Delete(&User{})
// 物理删除// DELETE FROM users WHERE id=10;db.Unscoped().Delete(&user)

复制代码

改 Update

db.Model(&user).Update("nick_name", "NewNickName")
// Update - 更新多个字段db.Model(&user).Updates(User{UserName: "NewUserName", NickName: "NewNickName"})db.Model(&user).Updates(map[string]interface{}{"user_name": "NewUserName", "nick_name": "NewNickName"})

复制代码

查 Read

var user User
// 获取第一条记录（主键升序）// SELECT * FROM users ORDER BY id LIMIT 1;db.First(&user)
// 根据整型主键查找// SELECT * FROM users WHERE id = 10;db.First(&user, 10)db.First(&user, "10")
// 根据主键获取记录，如果是非整型主键// SELECT * FROM users WHERE user_name = 'TestUserName';db.First(&user, "user_name = ?", "TestUserName")
// SELECT * FROM users WHERE id IN (1,2,3);db.Find(&users, []int{1,2,3})
// 获取一条记录，没有指定排序字段// SELECT * FROM users LIMIT 1;db.Take(&user)
// 获取最后一条记录（主键降序）// SELECT * FROM users ORDER BY id DESC LIMIT 1;db.Last(&user)

复制代码

与 Kratos 携起手来

官方推荐的包结构是这样的：

|- data

|- biz

|- service

|- server

那么，我们可以把模型定义做成一个 package，放到 data 文件夹下面去：

|- data

| |- modal

|- biz

|- service

|- server

创建数据库客户端

在data/data.go文件中添加创建 Gorm 数据库客户端的方法NewGormClient：

import (  "gorm.io/driver/clickhouse"  "gorm.io/driver/mysql"  "gorm.io/driver/postgres"  "gorm.io/driver/sqlite"  "gorm.io/driver/sqlserver"
  "gorm.io/gorm")
// Data .type Data struct {    db  *gorm.Client}
// NewGormClient 创建数据库客户端func NewGormClient(cfg *conf.Bootstrap, logger log.Logger) *gorm.DB {  l := log.NewHelper(log.With(logger, "module", "ent/data/user-service"))
  var driver gorm.Dialector  switch cfg.Data.Database.Driver {  default:    fallthrough  case "mysql":    driver = mysql.Open(cfg.Data.Database.Source)    break  case "postgres":    driver = postgres.Open(cfg.Data.Database.Source)    break  case "clickhouse":    driver = clickhouse.Open(cfg.Data.Database.Source)    break  case "sqlite":    driver = sqlite.Open(cfg.Data.Database.Source)    break  case "sqlserver":    driver = sqlserver.Open(cfg.Data.Database.Source)    break  }
  client, err := gorm.Open(driver, &gorm.Config{})  if err != nil {    l.Fatalf("failed opening connection to db: %v", err)  }
  // 运行数据库迁移工具  if cfg.Data.Database.Migrate {    if err := client.AutoMigrate(      &models.User{},    ); err != nil {      l.Fatalf("failed creating schema resources: %v", err)    }  }  return client}

复制代码

并将之注入到ProviderSet

// ProviderSet is data providers.var ProviderSet = wire.NewSet(    NewGormClient,    ...)

复制代码

需要说明的是数据库迁移工具，如果数据库中不存在表，迁移工具会创建一个；如果字段存在改变，迁移工具会对字段进行修改。

创建 UseCase

在 biz 文件夹下创建user.go：

package biz
type UserRepo interface {  ListUser(ctx context.Context, req *pagination.PagingRequest) (*v1.ListUserResponse, error)  GetUser(ctx context.Context, req *v1.GetUserRequest) (*v1.User, error)  CreateUser(ctx context.Context, req *v1.CreateUserRequest) (*v1.User, error)  UpdateUser(ctx context.Context, req *v1.UpdateUserRequest) (*v1.User, error)  DeleteUser(ctx context.Context, req *v1.DeleteUserRequest) (bool, error)}
type UserUseCase struct {  repo UserRepo  log  *log.Helper}
func NewUserUseCase(repo UserRepo, logger log.Logger) *UserUseCase {  l := log.NewHelper(log.With(logger, "module", "user/usecase"))  return &UserUseCase{repo: repo, log: l}}
func (uc *UserUseCase) ListUser(ctx context.Context, req *pagination.PagingRequest) (*v1.ListUserResponse, error) {  return uc.repo.ListUser(ctx, req)}
func (uc *UserUseCase) GetUser(ctx context.Context, req *v1.GetUserRequest) (*v1.User, error) {  return uc.repo.GetUser(ctx, req)}
func (uc *UserUseCase) CreateUser(ctx context.Context, req *v1.CreateUserRequest) (*v1.User, error) {  return uc.repo.CreateUser(ctx, req)}
func (uc *UserUseCase) UpdateUser(ctx context.Context, req *v1.UpdateUserRequest) (*v1.User, error) {  return uc.repo.UpdateUser(ctx, req)}
func (uc *UserUseCase) DeleteUser(ctx context.Context, req *v1.DeleteUserRequest) (bool, error) {  return uc.repo.DeleteUser(ctx, req)}

复制代码

注入到biz.ProviderSet

package biz
// ProviderSet is biz providers.var ProviderSet = wire.NewSet(    NewUserUseCase,    ...)

复制代码

创建 Repo

在data文件夹下创建user.go文件，实际操作数据库的操作都在此处。

package data
var _ biz.UserRepo = (*UserRepo)(nil)
type UserRepo struct {  data *Data  log  *log.Helper}
func NewUserRepo(data *Data, logger log.Logger) biz.UserRepo {  l := log.NewHelper(log.With(logger, "module", "User/repo"))  return &UserRepo{    data: data,    log:  l,  }}
func (r *UserRepo) convertModelToProto(in *models.User) *v1.User {  if in == nil {    return nil  }  return &v1.User{    Id:         uint32(in.ID),    UserName:   &in.UserName,    NickName:   &in.NickName,    Password:   &in.Password,    CreateTime: util.TimeToTimeString(&in.CreatedAt),    UpdateTime: util.TimeToTimeString(&in.UpdatedAt),  }}
func (r *UserRepo) List(_ context.Context, req *pagination.PagingRequest) (*v1.ListUserResponse, error) {  var results []models.User
  result := r.data.db.    Limit(int(req.GetPageSize())).    Offset(int(req.GetPageSize() * (req.GetPage() - 1))).    Find(&results)  if result.Error != nil {    return nil, result.Error  }
  items := make([]*v1.User, 0, len(results))  for _, res := range results {    item := r.convertModelToProto(&res)    items = append(items, item)  }
  var count int64  result = r.data.db.Model(&models.User{}).    Count(&count)  if result.Error != nil {    return nil, result.Error  }
  return &v1.ListUserResponse{    Total: int32(count),    Items: items,  }, nil}
func (r *UserRepo) Get(_ context.Context, req *v1.GetUserRequest) (*v1.User, error) {  res := &models.User{}  r.data.db.First(res, "id = ?", req.GetId())  return r.convertModelToProto(res), nil}
func (r *UserRepo) Create(_ context.Context, req *v1.CreateUserRequest) (*v1.User, error) {  cryptoPassword, err := crypto.HashPassword(req.User.GetPassword())  if err != nil {    return nil, err  }
  res := &models.User{    UserName: req.User.GetUserName(),    NickName: req.User.GetNickName(),    Password: cryptoPassword,  }
  result := r.data.db.Create(res)  if result.Error != nil {    return nil, result.Error  }
  return r.convertModelToProto(res), err}
func (r *UserRepo) Update(_ context.Context, req *v1.UpdateUserRequest) (*v1.User, error) {  var cryptoPassword string  var err error  if req.User.Password != nil {    cryptoPassword, err = crypto.HashPassword(req.User.GetPassword())    if err != nil {      return nil, err    }  }
  res := &models.User{    UserName: req.User.GetUserName(),    NickName: req.User.GetNickName(),    Password: cryptoPassword,  }
  result := r.data.db.Model(res).Updates(res)  if result.Error != nil {    return nil, result.Error  }
  return r.convertModelToProto(res), err}
func (r *UserRepo) Delete(_ context.Context, req *v1.DeleteUserRequest) (bool, error) {  result := r.data.db.Delete(&models.User{}, req.GetId())  if result.Error != nil {    return false, result.Error  }  return true, nil}

复制代码

注入到data.ProviderSet

package data
// ProviderSet is data providers.var ProviderSet = wire.NewSet(    NewUserRepo,    ...)

复制代码

在 Service 中调用

package service
type UserService struct {  v1.UnimplementedUserServiceServer
  uc  *biz.UserUseCase  log *log.Helper}
func NewUserService(logger log.Logger, uc *biz.UserUseCase) *UserService {  l := log.NewHelper(log.With(logger, "module", "service/user"))  return &UserService{    log: l,    uc:  uc,  }}
// ListUser 获取用户列表func (s *UserService) ListUser(ctx context.Context, req *pagination.PagingRequest) (*v1.ListUserResponse, error) {  return s.uc.ListUser(ctx, req)}
// GetUser 获取一个用户func (s *UserService) GetUser(ctx context.Context, req *v1.GetUserRequest) (*v1.User, error) {  return s.uc.GetUser(ctx, req)}
// CreateUser 创建一个用户func (s *UserService) CreateUser(ctx context.Context, req *v1.CreateUserRequest) (*v1.User, error) {  return s.uc.CreateUser(ctx, req)}
// UpdateUser 更新一个用户func (s *UserService) UpdateUser(ctx context.Context, req *v1.UpdateUserRequest) (*v1.User, error) {  return s.uc.UpdateUser(ctx, req)}
// DeleteUser 删除一个用户func (s *UserService) DeleteUser(ctx context.Context, req *v1.DeleteUserRequest) (*emptypb.Empty, error) {  _, err := s.uc.DeleteUser(ctx, req)  if err != nil {    return nil, err  }  return &emptypb.Empty{}, nil}

复制代码

注入到service.ProviderSet

package service
// ProviderSet is data providers.var ProviderSet = wire.NewSet(    NewUserService,    ...)

复制代码

将服务注册到 gRPC 服务器当中去：

package server
// NewGRPCServer new a gRPC server.func NewGRPCServer(cfg *conf.Bootstrap, logger log.Logger,  userSvc *service.UserService,) *grpc.Server {  srv := bootstrap.CreateGrpcServer(cfg, logging.Server(logger))
  userV1.RegisterUserServiceServer(srv, userSvc)
  return srv}

复制代码

这样，我们就有了一个完整的用户服务。