biz

在kratos Blog的“Go工程化 - Project Layout 最佳实践”一文中有对biz层描述：

“业务逻辑的组装层，类似 DDD 的 domain 层，data 类似 DDD 的 repo，repo 接口在这里定义，使用依赖倒置的原则。”

啊这…看完后，我更蒙了，DDD是啥，domain又是啥，学校啥也没教我啊( ´•̥̥̥ω•̥̥̥` )

没事，我不知道，但是总有人知道。对着搜索引擎猛地一哆嗦，啪啪，很快啊，在某乎上找到“领域驱动设计(DDD)-基础思想”这篇文章，其中介绍了DDD也就是“领域驱动设计”也介绍了“领域驱动三层架构”。文中是这样介绍domian层的

“系统的核心层，所有具体的业务逻辑处理、事件处理等都在这层域模型中处理”

我完全懂了.jpg(不是) 管它呢，干就完了

模型定义

定义一个极其简单的用户模型，它的名字叫做User，它有两个属性，一个叫做名字(Name)，另一个叫做密码(Passwd)。

将这个用户模型在代码中进行实现

在“/biz”目录下创建一个名为“user.go”的文件

在“/biz/user.go”文件里添加如下内容

package biz
import (
    "gorm.io/gorm"
)
// User 用户数据模型
type User struct {
    // GORM的一个基础数据模型
    // 其中有ID、CreatedAt(创建时间)、UpdatedAt(更新时间)、DeletedAt(删除时间)
    gorm.Model
    // Name 用户的姓名
    // "not null" 代表不能为空
    // "type" 定义属性(字段)在数据库中的类型，其类型为"varchar(32)"
    Name string `gorm:"not null; type:varchar(32)"`
    // Passwd 用户的密码
    Passwd string `gorm:"not null; type:char(16)"`
}

为了让GORM知道我们定义了一个数据模型我们需要对“/data/data.go”文件进行修改

我们在“/data/data.go”的最底下加入

// DBAutoMigrate 数据库模型自动迁移
func DBAutoMigrate(db *gorm.DB) error {
    // 在这里让GORM知道那些结构体是我们的数据模型，GORM将完成自动建表
    err := db.AutoMigrate(
        &biz.User{}, // 加入用户数据模型
    )
    if err != nil {
        return err
    }
    return nil
}

在“/data/data.go”的NewDataBase函数里调用刚刚编写的DBAutoMigrate函数

// NewDataBase 初始化数据库
func NewDataBase(c *conf.Data) (*gorm.DB, error) {
    ......
    // 超时
    sqlDb.SetConnMaxLifetime(time.Second * 30)
    err = DBAutoMigrate(db)
    if err != nil {
        return nil, err
    }
    return db, nil
}

到这里，我们就完成了用户数据模型的定义，并且让GORM知道我们定义了这个数据模型

repo接口的定义

在repo接口中，我们需要定义一些基础操作数据库修改数据的函数

让我们回到“/biz/user.go”，在这个文件的末尾添加以下代码

// UserRepo 将“用户数据模型”在数据库上的基础操作封装为接口
type UserRepo interface {
    // CreateUser 创建用户
    // 参数 model 为 User用户数据模型
    CreateUser(ctx context.Context, model *User) (uint, error)
}

data层中实现repo接口

在“/data”目录下创建”user.go”文件

给创建好的“/data/user.go”文件添加内容

我们创建一个私有的结构体去实现“/biz/user.go”中的“biz.UserRepo”接口

// userRepo 实现 biz.UserRepo 接口
// 私有的结构体
// 对“/biz/user.go”中的UserRepo进行实现，
// 完成对“用户数据模型”的数据库基础操作。
type userRepo struct {
    data *Data // 数据库客户端的集合
    log  *log.Helper
}

让我们编写一个“NewUseRepo”函数来创建结构体userRepo

// NewUseRepo .
// 注意这里返回的是 biz.UserRepo
// 在golang中接口的继承是不需要明确声明的
// 只要我们的私有结构体userRepo实现了“/biz/user.go”内 biz.UserRepo 接口内的方法
// 那么 userRepo 就是“继承”了 biz.UserRepo
func NewUseRepo(data *Data, logger log.Logger) biz.UserRepo {
   return &userRepo{
      data: data,
      log:  log.NewHelper(logger),
   }
}

啪！这个时候ide是不是已经爆红报错了？安心咯，这只是因为我们的“userRepo”还没有实现“biz.UserRepo”接口内的方法

在上文“repo接口的定义”中，我们给“biz.UserRepo”接口编写了一个“CreateUser”方法(成员函数)，它长这样

CreateUser(ctx context.Context, model *User) (uint, error)

现在我们给“userRepo”实现这个方法

在“/data/user.go”的末尾添加

// CreateUser 创建用户的数据库操作
// model 为用户数据模型
func (u userRepo) CreateUser(ctx context.Context, model *biz.User) (uint, error) {
   // 使用 “/data/date.go”中的 “Data”结构体内的 “DataBase *gorm.DB”数据库客户端在数据库中创建一个“用户数据”
   err := u.data.DataBase.Create(model).Error
   // 如果存在错误，则将错误返回
   if err != nil {
      return 0, err
   }
   // 如果没有发生错误，则返回创建成功后的用户id
   return model.ID, nil
}

让我们吧创建结构体的函数“NewUseRepo”添加到依赖提供者集中

修改“/data/data.go”文件中的“wire.NewSet()”函数，在“NewSet”函数里添加“NewUseRepo”

// ProviderSet is data providers.
var ProviderSet = wire.NewSet(NewData, NewDataBase, NewUseRepo)

/biz/user.go

业务逻辑处理

我们将对用户的操作封装成“UserUseCase”结构体

回到“/biz/user.go”添加“UserUseCase”结构体

// UserUseCase 将对用户的操作封装
type UserUseCase struct {
}

在结构体中添加“repo”成员，其类型是我们编写的repo接口

在结构体中添加“log”成员，*log.Helper类型，虽然在这里不会使用到，但也还是加上

// UserUseCase 将对用户的操作封装
type UserUseCase struct {
    repo UserRepo // 我们需要使用Repo来对数据库进行基础操作
    log  *log.Helper
}

编写一个“NewUserUseCase”去创建一个“UserUseCase”，并将它返回，以便于之后的wine依赖注入

func NewUserUseCase(repo UserRepo, logger log.Logger) *UserUseCase {
    return &UserUseCase{
        repo: repo,
        log:  log.NewHelper(logger),
    }
}

将以上乱七八糟的东西封装好后我们可以开始真正的业务逻辑处理了

接下来进行编写创建用户的业务逻辑

不同的项目有不同的功能，不同的功能需要不同的实现，实现这些核心功能的代码就叫业务逻辑

我们在这里去使用各种底层基础设施(例如数据库，缓存，对象存储等)去储存、获取数据，对这些数据进行处理，实现项目的功能。(当然，我们目前只使用到了)

我们创建一个“UserUseCase”的方法(成员函数)，命名为“CreateUser”

func (uc *UserUseCase) CreateUser(ctx context.Context, name, passwd string) (uint, error) {
}

如果你关心为什么这个函数有一个“ctx context.Context”参数，你可以去搜索以下“golang context”，这里我们没有使用到它，暂且放一放

至于为什么要有name, passwd呢，还记得我们用户数据模型中的Name和Passwd吗，如果忘记了可以往上翻翻，看一下“模型定义”部分

接下来我们在“CreateUser”方法中创建一个用户数据模型，并且调用“UserRepo”去完成用户数据的创建

// CreateUser 创建用户
func (uc *UserUseCase) CreateUser(ctx context.Context, name, passwd string) (uint, error) {
    // 将“创建用户”函数的参数转换为“用户数据模型”
    userModel := &User{
        Name:   name,
        Passwd: passwd,
    }
    // 调用UserRepo接口实现中的CreateUser函数去创建用户
    return uc.repo.CreateUser(ctx, userModel)
}

啊，没了，业务逻辑写完了。为啥？因为我们只写了一个创建用户的业务逻辑啊，多写几个业务它不就多了吗

最后，我们将“NewUserUseCase”函数加入到依赖提供者集中

修改“/biz/biz.go”文件中的“wire.NewSet()”函数，在“NewSet”函数里添加“NewUserUseCase”

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

完成本节后你将得到如下代码

文件: /data/data.go

package data
import (
    "github.com/go-kratos/kratos/v2/log"
    "github.com/google/wire"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "time"
    "user/internal/biz"
    "user/internal/conf"
)
// ProviderSet is data providers.
var ProviderSet = wire.NewSet(NewData, NewDataBase, NewUseRepo)
// Data .
type Data struct {
    DataBase *gorm.DB // 数据库
}
// NewData .
func NewData(c *conf.Data, logger log.Logger, db *gorm.DB) (*Data, func(), error) {
    cleanup := func() {
        log.NewHelper(logger).Info("closing the data resources")
    }
    return &Data{
        DataBase: db,
    }, cleanup, nil
}
// NewDataBase 初始化数据库
func NewDataBase(c *conf.Data) (*gorm.DB, error) {
    // dsn 数据库链接
    // "用户名":"密码"@tcp("IP":"端口")/"数据库名称"?charset=utf8mb4&parseTime=True&loc=Local
    // 不要无脑抄作业哦，根据自己的实际情况修改数据库链接
    dsn := "test:test@tcp(localhost:3306)/kratos_demo?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(
        mysql.Open(dsn),
        &gorm.Config{})
    if err != nil {
        return nil, err
    }
    sqlDb, err := db.DB()
    if err != nil {
        return nil, err
    }
    // 设置连接池
    // 空闲
    sqlDb.SetMaxIdleConns(50)
    // 打开
    sqlDb.SetMaxOpenConns(100)
    // 超时
    sqlDb.SetConnMaxLifetime(time.Second * 30)
    err = DBAutoMigrate(db)
    if err != nil {
        return nil, err
    }
    return db, nil
}
// DBAutoMigrate 数据库模型自动迁移
// 在这里让GORM知道那些结构体是我们的数据模型，GORM将完成自动建表
func DBAutoMigrate(db *gorm.DB) error {
    err := db.AutoMigrate(
        &biz.User{}, // 加入用户数据模型
    )
    if err != nil {
        return err
    }
    return nil
}

文件: /data/user.go

package data
import (
    "context"
    "github.com/go-kratos/kratos/v2/log"
    "user/internal/biz"
)
// userRepo 实现 biz.UserRepo 接口
// 私有的结构体
// 对“/biz/user.go”中的UserRepo进行实现，
// 完成对“用户数据模型”的数据库基础操作。
type userRepo struct {
    data *Data // 数据库客户端的集合
    log  *log.Helper
}
// NewUseRepo .
// 注意这里返回的是 biz.UserRepo
// 在golang中接口的继承是不需要明确声明的
// 只要我们的私有结构体userRepo实现了“/biz/user.go”内 biz.UserRepo 接口内的方法
// 那么 userRepo 就是继承了 biz.UserRepo
func NewUseRepo(data *Data, logger log.Logger) biz.UserRepo {
    return &userRepo{
        data: data,
        log:  log.NewHelper(logger),
    }
}
// CreateUser 创建用户的数据库操作
// model 为用户数据模型
func (u userRepo) CreateUser(ctx context.Context, model *biz.User) (uint, error) {
    // 使用 “/data/date.go”中的 “Data”结构体内的 “DataBase *gorm.DB”数据库客户端在数据库中创建一个“用户数据”
    err := u.data.DataBase.Create(model).Error
    // 如果存在错误，则将错误返回
    if err != nil {
        return 0, err
    }
    // 如果没有发生错误，则返回创建成功后的用户id
    return model.ID, nil
}

文件: /biz/user.go

package biz
import (
    "context"
    "github.com/go-kratos/kratos/v2/log"
    "gorm.io/gorm"
)
// User 用户数据模型
type User struct {
    // GORM的一个基础数据模型
    // 其中有ID、CreatedAt(创建时间)、UpdatedAt(更新时间)、DeletedAt(删除时间)
    gorm.Model
    // Name 用户的姓名
    // "not null" 定义该数据库字段不能为空
    // "type" 定义该数据库字段的类型，其类型为"varchar(32)"
    Name string `gorm:"not null; type:varchar(32)"`
    // Passwd 用户的密码
    Passwd string `gorm:"not null; type:char(16)"`
}
// UserRepo 将“用户数据模型”在数据库上的基础操作封装为接口
type UserRepo interface {
    // CreateUser 创建用户
    // 参数 model 为 User用户数据模型
    CreateUser(ctx context.Context, model *User) (uint, error)
}
// UserUseCase 将对用户的操作封装
type UserUseCase struct {
    repo UserRepo // 我们需要使用Repo来对数据库进行基础操作
    log  *log.Helper
}
func NewUserUseCase(repo UserRepo, logger log.Logger) *UserUseCase {
    return &UserUseCase{
        repo: repo,
        log:  log.NewHelper(logger),
    }
}
// 以下开始！
// 业务逻辑处理！
// CreateUser 创建用户
func (uc *UserUseCase) CreateUser(ctx context.Context, name, passwd string) (uint, error) {
    // 将“创建用户”函数的参数转换为“用户数据模型”
    userModel := &User{
        Name:   name,
        Passwd: passwd,
    }
    // 调用UserRepo接口实现中的CreateUser函数去创建用户
    return uc.repo.CreateUser(ctx, userModel)
}

参考内容：

《GORM 指南》入门指南 - 模型定义: https://gorm.io/zh_CN/docs/models.html

《kratos Blog》Go工程化 - Project Layout 最佳实践: https://go-kratos.dev/blog/go-project-layout

领域驱动设计(DDD)-基础思想 BY Ebiubiu: https://zhuanlan.zhihu.com/p/109114670

3、Kratos v2 初步学习 3-biz中的数据模型与逻辑处理

biz

模型定义

repo接口的定义

data层中实现repo接口

业务逻辑处理