如何用Golang处理分布式事务中的错误 Saga模式的错误补偿实现

package main

import (
    "errors"
    "fmt"
    "log"
    "sync"
)

// 定义一个Saga步骤
type SagaStep struct {
    Name      string
    Execute   func() error
    Compensate func() error
}

// Saga执行器
type SagaExecutor struct {
    Steps []SagaStep
    CompletedSteps []int // 记录已完成的步骤
    mu sync.Mutex
}

func (s *SagaExecutor) AddStep(step SagaStep) {
    s.Steps = append(s.Steps, step)
}

func (s *SagaExecutor) Execute() error {
    s.mu.Lock()
    defer s.mu.Unlock()

    for i, step := range s.Steps {
        err := step.Execute()
        if err != nil {
            log.Printf("Step %s failed: %v", step.Name, err)
            s.compensate(i)
            return err
        }
        s.CompletedSteps = append(s.CompletedSteps, i)
        log.Printf("Step %s completed", step.Name)
    }
    return nil
}

func (s *SagaExecutor) compensate(failedStepIndex int) {
    log.Println("Starting compensation...")
    // 倒序执行已完成步骤的补偿操作
    for i := len(s.CompletedSteps) - 1; i >= 0; i-- {
        stepIndex := s.CompletedSteps[i]
        step := s.Steps[stepIndex]
        err := step.Compensate()
        if err != nil {
            log.Printf("Compensation for step %s failed: %v", step.Name, err)
            // 在实际应用中，需要更完善的错误处理，例如重试或人工介入
        } else {
            log.Printf("Compensated step %s", step.Name)
        }
    }
}

// 模拟订单服务
func createOrder() error {
    // 模拟创建订单失败的情况
    //return errors.New("failed to create order")
    fmt.Println("Creating order...")
    return nil
}

func cancelOrder() error {
    fmt.Println("Cancelling order...")
    return nil
}

// 模拟库存服务
func deductStock() error {
    // 模拟库存不足的情况
    return errors.New("not enough stock")
    //fmt.Println("Deducting stock...")
    //return nil
}

func refundStock() error {
    fmt.Println("Refunding stock...")
    return nil
}

func main() {
    saga := SagaExecutor{}

    saga.AddStep(SagaStep{
        Name:      "CreateOrder",
        Execute:   createOrder,
        Compensate: cancelOrder,
    })

    saga.AddStep(SagaStep{
        Name:      "DeductStock",
        Execute:   deductStock,
        Compensate: refundStock,
    })

    err := saga.Execute()
    if err != nil {
        log.Printf("Saga failed: %v", err)
    } else {
        log.Println("Saga completed successfully")
    }
}

sync.Mutex

github.com/looplab/fsm