策略模式通过接口+结构体组合实现算法可插拔，状态模式用状态对象封装行为并支持流转，二者可组合用于风控等需依状态动态切换算法的场景。
策略模式：让算法可插拔
策略模式的核心是把一组算法封装成独立的类型，通过统一接口调用，运行时动态替换。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语言免费学习笔记（深入）”；
以订单状态为例：待支付 → 已支付 → 已发货 → 已完成，不同状态下允许的操作不同：
// 状态接口
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{}}
}
关键设计提醒
- 避免状态爆炸：不是所有差异都要建新状态，优先用字段+条件分支；只有行为差异大、生命周期明确才抽状态
- 策略应无副作用、可并发安全；若需共享上下文（如缓存、DB连接），通过依赖注入传入，而非全局变量
- 状态切换建议加校验（如只允许从 A → B，禁止 A → C），可在 Next() 或 SetState() 中做守卫
- Golang 的接口是隐式实现，别为模式而接口——先写清楚行为契约，再补接口定义
不复杂但容易忽略
