Golang状态模式应用与实践解析

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)
}

func main() {
    order := NewOrder()

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

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