Go权限审计网关事务边界 - 第2节

2.1 模块系统：从 GOPATH 到 Go Modules

Go 语言的模块系统经历了从 GOPATH 到 Go Modules 的演进。在构建权限审计网关这类多服务、多依赖的工程时，模块系统决定了依赖管理的清晰度与可复现性。

# 初始化模块
go mod init github.com/team/gateway

# 添加依赖（自动更新 go.mod）
go get github.com/gin-gonic/gin@v1.9.1

# 整理依赖
go mod tidy

# 将依赖下载到本地 vendor 目录（离线构建用）
go mod vendor

在权限审计网关中，建议将核心业务逻辑、中间件、存储层拆分为独立内部包，通过模块路径隔离变更边界。

2.2 接口与结构体：组合优于继承

Go 通过接口（interface）与结构体（struct）实现多态与组合。在网关事务边界设计中，接口定义了“能做什么”，结构体定义了“怎么做”。

接口定义示例

// Authenticator 定义认证能力
type Authenticator interface {
    Authenticate(ctx context.Context, token string) (*Claims, error)
}

// Auditor 定义审计日志能力
type Auditor interface {
    Record(ctx context.Context, entry AuditEntry) error
}

// TransactionBoundary 定义事务边界能力
type TransactionBoundary interface {
    Begin(ctx context.Context) (Tx, error)
    Commit(ctx context.Context, tx Tx) error
    Rollback(ctx context.Context, tx Tx) error
}

结构体组合实现

// GatewayService 通过组合多个接口实现网关核心逻辑
type GatewayService struct {
    auth   Authenticator
    audit  Auditor
    txMgr  TransactionBoundary
}

func NewGatewayService(auth Authenticator, audit Auditor, txMgr TransactionBoundary) *GatewayService {
    return &GatewayService{
        auth:  auth,
        audit: audit,
        txMgr: txMgr,
    }
}

2.3 错误处理模式：显式与可控

Go 的错误处理强调显式检查，不依赖异常抛出。在网关事务边界中，错误处理直接影响事务的提交或回滚决策。

标准错误模式

func (s *GatewayService) ProcessRequest(ctx context.Context, req *Request) error {
    // 1. 认证
    claims, err := s.auth.Authenticate(ctx, req.Token)
    if err != nil {
        return fmt.Errorf("authenticate failed: %w", err)
    }

    // 2. 开启事务
    tx, err := s.txMgr.Begin(ctx)
    if err != nil {
        return fmt.Errorf("begin tx failed: %w", err)
    }
    defer func() {
        if err != nil {
            // 发生错误时回滚
            _ = s.txMgr.Rollback(ctx, tx)
        }
    }()

    // 3. 执行业务逻辑（可能失败）
    if err = s.doBusiness(ctx, tx, claims); err != nil {
        return err // defer 中会回滚
    }

    // 4. 提交事务
    if err = s.txMgr.Commit(ctx, tx); err != nil {
        return fmt.Errorf("commit tx failed: %w", err)
    }
    return nil
}

错误类型与分类

2.4 并发原语：goroutine 与 channel 的边界控制

Go 的并发模型基于 goroutine 和 channel。在网关中，每个请求通常由一个 goroutine 处理，但事务边界需要跨 goroutine 协调时，必须使用同步原语。

常用并发原语对比

事务边界中的并发控制示例

func (s *GatewayService) ConcurrentProcess(ctx context.Context, req *Request) error {
    ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
    defer cancel()

    // 开启事务
    tx, err := s.txMgr.Begin(ctx)
    if err != nil {
        return err
    }

    errCh := make(chan error, 2)
    var wg sync.WaitGroup

    // 并发执行两个子任务
    wg.Add(2)
    go func() {
        defer wg.Done()
        errCh <- s.taskA(ctx, tx)
    }()
    go func() {
        defer wg.Done()
        errCh <- s.taskB(ctx, tx)
    }()

    // 等待所有任务完成
    wg.Wait()
    close(errCh)

    // 检查是否有错误
    for err := range errCh {
        if err != nil {
            s.txMgr.Rollback(ctx, tx)
            return fmt.Errorf("concurrent task failed: %w", err)
        }
    }

    return s.txMgr.Commit(ctx, tx)
}