CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Go工程化如何在整洁架构中使用事务?由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

回顾先简单回顾一下 《Go工程化(九) 项目重构实践》 如果还没看过之前这篇文章可以先看一下:

在我们之前的项目目录分层中，我们主要分为了五个块:

• cmd/appname 是我们服务的入口，只负责启动和依赖注入(使用 Wire)
• domain 或者 model 是我们的实体定义 + 接口定义
• server 负责实现我们在 proto 中定义的接口，在这一层中我们只做数据转换，不写业务逻辑
• usecase 负责实现我们的业务逻辑
• repo 负责数据操作， 仅做数据操作，不实现业务逻辑

在之前的文章中仅仅提到了一个非常简单的示例，但是我们实际业务流程往往没有那么简单，就一个非常常见的例子，我们现在需要创建一篇文章，文章上需要关联分类或者是标签信息，这里至少就分两步:

• 创建文章
• 关联文章和标签

这两个创建操作需要保证一致性，我们需要在数据库中使用事务，这时候我们的事务在哪里承载呢？

在 repo 层承载事务

其中最简单也最直接的办法就是在 repo 的 CreateArticle 方法中我们就使用事务去同时创建文章以及标签之间的关联关系.

• 我们不是所有的业务场景都需要关联创建，有的场景下我们只需要一个单纯的方法又怎么办呢?
• 这么写还有一个问题，我们把业务逻辑下沉到了 repo 中，后面我们还有其它关联也这么搞么?

针对第一个问题，最简单的办法就是我们提供一个 CreateArticleWithTags 方法表示同时创建这两者，如果我们需要一个独立的 CreateArticle 再写一个就好了.

但是随着需求越来越多，可能后面还有需要和角色关联的，和商品关联的等等.

难道我们就一种逻辑写一个方法么。想想就可怕.

还是在参数中加上很多可选的 options，然后在一个方法中不断判断。那我们还拿 usecase 做什么直接写一起不更好么？

在 usecase 层承载事务

ok，所以直接在 repo 层里面来实现看上去好像行不通，那我们就把视线往上移动，我们在 usecase 来解决这个问题.

事务的能力是在 repo 上提供的，所以我们需要在 repo 层提供一个事务接口，然后在 usecase 中进行调用，保证是事务执行的就行.

使用 repo 层提供的事务接口

1. // domain/article.go
2. // ArticleRepoTxFunc 事务方法
3. type ArticleRepoTxFunc = func(ctx context.Context, repo IArticleRepo) error
4. // IArticleRepo IArticleRepo
5. type IArticleRepo interface {
6. Tx(ctx context.Context, f ArticleRepoTxFunc) error
7. GetArticle(ctx context.Context, id int) (*Article, error)
8. CreateArticle(ctx context.Context, article *Article) error
9. }

在 repo 中，我们可以像上面这样定义，提供一个 Tx 方法，这个方法接受一个 ArticleRepoTxFunc 作为参数，这个函数中的 repo 是开启了事务的 repo，通过这个 repo 调用的所有方法都是在事务中执行的.

1. // repo/article.go
2. func (r *article) Tx(ctx context.Context, f domain.ArticleRepoTxFunc) error {
3. // 注意，这里的 r.db 是 *gorm.DB
4. // 在 gorm 中提供了 Transaction 的工具方法用于执行事务，这里我们就不自己写了
5. return r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
6. // 我们使用事务的 tx 重新初始化一个 repo
7. // 这个 repo 后续的执行的数据库相关的操作就都是事务的了
8. repo := NewArticleRepo(tx)
9. return f(ctx, repo)
10. })
11. }

然后我们在 usecase 调用的时候就可以这样.

1. // usecase/article.go
2. func (u *article) CreateArticle(ctx context.Context, article *domain.Article, tagIDs []uint) error {
3. return u.repo.Tx(ctx, func(ctx context.Context, repo domain.IArticleRepo) error {
4. err := repo.CreateArticle(ctx, article)
5. if err != nil {
6. return err
7. }
8. var ats []*domain.ArticleTag
9. for _, tid := range tagIDs {
10. ats = append(ats, &domain.ArticleTag{
11. ArticleID: article.ID,
12. TagID: tid,
13. })
14. }
15. return repo.CreateArticleTags(ctx, ats)
16. })
17. }

这样写起来就整洁很多了，业务逻辑和我们最初的设计一样，在 usecase 中实现了，repo 中我们也保持了简单的原则.

这样是不是就万事大吉了呢?如果万事大吉了这篇文章到这儿也就应该结束了，但是还没有，说明我在实践的过程中还碰到了问题.

问题很简单，就是我们在 usecase 中不仅仅需要复用 repo 中的代码，还有可能需要复用 usecase 中的代码，不然我们就可能在 usecase 中出现很多相同的逻辑代码片段，代码的重复率就很高.

我们来看下面一个例子会不会发现有点什么不对.

1. // usecase/article.go
2. func (u *article) A(ctx contect, args args) error {
3. err := u.CreateArticle(ctx, args.Article) // 包含事务
4. if err != nil {
5. return err
6. }
7. return u.UpdateXXX(ctx, args.XXX) // 这个方法中也使用了事务
8. }

这个方法内其实是开启了两个事务，这两个事务之间互不相关，不符合我们需求.

在 usecase 层提供事务方法

1. // usecase/article.go
2. type handler func(ctx context.Context, usecase domain.IArticleUsecase) error
3. func (u *article) tx(ctx context.Context, f handler) error {
4. return u.repo.Tx(ctx, func(ctx context.Context, repo domain.IArticleRepo) error {
5. usecase := NewArticleUsecase(repo)
6. return f(ctx, usecase)
7. })
8. }

我们在 usecase 中也创建了一个 tx 方法，和 repo 类似，在调用 tx 之后，handler 中的方法的需要都是用新的参数 usecase 这个新的 usecase 可以保证里面的 repo 调用都是事务的.

所以我们之前的 A 函数可以修改为这样:

1. // usecase/article.go
2. func (u *article) A(ctx contect, args args) error {
3. return u.tx(ctx, func(ctx context.Context, usecase domain.IArticleUsecase) error {
4. err := usecase.CreateArticle(ctx, args.Article) // 包含事务
5. if err != nil {
6. return err
7. }
8. return usecase.UpdateXXX(ctx, args.XXX) // 这个方法中也使用了事务
9. })
10. }

这样就没有问题了么?我们 UpdateXXX 方法中也调用 u.tx 方法，这样就会导致反复开启事务，虽然在 gorm 的 Transaction 方法是支持嵌套事务的，但是我们还是不要滥用这个特性.

解决办法很简单，我们只需要在执行的时候判断下就行了.

1. // usecase/article.go
2. type article struct {
3. repo domain.IArticleRepo
4. isTx bool // 用于标识是否开启了事务
5. }

然后我们在 tx 方法内:

1. func (u *article) tx(ctx context.Context, f handler) error {
2. // 如果已经开启过事务了我们就直接复用就行了
3. if u.isTx {
4. return f(ctx, u)
5. }
6. return u.repo.Tx(ctx, func(ctx context.Context, repo domain.IArticleRepo) error {
7. usecase := &article{
8. repo: repo,
9. isTx: true,
10. }
11. return f(ctx, usecase)
12. })
13. }

总结

文章到这里就到尾声了，同样的问题，我们现在这么写就可以了么？

对于我当前所遇到的一些需求来说已经可以解决了，当然这个方案并不完美，比如说我们涉及到多个 repo 的时候，当前的方法就没法直接用了，还得进行一些改造，虽然我们要有远见但是也不要想的太多，进化是优于完美的.

原文链接：https://mp.weixin.qq.com/s/MSwUlVGPDRBjdR-xh5cNfA 。

最后此篇关于Go工程化如何在整洁架构中使用事务?的文章就讲到这里了,如果你想了解更多关于Go工程化如何在整洁架构中使用事务?的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。