Golang如何使用状态模式管理对象状态_Golang状态模式对象状态管理实践详解-Golang-PHP中文网

Golang如何使用状态模式管理对象状态_Golang状态模式对象状态管理实践详解

P粉602998670

发布： 2025-11-04 21:32:02

原创

569人浏览过

状态模式通过接口与组合实现行为随状态变化，如订单系统中不同状态下操作响应不同，消除条件判断，提升可维护性。

golang如何使用状态模式管理对象状态_golang状态模式对象状态管理实践详解

在Go语言中，状态模式是一种行为设计模式，它允许对象在其内部状态改变时改变其行为。通过将状态相关的行为封装到独立的结构体中，可以让代码更清晰、易于维护和扩展。尤其在处理复杂的状态流转逻辑时，比如订单系统、工作流引擎或设备控制程序，状态模式能有效避免大量的条件判断语句。

状态模式的核心思想

状态模式的关键在于：将每个状态定义为一个接口实现，对象的行为委托给当前状态实例。当状态发生变化时，只需更换内部的状态实例，调用同一方法就会产生不同的行为。

这种做法把“状态判断 + 行为执行”的耦合拆解开来，使新增状态或修改状态逻辑变得非常灵活。

核心组成包括：

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

Context（上下文）：持有当前状态的对象，对外提供操作方法
State 接口：定义所有具体状态共有的行为方法
ConcreteState（具体状态）：实现 State 接口，封装特定状态下的行为

使用示例：订单状态管理

假设我们有一个订单系统，订单有“待支付”、“已支付”、“已发货”、“已完成”四种状态。不同状态下对“支付”、“发货”、“完成”等操作的响应不同。

package main

import "fmt"

// 定义状态接口
type OrderState interface {
    Pay(order *Order)
    Ship(order *Order)
    Complete(order *Order)
    Cancel(order *Order)
}

// 待支付状态
type PendingState struct{}

func (s *PendingState) Pay(order *Order) {
    fmt.Println("订单已支付")
    order.setState(&PaidState{})
}

func (s *PendingState) Ship(order *Order) {
    fmt.Println("无法发货：订单尚未支付")
}

func (s *PendingState) Complete(order *Order) {
    fmt.Println("无法完成：订单尚未支付")
}

func (s *PendingState) Cancel(order *Order) {
    fmt.Println("订单已取消")
    order.setState(&CanceledState{})
}

// 已支付状态
type PaidState struct{}

func (s *PaidState) Pay(order *Order) {
    fmt.Println("订单已支付，无需重复支付")
}

func (s *PaidState) Ship(order *Order) {
    fmt.Println("已发货")
    order.setState(&ShippedState{})
}

func (s *PaidState) Complete(order *Order) {
    fmt.Println("不能直接完成：请先发货")
}

func (s *PaidState) Cancel(order *Order) {
    fmt.Println("订单已取消")
    order.setState(&CanceledState{})
}

// 已发货状态
type ShippedState struct{}

func (s *ShippedState) Pay(order *Order) {
    fmt.Println("订单已支付")
}

func (s *ShippedState) Ship(order *Order) {
    fmt.Println("已发货，无需再次发货")
}

func (s *ShippedState) Complete(order *Order) {
    fmt.Println("订单已完成")
    order.setState(&CompletedState{})
}

func (s *ShippedState) Cancel(order *Order) {
    fmt.Println("已发货，无法取消")
}

// 已完成状态
type CompletedState struct{}

func (s *CompletedState) Pay(order *Order) {
    fmt.Println("订单已完成，无法支付")
}

func (s *CompletedState) Ship(order *Order) {
    fmt.Println("订单已完成，无法再次发货")
}

func (s *CompletedState) Complete(order *Order) {
    fmt.Println("订单已完成")
}

func (s *CompletedState) Cancel(order *Order) {
    fmt.Println("订单已完成，无法取消")
}

// 取消状态
type CanceledState struct{}

func (s *CanceledState) Pay(order *Order) {
    fmt.Println("订单已取消，无法支付")
}

func (s *CanceledState) Ship(order *Order) {
    fmt.Println("订单已取消，无法发货")
}

func (s *CanceledState) Complete(order *Order) {
    fmt.Println("订单已取消，无法完成")
}

func (s *CanceledState) Cancel(order *Order) {
    fmt.Println("订单已取消")
}

// 订单结构体（上下文）
type Order struct {
    state StateInterface
}

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

// 设置新状态
func (o *Order) setState(state OrderState) {
    o.state = state
}

// 委托调用当前状态的方法
func (o *Order) Pay() {
    o.state.Pay(o)
}

func (o *Order) Ship() {
    o.state.Ship(o)
}

func (o *Order) Complete() {
    o.state.Complete(o)
}

func (o *Order) Cancel() {
    o.state.Cancel(o)
}

登录后复制

上面的例子中，Order 结构体不直接处理各种状态逻辑，而是将其委托给当前持有的 state 实例。每次调用方法都会由实际状态决定行为，并可自动切换到下一个状态。

百灵大模型

蚂蚁集团自研的多模态AI大模型系列

177

查看详情

测试状态流转

编写一个简单的 main 函数来验证状态流转是否正确：

func main() {
    order := NewOrder()

    order.Pay()     // 输出：订单已支付 → 状态变为 Paid
    order.Ship()    // 输出：已发货 → 状态变为 Shipped
    order.Complete()// 输出：订单已完成 → 状态变为 Completed
    order.Pay()     // 输出：订单已完成，无法支付

    // 尝试从已支付状态取消
    anotherOrder := NewOrder()
    anotherOrder.Pay()
    anotherOrder.Cancel() // 输出：订单已取消
}

登录后复制

输出结果会清晰展示每一步操作对应的状态行为，且不会出现非法操作。