一小时用Golang高效工具轻松构建简单可靠的订单系统，优雅解决分布式事务难题

专业评论

这个订单系统示例展示了Golang在分布式事务处理上的优秀实践。核心亮点在于使用dtm框架优雅解决分布式事务问题，同时结合gRPC实现高效微服务通信。

关键架构设计

// 分布式事务示例 - SAGA模式
func CreateOrderSaga() error {
    saga := dtmcli.NewSaga(dtmServer, gid).
        Add(orderService+"/CreateOrder", orderService+"/CompensateOrder", orderData).
        Add(paymentService+"/CreatePayment", paymentService+"/CompensatePayment", paymentData)
    
    return saga.Submit()
}

// TCC模式实现
func TryCreateOrder(ctx context.Context, req *pb.CreateOrderReq) error {
    // 1. 预扣库存
    if err := inventoryClient.TryDeduct(ctx, req); err != nil {
        return err
    }
    
    // 2. 预创建订单
    order := &Order{
        Status:    "pending",
        CreatedAt: time.Now(),
    }
    if err := db.Create(order).Error; err != nil {
        return err
    }
    
    return nil
}

核心特性实现

1. 订单服务层

type OrderService struct {
    pb.UnimplementedOrderServer
    dtmClient *dtmgrpc.Client
    db        *gorm.DB
}

func (s *OrderService) CreateOrder(ctx context.Context, req *pb.CreateOrderReq) (*pb.CreateOrderResp, error) {
    // 开启本地事务
    tx := s.db.Begin()
    
    // 创建订单记录
    order := &model.Order{
        OrderNo:   generateOrderNo(),
        UserID:    req.UserId,
        Amount:    req.Amount,
        Status:    model.StatusPending,
    }
    
    if err := tx.Create(order).Error; err != nil {
        tx.Rollback()
        return nil, err
    }
    
    // 调用库存服务
    if err := s.callInventoryService(ctx, order); err != nil {
        tx.Rollback()
        return nil, err
    }
    
    tx.Commit()
    return &pb.CreateOrderResp{OrderId: order.ID}, nil
}

2. 分布式事务协调

func (s *OrderService) handleDistributedTransaction(ctx context.Context, orderID uint64) error {
    // 使用DTM的MSG模式
    msg := dtmgrpc.NewMsgGrpc(dtmServer, gid).
        Add(orderService+"/ConfirmOrder", orderData).
        Add(inventoryService+"/ConfirmDeduct", inventoryData)
    
    // 设置超时和重试策略
    msg.SetTimeout(30 * time.Second).
        SetRetryInterval(5 * time.Second).
        SetBranchHeaders(map[string]string{"order_id": fmt.Sprintf("%d", orderID)})
    
    return msg.Submit()
}

3. 幂等性处理

func (s *OrderService) CreateOrderWithIdempotency(ctx context.Context, req *pb.CreateOrderReq) error {
    // 基于唯一业务ID的幂等检查
    key := fmt.Sprintf("order:%s:%d", req.OrderToken, req.UserId)
    
    // Redis分布式锁
    lock := redis.NewLock(key, 10*time.Second)
    if !lock.Acquire() {
        return errors.New("operation in progress")
    }
    defer lock.Release()
    
    // 幂等记录检查
    if exists, _ := s.redis.Exists(ctx, key).Result(); exists > 0 {
        return nil // 已处理，直接返回成功
    }
    
    // 执行业务逻辑
    // ...
    
    // 设置幂等标记
    s.redis.SetEX(ctx, key, "1", 24*time.Hour)
    return nil
}

性能优化技巧

// 批量处理订单
func BatchCreateOrders(orders []*model.Order) error {
    return s.db.Transaction(func(tx *gorm.DB) error {
        // 批量插入
        batchSize := 100
        for i := 0; i < len(orders); i += batchSize {
            end := i + batchSize
            if end > len(orders) {
                end = len(orders)
            }
            
            if err := tx.Create(orders[i:end]).Error; err != nil {
                return err
            }
        }
        return nil
    })
}

// 连接池配置
func initGRPCClient() {
    conn, err := grpc.Dial(
        serviceEndpoint,
        grpc.WithInsecure(),
        grpc.WithDefaultServiceConfig(`{"loadBalancingPolicy":"round_robin"}`),
        grpc.WithInitialWindowSize(65535),
        grpc.WithInitialConnWindowSize(65535),
        grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(1024*1024*10)),
    )
}

这个实现方案通过DTM框架将复杂的分布式事务简化为声明式配置，结合Golang的高并发特性，确实能在短时间内构建出可靠的订单系统。代码结构清晰，事务边界明确，是生产级分布式系统的优秀参考实现。