状态模式控制行为的可用性，策略模式定义行为的具体实现。在订单系统中，不同状态（如待支付、已发货）决定哪些操作可执行，同时通过策略模式为“完成订单”等操作绑定不同逻辑（如发奖励或默认处理）。每个状态实现状态接口并提供对应的策略，如已发货状态使用RewardCompletion策略，完成时触发积分奖励；而待支付状态则不支持完成操作。结合两者使状态变化时自动切换行为集，提升代码灵活性与可维护性，适用于工作流、审批系统等复杂场景。Golang通过接口与组合实现该模式，无需继承即可解耦状态与行为。
在 Golang 中，状态模式和策略模式都可以用来解耦对象的行为与状态。将两者结合使用，可以在复杂业务场景中实现更灵活、可维护的代码结构。下面通过一个高级示例说明如何用 Golang 实现状态模式与策略模式的组合。
状态模式与策略模式的核心区别
状态模式：允许对象在其内部状态改变时改变其行为，对象看起来像是改变了类。通常由上下文持有当前状态，并委托具体行为给状态实现。
策略模式：定义一系列算法或行为，将它们封装起来并使它们可以互换。上下文在运行时选择不同的策略执行。
当我们将两者结合，可以让“状态”本身携带一组“策略”，从而实现状态变化的同时自动切换对应的行为集。
立即学习“go语言免费学习笔记（深入）”；
场景设计：订单处理系统
考虑一个电商订单系统，订单有多个状态（待支付、已支付、已发货、已完成），每个状态下支持的操作不同，且操作逻辑也不同。比如：
- 待支付时，支持取消订单和支付
- 已支付时，支持发货，不支持取消
- 已发货时，支持确认收货
同时，某些操作（如“完成订单”）可能在不同状态下有不同的处理逻辑（例如是否发奖励、是否计入统计），这就适合用策略模式来动态绑定。
结构设计与代码实现
我们定义以下结构：
1. 状态接口与具体状态每个状态实现通用的状态接口，并持有对应的策略集合。
type OrderContext struct {
State OrderState
}
type OrderState interface {
Pay(order *OrderContext)
Ship(order *OrderState)
Complete(order *OrderContext)
Cancel(order *OrderContext)
// 获取当前状态下的完成策略
GetCompletionStrategy() CompletionStrategy
}2. 策略接口
定义完成订单时使用的策略，不同状态使用不同策略。
type CompletionStrategy interface {
Execute(*OrderContext)
}
type DefaultCompletion struct{}
func (d *DefaultCompletion) Execute(order *OrderContext) {
println("默认完成逻辑：更新状态")
}
type RewardCompletion struct{}
func (r *RewardCompletion) Execute(order *OrderContext) {
println("奖励完成逻辑：发积分+更新状态")
}3. 具体状态实现
每个状态不仅控制行为，还提供对应的策略。
type PendingPaymentState struct{}
func (p *PendingPaymentState) Pay(order *OrderContext) {
println("订单已支付")
order.State = &PaidState{}
}
func (p *PendingPaymentState) Cancel(order *OrderContext) {
println("订单已取消")
order.State = &CancelledState{}
}
func (p *PendingPaymentState) Ship(order *OrderContext) {
println("无法发货：订单未支付")
}
func (p *PendingPaymentState) Complete(order *OrderContext) {
println("无法完成：订单未支付")
}
func (p *PendingPaymentState) GetCompletionStrategy() CompletionStrategy {
return nil // 未支付不能完成
}type PaidState struct{}
func (p *PaidState) Pay(order *OrderContext) {
println("订单已支付，无需重复支付")
}
func (p *PaidState) Ship(order *OrderContext) {
println("已发货")
order.State = &ShippedState{}
}
func (p *PaidState) Cancel(order *OrderContext) {
println("无法取消：已支付订单需申请退款")
}
func (p *PaidState) Complete(order *OrderContext) {
println("不能手动完成：需用户收货")
}
func (p *PaidState) GetCompletionStrategy() CompletionStrategy {
return nil
}type ShippedState struct{}
func (s *ShippedState) Pay(order *OrderContext) {
println("支付已完成")
}
func (s *ShippedState) Ship(order *OrderContext) {
println("已发货，无需重复发货")
}
func (s *ShippedState) Complete(order *OrderContext) {
strategy := s.GetCompletionStrategy()
if strategy != nil {
strategy.Execute(order)
order.State = &CompletedState{}
}
}
func (s *ShippedState) Cancel(order *OrderContext) {
println("无法取消：已发货")
}
func (s *ShippedState) GetCompletionStrategy() CompletionStrategy {
return &RewardCompletion{} // 发货后完成订单有奖励
}type CompletedState struct{}
func (c *CompletedState) Pay(order *OrderContext) {}
func (c *CompletedState) Ship(order *OrderContext) {}
func (c *CompletedState) Cancel(order *OrderContext) {
println("订单已完成，不支持取消")
}
func (c *CompletedState) Complete(order *OrderContext) {
println("订单已完成")
}
func (c *CompletedState) GetCompletionStrategy() CompletionStrategy {
return &DefaultCompletion{}
}4. 上下文调用示例
func main() {
order := &OrderContext{
State: &PendingPaymentState{},
}
order.State.Pay(order) // 支付
order.State.Ship(order) // 发货
order.State.Complete(order) // 完成（触发奖励策略）
// 输出：
// 订单已支付
// 已发货
// 奖励完成逻辑：发积分+更新状态
}优势与适用场景
这种组合模式的优势在于：
- 高内聚低耦合：每个状态决定可用操作和对应策略，逻辑集中
- 易于扩展：新增状态只需实现接口，不影响现有代码
- 行为可配置：策略可在状态中动态替换，比如灰度发布不同完成逻辑
适用于工作流引擎、审批系统、游戏角色状态机等需要状态驱动行为且行为多变的场景。
基本上就这些。Golang 虽无继承，但通过接口与组合，完全可以优雅实现状态与策略的融合。关键在于明确职责划分：状态控制“能不能做”，策略决定“怎么做”。
