Golang如何应用状态机模式管理状态_Golang 状态机模式实践_技术教程

状态机模式通过定义状态、事件、转移和动作来清晰管理对象生命周期，适用于订单等场景。

在 Go 开发中，状态机模式是管理对象生命周期状态的有效方式。它能清晰地表达状态流转逻辑，避免散乱的 if-else 判断，提升代码可维护性。尤其适用于订单、任务、审批流程等有明确状态和转换规则的场景。

什么是状态机模式

状态机（State Machine）是一种行为设计模式，用于描述一个对象在其生命周期内所经历的状态序列，以及如何响应来自外部的事件。核心要素包括：

状态（State）：对象当前所处的阶段，如 "待支付"、"已发货"
事件（Event）：触发状态变化的动作，如 "支付"、"发货"
转移（Transition）：定义在某个状态下响应某个事件后，应迁移到的新状态
动作（Action）：状态转移前后可执行的业务逻辑，如发送通知、更新数据库

用 Go 实现简易状态机

下面是一个基于订单状态管理的简单实现。通过 map 定义状态转移规则，并封装状态变更逻辑。

package main

import "fmt"

// OrderState 订单状态
type OrderState string

const (
    Pending   OrderState = "pending"   // 待支付
    Paid      OrderState = "paid"     // 已支付
    Shipped   OrderState = "shipped"  // 已发货
    Delivered OrderState = "delivered" // 已送达
    Cancelled OrderState = "cancelled" // 已取消
)

// Event 触发事件
type Event string

const (
    Pay     Event = "pay"
    Ship    Event = "ship"
    Deliver Event = "deliver"
    Cancel  Event = "cancel"
)

// Transition 表示一次状态转移
type Transition struct {
    From  OrderState
    To    OrderState
    Event Event
}

// StateMachine 状态机
type StateMachine struct {
    currentState OrderState
    transitions  map[OrderState]map[Event]OrderState
    actions      map[OrderState]func()
}

// NewStateMachine 初始化状态机
func NewStateMachine() *StateMachine {
    sm := &StateMachine{
        currentState: Pending,
        transitions:  make(map[OrderState]map[Event]OrderState),
        actions:      make(map[OrderState]func()),
    }

    // 定义合法转移
    sm.transitions[Pending] = map[Event]OrderState{
        Pay:    Paid,
        Cancel: Cancelled,
    }
    sm.transitions[Paid] = map[Event]OrderState{
        Ship:   Shipped,
        Cancel: Cancelled,
    }
    sm.transitions[Shipped] = map[Event]OrderState{
        Deliver: Delivered,
    }

    // 可选：注册进入状态时的动作
    sm.actions[Cancelled] = func() {
        fmt.Println("订单已取消，释放库存")
    }
    sm.actions[Delivered] = func() {
        fmt.Println("订单已完成，奖励积分")
    }

    return sm
}

// CanTransition 检查是否允许转移
func (sm *StateMachine) CanTransition(event Event) bool {
    if next, ok := sm.transitions[sm.currentState][event]; ok {
        return true
    }
    return false
}

// Transition 执行状态转移
func (sm *StateMachine) Transition(event Event) error {
    if !sm.CanTransition(event) {
        return fmt.Errorf("不允许的状态转移: %s -> %s", sm.currentState, event)
    }

    from := sm.currentState
    sm.currentState = sm.transitions[sm.currentState][event]

    fmt.Printf("状态变更: %s --(%s)--> %s\n", from, event, sm.currentState)

    // 执行进入新状态后的动作
    if action, exists := sm.actions[sm.currentState]; exists {
        action()
    }

    return nil
}

// Current 返回当前状态
func (sm *StateMachine) Current() OrderState {
    return sm.currentState
}

使用示例

实际调用非常直观：

func main() {
    sm := NewStateMachine()

    fmt.Println("初始状态:", sm.Current())

    sm.Transition(Pay)
    sm.Transition(Ship)
    sm.Transition(Deliver)

    // 输出：
    // 初始状态: pending
    // 状态变更: pending --(pay)--> paid
    // 状态变更: paid --(ship)--> shipped
    // 状态变更: shipped --(deliver)--> delivered
    // 订单已完成，奖励积分
}

如果尝试非法操作，比如从“待支付”直接发货：