go-zero 框架本身不内置分布式事务,需通过集成 dtm(distributed transaction manager)实现。具体做法是:在 go-zero 微服务中引入 dtmcli 客户端,将本地数据库操作封装为 dtm 的分支事务,由 dtm 协调器统一调度 saga、tcc 或 seata at 模式。这样可确保跨服务调用的数据一致性,避免部分成功导致的脏数据。

DTM 如何与 Go-Zero 微服务集成?
DTM 通过 HTTP/gRPC 协议与 Go-Zero 服务通信,集成核心在于配置 dtmcli 连接地址并定义事务分支。开发者需在 Go-Zero 的服务端暴露回调接口,用于接收 DTM 的提交或回滚指令;同时在调用方使用 dtmcli.TransAction 包裹业务逻辑。这种解耦设计让 Go-Zero 专注于业务处理,而事务协调交由 DTM 完成,支持 Saga 和 TCC 两种主流模式。

package main
import (
"context"
"fmt"
"log"
"net/http"
"github.com/dtm-labs/client/go-zero/dtmgrpc"
"github.com/dtm-labs/client/go-zero/dtmhttp"
"go-zero-framework/service"
)
// OrderService 模拟 Go-Zero 订单服务
type OrderService struct {
service.BaseService
}
func (s *OrderService) CreateOrder(ctx context.Context, req *CreateOrderReq) (*CreateOrderResp, error) {
// 1. 初始化 DTM 客户端
dtmClient := dtmhttp.NewClient("http://localhost:8080")
// 2. 创建 Saga 事务
saga := dtmClient.Saga()
// 3. 添加前置补偿动作(回滚)
saga.Add(&dtmgrpc.Dtmservice,
&PreCompensateReq{OrderId: req.OrderId},
&PostCompensateReq{},
)
// 4. 添加主业务动作(提交)
saga.Add(&dtmgrpc.Dtmservice,
&MainBusinessReq{OrderId: req.OrderId},
&PostBusinessReq{},
)
// 5. 执行事务
err := saga.Submit()
if err != nil {
log.Fatalf("Saga failed: %v", err)
}
return &CreateOrderResp{Status: "success"}, nil
}
// 请求结构体定义
type CreateOrderReq struct {
OrderId string
}
type CreateOrderResp struct {
Status string
}
type PreCompensateReq struct {
OrderId string
}
type PostCompensateReq struct{}
type MainBusinessReq struct {
OrderId string
}
type PostBusinessReq struct{}
func main() {
s := &OrderService{}
http.HandleFunc("/create", func(w http.ResponseWriter, r *http.Request) {
resp, _ := s.CreateOrder(r.Context(), &CreateOrderReq{OrderId: "123"})
fmt.Fprint(w, resp.Status)
})
log.Fatal(http.ListenAndServe(":8081", nil))
}
TCC 模式在 Go-Zero 中的具体实现步骤是什么?
TCC(Try-Confirm-Cancel)模式要求每个服务实现三个方法:Try 预留资源、Confirm 确认提交、Cancel 释放资源。在 Go-Zero 中,需为每个业务接口编写对应的 TCC 回调函数,并通过 dtmcli.TccTransaction 注册这些回调。DTM 会根据全局事务状态自动调用 Confirm 或 Cancel,确保最终一致性。相比 Saga,TCC 对代码侵入性更高,但能提供更强的隔离性。

package main
import (
"context"
"fmt"
"log"
"net/http"
"github.com/dtm-labs/client/go-zero/dtmhttp"
)
// TccService 实现 TCC 模式的 Go-Zero 服务
type TccService struct{}
func (s *TccService) ExecuteTcc(ctx context.Context) error {
dtmClient := dtmhttp.NewClient("http://localhost:8080")
tcc := dtmClient.TccTransaction()
// 注册 Try 阶段:预留库存
tcc.Add(&TccService{},
&TryReq{ItemId: "item-001", Qty: 1},
&EmptyReq{},
)
// 注册 Confirm 阶段:扣减库存
tcc.Add(&TccService{},
&ConfirmReq{ItemId: "item-001", Qty: 1},
&EmptyReq{},
)
// 注册 Cancel 阶段:恢复库存
tcc.Add(&TccService{},
&CancelReq{ItemId: "item-001", Qty: 1},
&EmptyReq{},
)
// 执行 TCC 事务
err := tcc.Begin()
if err != nil {
return err
}
// 模拟业务逻辑失败,触发 Cancel
// err = someBusinessLogic()
// if err != nil {
// return tcc.Revert()
// }
return tcc.Commit()
}
type TryReq struct {
ItemId string
Qty int
}
type ConfirmReq struct {
ItemId string
Qty int
}
type CancelReq struct {
ItemId string
Qty int
}
type EmptyReq struct{}
func (s *TccService) Try(ctx context.Context, req *TryReq) (*EmptyReq, error) {
fmt.Println("Try: Reserving item", req.ItemId)
return &EmptyReq{}, nil
}
func (s *TccService) Confirm(ctx context.Context, req *ConfirmReq) (*EmptyReq, error) {
fmt.Println("Confirm: Deducting item", req.ItemId)
return &EmptyReq{}, nil
}
func (s *TccService) Cancel(ctx context.Context, req *CancelReq) (*EmptyReq, error) {
fmt.Println("Cancel: Restoring item", req.ItemId)
return &EmptyReq{}, nil
}
func main() {
svc := &TccService{}
if err := svc.ExecuteTcc(context.Background()); err != nil {
log.Fatalf("TCC failed: %v", err)
}
}
当 Go-Zero 服务中某个分支事务返回错误时,DTM 会如何处理?
当分支事务返回错误或超时未响应时,DTM 会自动触发补偿机制。对于 Saga 模式,DTM 会按逆序调用已执行分支的补偿接口(如 PreCompensate),确保数据回滚到初始状态。对于 TCC 模式,DTM 会调用 Cancel 方法释放已预留资源。开发者无需手动编写重试或回滚逻辑,DTM 内部维护了事务状态机,保证最终一致性。若所有补偿也失败,DTM 会将事务标记为异常,需人工介入或通过告警系统监控。


















