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

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

P粉602998670

发布： 2025-12-24 11:01:40

原创

155人浏览过

策略模式通过接口+结构体组合实现算法可插拔，状态模式用状态对象封装行为并支持流转，二者可组合用于风控等需依状态动态切换算法的场景。

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

策略模式：让算法可插拔

策略模式的核心是把一组算法封装成独立的类型，通过统一接口调用，运行时动态替换。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)

登录后复制

状态模式：让对象行为随状态变化

状态模式把对象内部状态封装成独立类型，每个状态定义自身的行为逻辑，对象委托给当前状态处理请求。Golang 中常用结构体嵌入 + 接口 + 指针接收者来模拟“状态切换”。

立即学习“go语言免费学习笔记（深入）”；

以订单状态为例：待支付 → 已支付 → 已发货 → 已完成，不同状态下允许的操作不同：

趣问问AI

免费可用的国内版chat，AI写作和AI对话

查看详情

// 状态接口
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()                   // 变为已发货

登录后复制

策略 + 状态组合：动态选择算法并响应状态

真实场景中，状态常决定可用策略。例如风控系统：订单在“待支付”时用「基础验签策略」，进入“已支付”后切换为「实时反欺诈策略」，发货后启用「物流异常检测策略」。

可以将策略作为状态的组成部分，或由状态工厂返回对应策略：

每个状态类型内嵌一个策略字段，初始化时绑定专属算法
状态切换时自动更新策略，业务调用统一入口（如 RunCheck()），内部委托给当前策略执行
策略本身保持无状态，纯函数式；状态对象负责生命周期和切换逻辑

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{}}
}

登录后复制