如何用Golang实现状态模式与策略模式组合_Golang 状态模式高级示例-Golang-PHP中文网

如何用Golang实现状态模式与策略模式组合_Golang 状态模式高级示例

P粉602998670

发布： 2025-11-26 08:44:31

原创

695人浏览过

状态模式控制行为的可用性，策略模式定义行为的具体实现。在订单系统中，不同状态（如待支付、已发货）决定哪些操作可执行，同时通过策略模式为“完成订单”等操作绑定不同逻辑（如发奖励或默认处理）。每个状态实现状态接口并提供对应的策略，如已发货状态使用RewardCompletion策略，完成时触发积分奖励；而待支付状态则不支持完成操作。结合两者使状态变化时自动切换行为集，提升代码灵活性与可维护性，适用于工作流、审批系统等复杂场景。Golang通过接口与组合实现该模式，无需继承即可解耦状态与行为。

如何用golang实现状态模式与策略模式组合_golang 状态模式高级示例

在 Golang 中，状态模式和策略模式都可以用来解耦对象的行为与状态。将两者结合使用，可以在复杂业务场景中实现更灵活、可维护的代码结构。下面通过一个高级示例说明如何用 Golang 实现状态模式与策略模式的组合。

状态模式与策略模式的核心区别

状态模式：允许对象在其内部状态改变时改变其行为，对象看起来像是改变了类。通常由上下文持有当前状态，并委托具体行为给状态实现。

策略模式：定义一系列算法或行为，将它们封装起来并使它们可以互换。上下文在运行时选择不同的策略执行。

当我们将两者结合，可以让“状态”本身携带一组“策略”，从而实现状态变化的同时自动切换对应的行为集。

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

场景设计：订单处理系统

考虑一个电商订单系统，订单有多个状态（待支付、已支付、已发货、已完成），每个状态下支持的操作不同，且操作逻辑也不同。比如：

待支付时，支持取消订单和支付
已支付时，支持发货，不支持取消
已发货时，支持确认收货

同时，某些操作（如“完成订单”）可能在不同状态下有不同的处理逻辑（例如是否发奖励、是否计入统计），这就适合用策略模式来动态绑定。

结构设计与代码实现

我们定义以下结构：

1. 状态接口与具体状态

每个状态实现通用的状态接口，并持有对应的策略集合。

Freepik Mystic

Freepik Mystic 是一款革命性的AI图像生成器，可以直接生成全高清图像

127

查看详情

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) // 完成（触发奖励策略）

    // 输出：
    // 订单已支付
    // 已发货
    // 奖励完成逻辑：发积分+更新状态
}

登录后复制