如何使用Golang实现策略+状态模式_动态算法和状态切换

// 定义策略接口
type PaymentStrategy interface {
    Pay(amount float64) error
}

// 微信支付策略
type WechatPay struct{}
func (w WechatPay) Pay(amount float64) error {
    fmt.Printf("微信支付 %.2f 元\n", amount)
    return nil
}

// 支付宝策略
type Alipay struct{}
func (a Alipay) Pay(amount float64) error {
    fmt.Printf("支付宝支付 %.2f 元\n", amount)
    return nil
}

// 上下文：持有当前策略，可随时切换
type PaymentContext struct {
    strategy PaymentStrategy
}

func (p *PaymentContext) SetStrategy(s PaymentStrategy) {
    p.strategy = s
}

func (p *PaymentContext) ExecutePayment(amount float64) error {
    if p.strategy == nil {
        return errors.New("no strategy set")
    }
    return p.strategy.Pay(amount)
}

ctx := &PaymentContext{}
ctx.SetStrategy(WechatPay{})
ctx.ExecutePayment(99.9)

ctx.SetStrategy(Alipay{})
ctx.ExecutePayment(128.5)

// 状态接口
type OrderState interface {
    Handle(ctx *Order) error
    Name() string
}

// 各状态实现
type PendingState struct{}
func (p PendingState) Name() string { return "待支付" }
func (p PendingState) Handle(ctx *Order) error {
    fmt.Println("跳转到支付页")
    ctx.state = &PaidState{} // 切换状态
    return nil
}

type PaidState struct{}
func (p PaidState) Name() string { return "已支付" }
func (p PaidState) Handle(ctx *Order) error {
    fmt.Println("通知仓库发货")
    ctx.state = &ShippedState{}
    return nil
}

// 订单上下文
type Order struct {
    ID    string
    state OrderState
}

func NewOrder(id string) *Order {
    return &Order{
        ID:    id,
        state: &PendingState{},
    }
}

func (o *Order) Process() error {
    return o.state.Handle(o)
}

func (o *Order) CurrentState() string {
    return o.state.Name()
}

order := NewOrder("ORD-001")
fmt.Println(order.CurrentState()) // 待支付
order.Process()                   // 变为已支付
fmt.Println(order.CurrentState()) // 已支付
order.Process()                   // 变为已发货

type RiskState interface {
    RunCheck(data map[string]interface{}) error
    Next() RiskState
}

type PendingRiskState struct {
    strategy *BasicSignatureStrategy
}

func (s *PendingRiskState) RunCheck(data map[string]interface{}) error {
    return s.strategy.Check(data)
}

func (s *PendingRiskState) Next() RiskState {
    return &PaidRiskState{strategy: &FraudDetectionStrategy{}}
}