Golang在整洁架构基础上实现事务操作_Golang

前言

大家好，这里是白泽，这篇文章在 go-kratos 官方的 layout 项目的整洁架构基础上，实现优雅的数据库事务操作。

本期涉及的学习资料：

我的开源golang学习仓库：https://github.com/baize1998/go-learning，这期的所有内容汇聚成一个可运行的 demo， kit/transaction 路径下。
kratos cli 工具：go install github.com/go-kratos/kratos/cmd/kratos/v2@latest。
kratos 微服务框架：https://github.com/go-kratos/kratos
wire 依赖注入库：https://github.com/google/wire
领域驱动设计思想：本文不多涉及，具备相关背景知识食用本文更佳。

在开始学习之前，先补齐一下整洁架构 & 依赖注入的前置知识。

预备知识

整洁架构

kratos 是 go 语言的一个微服务框架，github 🌟 23k，https://github.com/go-kratos/kratos

该项目提供了 cli 工具，允许用户通过 kratos new xxxx，新建一个 xxxx 项目，这个项目将使用 kratos-layout 仓库的代码结构。

仓库地址：https://github.com/go-kratos/kratos-layout

kratos-layout 项目为用户提供的，配合 cli 工具生成的一个典型的 go 项目布局看起来像这样：

application
|____api
| |____helloworld
| | |____v1
| | |____errors
|____cmd
| |____helloworld
|____configs
|____internal
| |____conf
| |____data
| |____biz
| |____service
| |____server
|____test
|____pkg
|____go.mod
|____go.sum
|____license
|____readme.md

依赖注入

🌟 通过依赖注入，实现了资源的使用和隔离，同时避免了重复创建资源对象，是实现整洁架构的重要一环。

kratos 的官方文档中提到，十分建议用户尝试使用 wire 进行依赖注入，整个 layout 项目，也是基于 wire，完成了整洁架构的搭建。

service 层，实现 rpc 接口定义的方法，实现对外交互，注入了 biz。

// greeterservice is a greeter service.
type greeterservice struct {
   v1.unimplementedgreeterserver
   uc *biz.greeterusecase
}
// newgreeterservice new a greeter service.
func newgreeterservice(uc *biz.greeterusecase) *greeterservice {
   return &greeterservice{uc: uc}
}
// sayhello implements helloworld.greeterserver.
func (s *greeterservice) sayhello(ctx context.context, in *v1.hellorequest) (*v1.helloreply, error) {
   g, err := s.uc.creategreeter(ctx, &biz.greeter{hello: in.name})
   if err != nil {
      return nil, err
   }
   return &v1.helloreply{message: "hello " + g.hello}, nil
}

biz 层：定义 repo 接口，注入 data 层。

// greeterrepo is a greater repo.
type greeterrepo interface {
   save(context.context, *greeter) (*greeter, error)
   update(context.context, *greeter) (*greeter, error)
   findbyid(context.context, int64) (*greeter, error)
   listbyhello(context.context, string) ([]*greeter, error)
   listall(context.context) ([]*greeter, error)
}
// greeterusecase is a greeter usecase.
type greeterusecase struct {
   repo greeterrepo
   log  *log.helper
}
// newgreeterusecase new a greeter usecase.
func newgreeterusecase(repo greeterrepo, logger log.logger) *greeterusecase {
	return &greeterusecase{repo: repo, log: log.newhelper(logger)}
}
// creategreeter creates a greeter, and returns the new greeter.
func (uc *greeterusecase) creategreeter(ctx context.context, g *greeter) (*greeter, error) {
	uc.log.withcontext(ctx).infof("creategreeter: %v", g.hello)
	return uc.repo.save(ctx, g)
}

data 作为数据访问的实现层，实现了上游接口，注入了数据库实例资源。

type greeterrepo struct {
	data *data
	log  *log.helper
}
// newgreeterrepo .
func newgreeterrepo(data *data, logger log.logger) biz.greeterrepo {
	return &greeterrepo{
		data: data,
		log:  log.newhelper(logger),
	}
}
func (r *greeterrepo) save(ctx context.context, g *biz.greeter) (*biz.greeter, error) {
	return g, nil
}
func (r *greeterrepo) update(ctx context.context, g *biz.greeter) (*biz.greeter, error) {
	return g, nil
}
func (r *greeterrepo) findbyid(context.context, int64) (*biz.greeter, error) {
	return nil, nil
}
func (r *greeterrepo) listbyhello(context.context, string) ([]*biz.greeter, error) {
	return nil, nil
}
func (r *greeterrepo) listall(context.context) ([]*biz.greeter, error) {
	return nil, nil
}

db：注入 data，作为被操作的对象。

type data struct {
	// todo wrapped database client
}
// newdata .
func newdata(c *conf.data, logger log.logger) (*data, func(), error) {
	cleanup := func() {
		log.newhelper(logger).info("closing the data resources")
	}
	return &data{}, cleanup, nil
}

golang 优雅事务

准备

🌟 项目获取：强烈建议克隆仓库后实机操作。

git clone git@github.com:baize1998/go-learning.git
cd kit/transcation/helloworld

这个目录基于 go-kratos cli 工具使用 kratos new helloworld 生成，并在此基础上修改，实现了事务支持。

运行 demo 需要准备：

本地数据库 dev：root:root@tcp(127.0.0.1:3306)/dev?parsetime=true&loc=local
建立表：

create table if not exists greater (
    hello varchar(20) not null
) engine=innodb default charset=utf8mb4 collate=utf8mb4_0900_ai_ci;

ps：makefile 中提供了使用 goose 进行数据库变更管理的能力（goose 也是一个开源的高 🌟 项目，推荐学习）

up:
	goose mysql "root:root@tcp(localhost:3306)/dev?parsetime=true" up
down:
	goose mysql "root:root@tcp(localhost:3306)/dev?parsetime=true" down
create:
	goose mysql "root:root@tcp(localhost:3306)/dev?parsetime=true" create ${name} sql

启动服务：go run ./cmd/helloworld/，通过 config.yaml 配置了 http 服务监听 localhost:8000，grpc 则是 localhost:9000。
发起一个 get 请求

核心逻辑

helloworld 项目本质是一个打招呼服务，由于 kit/transcation/helloworld 已经是魔改后的版本，为了与默认项目做对比，你可以自行生成一个 helloworld 项目，在同级目录下，对照学习。

在 internal/biz/greeter.go 文件中，是我更改的内容，为了测试事务，我在 biz 层的 creategreeter 方法中，调用了 repo 层的 save 和 update 两个方法，且这两个方法都会成功，但是 update 方法人为抛出一个异常。

// creategreeter creates a greeter, and returns the new greeter.
func (uc *greeterusecase) creategreeter(ctx context.context, g *greeter) (*greeter, error) {
   uc.log.withcontext(ctx).infof("creategreeter: %v", g.hello)
   var (
      greater *greeter
      err     error
   )
   //err = uc.db.exectx(ctx, func(ctx context.context) error {
   // // 更新所有 hello 为 hello + "updated"，且插入新的 hello
   // greater, err = uc.repo.save(ctx, g)
   // _, err = uc.repo.update(ctx, g)
   // return err
   //})
   greater, err = uc.repo.save(ctx, g)
   _, err = uc.repo.update(ctx, g)
   if err != nil {
      return nil, err
   }
   return greater, nil
}
// update 人为抛出异常
func (r *greeterrepo) update(ctx context.context, g *biz.greeter) (*biz.greeter, error) {
	result := r.data.db.db(ctx).model(&biz.greeter{}).where("hello = ?", g.hello).update("hello", g.hello+"updated")
	if result.rowsaffected == 0 {
		return nil, fmt.errorf("greeter %s not found", g.hello)
	}
	return nil, fmt.errorf("custom error")
	//return g, nil
}

repo 层开启事务

如果忽略上文注释中的内容，因为两个 repo 的数据库操作都是独立的。

func (r *greeterrepo) save(ctx context.context, g *biz.greeter) (*biz.greeter, error) {
   result := r.data.db.db(ctx).create(g)
   return g, result.error
}
func (r *greeterrepo) update(ctx context.context, g *biz.greeter) (*biz.greeter, error) {
   result := r.data.db.db(ctx).model(&biz.greeter{}).where("hello = ?", g.hello).update("hello", g.hello+"updated")
   if result.rowsaffected == 0 {
      return nil, fmt.errorf("greeter %s not found", g.hello)
   }
   return nil, fmt.errorf("custom error")
   //return g, nil
}

即使最后抛出 update 的异常，但是 save 和 update 都已经成功了，且彼此不强关联，数据库中会多增加一条数据。

biz 层开启事务

因此为了 repo 层的两个方法能够共用一个事务，应该在 biz 层就使用 db 开启事务，且将这个事务的会话传递给 repo 层的方法。

🌟 如何传递：使用 context 便成了顺理成章的方案。

接下来将 internal/biz/greeter.go 文件中注释的部分释放，且注释掉分开使用事务的两行，此时重新运行项目请求接口，则由于 update 方法抛出 err，导致事务回滚，未出现新增的 xiaomingupdated 记录。

// creategreeter creates a greeter, and returns the new greeter.
func (uc *greeterusecase) creategreeter(ctx context.context, g *greeter) (*greeter, error) {
   uc.log.withcontext(ctx).infof("creategreeter: %v", g.hello)
   var (
      greater *greeter
      err     error
   )
   err = uc.db.exectx(ctx, func(ctx context.context) error {
      // 更新所有 hello 为 hello + "updated"，且插入新的 hello
      greater, err = uc.repo.save(ctx, g)
      _, err = uc.repo.update(ctx, g)
      return err
   })
   //greater, err = uc.repo.save(ctx, g)
   //_, err = uc.repo.update(ctx, g)
   if err != nil {
      return nil, err
   }
   return greater, nil
}

核心实现

由于 biz 层的 usecase 实例持有 *dbclient，repo 层也持有 *dbclient，且二者在依赖注入的时候，代表同一个数据库连接池实例。

在 pkg/db/db.go 中，为 *dbclient 提供了如下两个方法： exectx() & db()。

在 biz 层，通过优先执行 exectx() 方法，创建事务，以及将待执行的两个 repo 方法封装在 fn 参数中，传递给 gorm 实例的 transaction() 方法待执行。

同时在 transcation 内部，触发 fn() 函数，也就是聚合的两个 repo 操作，需要注意的是，此时将携带 contexttxkey 事务 tx 的 ctx 作为参数传递给了 fn 函数，因此下游的两个 repo 可以获取到 biz 层的事务会话。

type contexttxkey struct{}
// exectx gorm transaction
func (c *dbclient) exectx(ctx context.context, fn func(ctx context.context) error) error {
   return c.db.withcontext(ctx).transaction(func(tx *gorm.db) error {
      ctx = context.withvalue(ctx, contexttxkey{}, tx)
      return fn(ctx)
   })
}
func (c *dbclient) db(ctx context.context) *gorm.db {
   tx, ok := ctx.value(contexttxkey{}).(*gorm.db)
   if ok {
      return tx
   }
   return c.db
}

在 repo 层执行数据库操作的时候，尝试通过 db() 方法，从 ctx 中获取到上游传递下来的事务会话，如果有则使用，如果没有，则使用 repo 层自己持有的 *dbclient，进行数据访问操作。

func (r *greeterrepo) save(ctx context.context, g *biz.greeter) (*biz.greeter, error) {
	result := r.data.db.db(ctx).create(g)
	return g, result.error
}
func (r *greeterrepo) update(ctx context.context, g *biz.greeter) (*biz.greeter, error) {
	result := r.data.db.db(ctx).model(&biz.greeter{}).where("hello = ?", g.hello).update("hello", g.hello+"updated")
	if result.rowsaffected == 0 {
		return nil, fmt.errorf("greeter %s not found", g.hello)
	}
	return nil, fmt.errorf("custom error")
	//return g, nil
}