罗罗编程学习记录
本页内容 展开查看

01.3.2.11 状态与命令模式

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解

覆盖范围

  • 状态对象与状态机:状态、事件、迁移
  • 状态转换表 vs 状态对象的取舍
  • 状态模式与策略模式的结构相似性与意图差异
  • 无状态状态对象与共享
  • Java 枚举状态机、Go stateFn、Python 手写状态机
  • TypeScript 状态机与 XState 的位置
  • Rust enum + match 与 typestate
  • 命令模式三角色:调用者 / 接收者 / 命令对象
  • 撤销与重做:Undo/Redo 栈
  • 宏命令与命令队列
  • 命令与策略、观察者、CQRS Command 的概念区别
  • 框架落地:任务队列、事务脚本、命令总线

面试题索引

编号 题目 难度 状态 备注
01.3.2.11-001 状态模式解决什么问题?状态对象与状态机是什么关系? 基础 已完成 状态机基本概念
01.3.2.11-002 状态转换表和状态对象怎么取舍? 进阶 已完成 表驱动 vs 类驱动
01.3.2.11-003 状态模式与策略模式的关键区别是什么? 进阶 已完成 结构相似、意图不同
01.3.2.11-004 状态对象为什么通常无状态?共享实例要注意什么? 进阶 已完成 状态对象与上下文
01.3.2.11-005 Java 枚举状态机怎么写? 进阶 已完成 枚举自带行为
01.3.2.11-006 Go 的 stateFn 写法是什么? 进阶 已完成 函数式状态机
01.3.2.11-007 Python 怎么手写一个状态机? 进阶 已完成 字典驱动
01.3.2.11-008 TypeScript 状态机与 XState 各自的位置? 进阶 已完成 库的边界
01.3.2.11-009 Rust 用 enum + match 怎么表达状态机?typestate 是什么? 高级 已完成 类型级状态
01.3.2.11-010 命令模式的三角色怎么分工? 基础 已完成 调用者/接收者/命令
01.3.2.11-011 撤销与重做怎么用 Undo/Redo 栈实现? 进阶 已完成 反向操作 vs 快照
01.3.2.11-012 宏命令与命令队列解决什么问题? 进阶 已完成 组合与异步
01.3.2.11-013 命令与策略、观察者、CQRS Command 有什么区别? 进阶 已完成 概念层级
01.3.2.11-014 命令在框架里的真实形态是什么?任务队列、事务脚本、命令总线? 进阶 已完成 工程落地

01.3.2.11-001 状态模式解决什么问题?状态对象与状态机是什么关系?

一句话结论

状态模式把对象在不同状态下的行为拆成独立的状态类,对象内部持有「当前状态」,事件到来时委托给当前状态处理,由状态决定下一状态;它替代的是在业务类里堆 if (state == A) ... else if (state == B) ... 的写法。

概念解释

  • 三个角色:上下文(Context,持有当前状态与业务数据)、抽象状态(声明事件接口)、具体状态(实现本状态允许的事件与迁移规则)。
  • 状态机:由状态集合、事件集合、迁移函数组成的数学模型;状态模式是状态机在面向对象语言里的一种实现。
  • 触发条件:状态数量 ≥ 4、迁移规则复杂、新增状态会频繁修改主干代码。

原理流程

  1. 业务对象(上下文)持有当前状态引用。
  2. 外部事件到来,上下文调用 current.onEvent(event)。
  3. 当前状态对象判断本状态是否允许该事件,允许则修改上下文字段并把 current 切换到下一状态。
  4. 不允许则忽略、抛业务异常或记录非法迁移。

代码或图示

订单状态机:
待支付 --支付成功--> 已支付 --发货--> 已发货 --确认--> 已完成
待支付 --取消------> 已取消
已支付 --取消------> 已取消
public interface OrderState {
    OrderState pay(OrderContext ctx);
    OrderState ship(OrderContext ctx);
}

常见误区

  • 状态少也强行拆类:两三个状态、迁移规则简单时,枚举 + switch 更直接,拆类反而把简单流程打散。
  • 状态对象里直接持有业务数据:业务数据应放在上下文,状态对象只持有迁移规则,避免多个状态实例复制数据。

追问

  • 状态机必须是「有限」的吗?答:实务里几乎都是有限状态机(FSM),状态集合可枚举;无限状态机需要额外建模,超出本模式范围。
  • 状态模式和状态表是同一件事吗?答:状态表是迁移的另一种表达(行=状态、列=事件、单元格=下一状态),状态对象是 OO 表达,两者可以互相转换。

01.3.2.11-002 状态转换表和状态对象怎么取舍?

一句话结论

状态转换表用数据结构(Map / 二维表)描述「当前状态 + 事件 → 下一状态」,简单、易审查、可配置;状态对象用类描述每个状态的行为与迁移,复杂行为更易内聚,但类数量膨胀。状态少、规则集中用表;每个状态有大量独立行为用状态对象。

概念解释

  • 表驱动:Map<(State, Event), State>,迁移逻辑集中在一处,业务事件只查表更新。
  • 对象驱动:每个状态一个类,行为与迁移内聚在类内,符合开闭原则。
  • 混合:表存合法迁移,行为放在状态对象里。

原理流程

  1. 数状态与事件数量:状态少、迁移简单 → 表。
  2. 每个状态行为差异大、会随业务演化 → 状态对象。
  3. 迁移规则需要审计或动态配置 → 表(甚至放数据库)。
  4. 两者可共存:表做合法性校验,对象做行为分发。

代码或图示

# 表驱动:行=状态,列=事件,值=下一状态
TRANSITIONS = {
    "PENDING": {"PAY": "PAID", "CANCEL": "CANCELED"},
    "PAID":    {"SHIP": "SHIPPED", "CANCEL": "CANCELED"},
    "SHIPPED": {"CONFIRM": "DONE"},
}

def apply(state, event):
    nxt = TRANSITIONS.get(state, {}).get(event)
    if nxt is None:
        raise ValueError(f"illegal transition {state} + {event}")
    return nxt

常见误区

  • 把所有行为都塞进表里:表只能存「下一状态」,不能存行为;行为差异大时表会变成一个大 switch。
  • 状态对象分散迁移规则:每个状态类自己写迁移,难以全局审查,容易出现「状态 A 说能到 C、状态 C 说不能从 A 来」的不一致。

追问

  • 状态表存数据库可行吗?答:可行,用于流程引擎、审批流;但每次事件都要查表,需要缓存与版本控制。
  • 状态对象怎么审查迁移完整性?答:把状态表作为单一事实来源,状态对象的迁移函数先查表再切换,避免不一致。

01.3.2.11-003 状态模式与策略模式的关键区别是什么?

一句话结论

两者结构几乎一样(上下文持有一个可替换的对象),但意图相反:策略模式由外部选择算法并注入,算法之间互不认识;状态模式由状态对象自己根据事件决定下一状态切换,外部不知道内部状态。

概念解释

  • 策略:上下文持有 strategy,外部调用 context.setStrategy(...),strategy 之间平级、可互换。
  • 状态:上下文持有 currentState,外部只发事件,currentState 自己决定 context.state = nextState,外部不应感知状态切换。
  • 行为差异:策略切换是「业务选择」,状态切换是「流程驱动」。

原理流程

  1. 看切换由谁发起:外部代码 → 策略;状态对象自己 → 状态。
  2. 看行为是否随内部状态变化而变化:策略的行为差异来自外部选择,状态的行为差异来自当前流程节点。
  3. 看状态之间是否有合法迁移:策略没有「不能从 X 切到 Y」的约束,状态有。

代码或图示

策略:外部 new PromotionContext().setStrategy(new GoldStrategy())
       ↑ 调用方主动选
状态:context.pay() -> PaidState.handle() -> context.state = new ShippedState()
       ↑ 状态对象自己切,外部不感知

常见误区

  • 把状态切换暴露给外部:context.state = XxxState.INSTANCE 直接赋值,等于破坏状态对象的封装,合法迁移约束失效。
  • 用策略模式做状态机:策略之间不知道迁移合法性,容易出现非法跳转。

追问

  • 两个模式能互相改造吗?答:结构上可以,但语义上会丢失约束;状态机的核心价值是「非法迁移被拒绝」,策略没有这层。
  • Spring StateMachine 是哪种?答:它显式建模状态、事件、迁移,属于状态机引擎,不是策略。

01.3.2.11-004 状态对象为什么通常无状态?共享实例要注意什么?

一句话结论

状态对象本身只承载「迁移规则与行为」,不保存业务数据,因此可以做成单例被多个上下文共享;业务数据(订单号、金额、用户)放在上下文里,事件处理时由状态对象从上下文读取。

概念解释

  • 无状态状态对象:不持有字段,方法只操作传入的上下文。
  • 共享实例:每个状态类只有一个对象,节省内存。
  • 状态对象引用的是「类型身份」,不是「数据快照」。

原理流程

  1. 状态类不声明业务字段。
  2. 上下文持有业务数据与当前状态实例。
  3. 事件方法签名:State handle(Context ctx, Event e),返回下一状态实例。
  4. 状态实例在 JVM/进程内只创建一次(枚举或单例)。

代码或图示

public enum OrderState {
    PENDING {
        public OrderState onPay(Order o) { o.setPaid(true); return PAID; }
    },
    PAID {
        public OrderState onShip(Order o) { o.setShipped(true); return SHIPPED; }
    };
    public abstract OrderState onPay(Order o);
    public OrderState onShip(Order o) { throw new IllegalStateException(); }
}

常见误区

  • 在状态类里加 private Order order;:状态对象被多个上下文共享时,这个字段会被覆盖,典型串数据事故。
  • 每次事件都 new 一个状态对象:浪费内存且失去共享语义;枚举或静态单例即可。

追问

  • 状态对象需要序列化吗?答:通常只持久化「当前状态标识」(枚举名 / 字符串),反序列化时恢复为共享状态实例,不序列化状态对象本身。
  • 多线程下状态对象安全吗?答:无状态、只读,天然线程安全;业务数据的并发安全由上下文自己保证。

01.3.2.11-005 Java 枚举状态机怎么写?

一句话结论

Java 枚举状态机把每个状态做成枚举常量,常量内部覆盖本状态支持的事件方法;枚举天然单例、可序列化、可持久化,适合状态数量有限、迁移规则清晰的业务。

概念解释

  • 枚举常量:每个状态是一个枚举实例。
  • 抽象方法或默认实现:在枚举基类声明 onPay(Order) 等方法,每个常量按需覆盖。
  • 持久化:存枚举名,反序列化自动恢复单例。

原理流程

  1. 枚举基类声明所有事件方法,默认抛 IllegalStateException。
  2. 每个状态常量覆盖自己支持的事件。
  3. 上下文持有 OrderState state 字段。
  4. 事件方法返回下一状态,由上下文赋值。

代码或图示

public enum OrderState {
    PENDING {
        @Override public OrderState onPay(Order o) { o.markPaid(); return PAID; }
        @Override public OrderState onCancel(Order o) { o.markCanceled(); return CANCELED; }
    },
    PAID {
        @Override public OrderState onShip(Order o) { o.markShipped(); return SHIPPED; }
    },
    SHIPPED {
        @Override public OrderState onConfirm(Order o) { o.markDone(); return DONE; }
    },
    CANCELED, DONE;

    public OrderState onPay(Order o) { throw new IllegalStateException("not in " + this); }
    public OrderState onShip(Order o) { throw new IllegalStateException("not in " + this); }
    public OrderState onCancel(Order o) { throw new IllegalStateException("not in " + this); }
    public OrderState onConfirm(Order o) { throw new IllegalStateException("not in " + this); }
}

常见误区

  • 在枚举里写大段业务逻辑:枚举是状态机,不是 Service;复杂逻辑应调用上下文注入的 Service。
  • 用枚举做「带数据的状态」:枚举常量是单例,不能放每单业务数据,业务数据仍在上下文。

追问

  • 枚举状态机怎么可视化?答:把每个常量的覆盖方法整理成迁移表,导出为 Mermaid 图即可。
  • 状态非常多(几十个)时枚举还合适吗?答:太多枚举常量会让文件巨大,应拆分或改用表驱动 + 状态对象混合。

01.3.2.11-006 Go 的 stateFn 写法是什么?

一句话结论

Go 的惯用状态机是 type stateFn func() stateFn:每个状态是一个函数,函数返回「下一个状态函数」;主循环不断调用当前状态函数,直到返回 nil 结束。这是 Go 官方博客介绍的 parser 写法,没有类继承也能表达复杂状态机。

概念解释

  • stateFn:函数类型,签名 func() stateFn。
  • 状态:一个具体的 Go 函数。
  • 迁移:函数返回值决定下一个状态。
  • 上下文:通过闭包或外部结构体在多个状态函数间共享。

原理流程

  1. 定义 type stateFn func() stateFn。
  2. 每个状态写一个函数,处理事件并返回下一个 stateFn。
  3. 主循环:for s := startState; s != nil; s = s() {}。
  4. 需要上下文时,把上下文做成闭包变量或参数。

代码或图示

package main

import "fmt"

type stateFn func(*order) stateFn

type order struct {
    state string
}

func statePending(o *order) stateFn {
    fmt.Println("in pending")
    // 假设事件是 pay
    o.state = "paid"
    return statePaid
}

func statePaid(o *order) stateFn {
    fmt.Println("in paid")
    o.state = "shipped"
    return nil // 终止
}

func main() {
    o := &order{state: "pending"}
    for s := statePending; s != nil; s = s(o) {
        // 空循环:每个状态函数内部推进
    }
    fmt.Println("final:", o.state)
}

常见误区

  • 把主循环写成递归:return statePending(o) 会无限递归爆栈;必须用循环。
  • 在状态函数里直接 panic 表示非法迁移:应返回错误或显式切换到错误状态。

追问

  • stateFn 怎么接收外部事件?答:把事件通道或队列作为参数传入状态函数,函数内 select 事件再决定返回哪个 stateFn。
  • 状态需要持久化怎么办?答:状态函数本身不能序列化,要持久化「状态名」(字符串),恢复时按名字映射到对应函数。

01.3.2.11-007 Python 怎么手写一个状态机?

一句话结论

Python 最常见的手写方式是「字典驱动」:用嵌套字典定义 当前状态 -> 事件 -> (下一状态, 动作),事件到来时查表更新状态并执行动作;需要更复杂行为时用类表示状态。

概念解释

  • 表驱动:迁移字典 + 动作回调。
  • 类驱动:每个状态一个类,类似 Java 状态对象。
  • 标准库:enum + 自定义 Enum 也能写状态机。

原理流程

  1. 定义状态枚举与事件枚举。
  2. 用字典描述合法迁移。
  3. 上下文持有 state 字段,事件方法查表并切换。
  4. 非法迁移抛业务异常。

代码或图示

from enum import Enum

class State(Enum):
    PENDING = "pending"
    PAID = "paid"
    SHIPPED = "shipped"
    CANCELED = "canceled"

TRANSITIONS = {
    (State.PENDING, "pay"):    (State.PAID,    lambda o: o.mark_paid()),
    (State.PENDING, "cancel"): (State.CANCELED, lambda o: o.mark_canceled()),
    (State.PAID,    "ship"):   (State.SHIPPED,  lambda o: o.mark_shipped()),
}

def apply(order, event):
    key = (order.state, event)
    if key not in TRANSITIONS:
        raise ValueError(f"illegal: {order.state} + {event}")
    nxt, action = TRANSITIONS[key]
    action(order)
    order.state = nxt

常见误区

  • 把动作和状态混在字典 key 里:表只存迁移,动作应是回调函数或独立函数,便于测试。
  • 用可变全局字典存迁移:多线程下需加锁或冻结为只读。

追问

  • Python 有状态机库吗?答:transitions、stately 等库封装了状态机,但手写字典版本更易理解,业务简单时不必引库。
  • 状态机里动作失败怎么办?答:动作应在状态切换前执行并回滚,或在切换前校验;不要先切状态再执行动作。

01.3.2.11-008 TypeScript 状态机与 XState 各自的位置?

一句话结论

简单状态机用 TS 联合类型 + switch 或 Record 表驱动即可;状态数量多、需要可视化、需要正交状态与历史状态时引入 XState,把状态机建模成 JSON/对象配置,由 XState 解释执行。

概念解释

  • 手写:type State = 'pending' | 'paid' | 'shipped',事件函数 reduce(state, event)。
  • XState:声明式状态机库,用 createMachine({ initial, states, on }) 建模,支持层次状态、并行状态、守护条件、动作。
  • 边界:业务简单时手写;需要调试、可视化、与后端状态机同步时用 XState。

原理流程

  1. 简单场景:联合类型 + reducer 函数。
  2. 复杂场景:定义 machine 配置,组件用 useMachine hook 驱动。
  3. XState 提供可视化编辑器与状态图导出,便于产品与工程共同审查。

代码或图示

type State = "pending" | "paid" | "shipped" | "done";
type Event = { type: "pay" } | { type: "ship" } | { type: "confirm" };

const TRANSITIONS: Record<State, Partial<Record<Event["type"], State>>> = {
  pending: { pay: "paid", cancel: "canceled" as State },
  paid: { ship: "shipped" },
  shipped: { confirm: "done" },
  done: {},
};

function reduce(state: State, event: Event): State {
  return TRANSITIONS[state]?.[event.type] ?? state;
}
// XState 形态(仅示意,API 以官方文档为准)
// const machine = createMachine({
//   initial: "pending",
//   states: {
//     pending: { on: { pay: "paid", cancel: "canceled" } },
//     paid: { on: { ship: "shipped" } },
//     shipped: { on: { confirm: "done" } },
//   },
// });

常见误区

  • 用 XState 写一个三状态的简单流程:引入库成本高于手写,违反 YAGNI。
  • 在组件里直接 send({type:'pay'}) 而不处理非法迁移:XState 会静默忽略未声明的事件,需要显式 on: { "": "#invalid" } 兜底。

追问

  • XState 与后端状态机怎么对齐?答:状态名与事件名约定一致,前端把事件发给后端,后端返回新状态,前端不自行切换,避免两端不一致。
  • XState 在 React/Vue 里怎么用?答:分别有 @xstate/react、@xstate/vue 适配 hook,具体 API 以官方文档为准。

01.3.2.11-009 Rust 用 enum + match 怎么表达状态机?typestate 是什么?

一句话结论

Rust 用 enum OrderState { Pending(...), Paid(...), Shipped(...) } 把每个状态的数据放在对应变体里,事件方法用 match 处理,非法迁移在编译期就不可能构造;typestate 是更激进的做法——用类型系统把状态编码进类型参数,让非法状态在编译期被拒绝。

概念解释

  • enum + match:运行时状态机,状态与数据绑定在变体上。
  • typestate:把状态做成类型(struct Order<S>),合法方法只在特定状态类型上存在,编译期拒绝非法调用。
  • 区别:enum 模式运行时检查,typestate 编译期检查。

原理流程

  1. 简单状态机:enum 表示状态,方法 fn pay(self) -> Result<OrderState, Error>。
  2. 编译期状态:定义 struct Pending; struct Paid;,struct Order<S>,impl Order<Pending> { fn pay(self) -> Order<Paid> {} }。
  3. 非法迁移在编译期报错,因为方法不存在。

代码或图示

enum Order {
    Pending { id: u64 },
    Paid { id: u64, paid_at: u64 },
    Shipped { id: u64, carrier: String },
}

fn pay(order: Order) -> Result<Order, String> {
    match order {
        Order::Pending { id } => Ok(Order::Paid { id, paid_at: now() }),
        other => Err(format!("cannot pay in {:?}", variant_name(&other))),
    }
}

fn now() -> u64 { 0 }
fn variant_name(_: &Order) -> &'static str { "..." }
// typestate 示意:方法只在对应状态上存在
struct Pending;
struct Paid;
struct Order<S> { id: u64, _state: std::marker::PhantomData<S> }

impl Order<Pending> {
    fn pay(self) -> Order<Paid> { Order { id: self.id, _state: std::marker::PhantomData } }
}

impl Order<Paid> {
    fn ship(self, carrier: String) -> Order<Shipped> { unimplemented!() }
}

常见误区

  • 把所有数据放在 enum 外层:状态专属字段(如 carrier)应放在对应变体里,未发货订单不该有 carrier 字段。
  • typestate 用 PhantomData 却忘记 S: ?Sized 约束:编译报错时检查泛型标记。

追问

  • typestate 的代价是什么?答:状态切换会移动对象(self 消费),代码比运行时状态机更啰嗦;适合协议解析、构建器这类强约束场景。
  • Rust 有状态机库吗?答:stacker、state_machine_future 等库封装异步状态机,具体 API 以官方文档为准。

01.3.2.11-010 命令模式的三角色怎么分工?

一句话结论

命令模式把「请求」封装成对象:调用者(Invoker)持有命令对象并触发执行,命令对象绑定接收者(Receiver)与参数,真正干活的是接收者。三者解耦后,命令可被排队、记录、撤销、持久化。

概念解释

  • 命令对象:实现 execute() 接口,持有接收者引用与参数。
  • 接收者:真正执行业务的对象,方法由命令调用。
  • 调用者:持有命令队列,决定何时执行,不知道接收者细节。
  • Client:负责组装命令、接收者、调用者。

原理流程

  1. 接收者实现业务方法(如 Cart.add(item))。
  2. 具体命令 AddCartCommand 持有 Cart 与 item,execute() 调 cart.add(item)。
  3. 调用者(如按钮、任务队列)持有命令并 execute()。
  4. 新增命令不修改调用者与接收者,只加新命令类。

代码或图示

public interface Command { void execute(); }

public class AddCartCommand implements Command {
    private final Cart cart;
    private final Item item;
    public AddCartCommand(Cart cart, Item item) { this.cart = cart; this.item = item; }
    public void execute() { cart.add(item); }
}

public class Button {
    private final Command cmd;
    public Button(Command cmd) { this.cmd = cmd; }
    public void onClick() { cmd.execute(); }
}

常见误区

  • 命令对象只做透传没有附加价值:不需要排队、撤销、记录时直接调用接收者更简单,不要为了模式而模式。
  • 命令里写大段业务:业务仍属于接收者,命令只做「参数 + 调用」。

追问

  • 命令模式与策略模式结构区别?答:结构几乎相同(都持有一个对象),意图不同:命令是「把动作封装为对象以便排队/记录/撤销」,策略是「整体算法可替换」。
  • 命令对象需要知道调用者吗?答:不需要,命令只认接收者,调用者只认命令接口。

01.3.2.11-011 撤销与重做怎么用 Undo/Redo 栈实现?

一句话结论

Undo/Redo 用两个栈:每次执行新命令时压入 undo 栈,redo 栈清空;撤销时从 undo 栈弹出命令、调 undo()、压入 redo 栈;重做反向。命令的 undo() 必须与 execute() 对称。

概念解释

  • Undo 栈:保存已执行命令。
  • Redo 栈:保存被撤销的命令。
  • 两种实现:反向操作(命令自己知道怎么撤销)vs 备忘录(保存状态快照,回滚时恢复快照)。
  • 组合:新命令到来时清空 redo 栈,符合「撤销后又做新动作,旧重做失效」的直觉。

原理流程

  1. 执行命令:cmd.execute() → undoStack.push(cmd) → redoStack.clear()。
  2. 撤销:cmd = undoStack.pop() → cmd.undo() → redoStack.push(cmd)。
  3. 重做:cmd = redoStack.pop() → cmd.execute() → undoStack.push(cmd)。
  4. 栈深度设上限,避免内存膨胀。

代码或图示

public class Editor {
    private final Deque<Command> undoStack = new ArrayDeque<>();
    private final Deque<Command> redoStack = new ArrayDeque<>();

    public void execute(Command cmd) {
        cmd.execute();
        undoStack.push(cmd);
        redoStack.clear();
    }

    public void undo() {
        if (undoStack.isEmpty()) return;
        Command cmd = undoStack.pop();
        cmd.undo();
        redoStack.push(cmd);
    }
}

常见误区

  • 新命令执行后不清空 redo 栈:用户撤销后做了新动作,旧重做仍能恢复,会覆盖新状态。
  • 命令 undo() 与 execute() 不对称:比如 execute 改了多个字段,undo 只恢复一个,状态不一致。
  • 栈无限增长:长会话内存膨胀,需要按大小或时间淘汰。

追问

  • 反向操作和快照哪个好?答:反向操作省内存但要写对称 undo;快照简单但占内存;复杂对象用「基线快照 + 增量命令」。
  • 跨服务操作怎么撤销?答:本地事务用回滚;跨服务用补偿事务(Saga),每步命令带补偿动作,本质是分布式版 undo。

01.3.2.11-012 宏命令与命令队列解决什么问题?

一句话结论

宏命令把多个命令组合成一个复合命令,execute() 时依次执行、undo() 时逆序撤销;命令队列把命令对象放入队列异步消费,支持延迟、重试、顺序执行与持久化。

概念解释

  • 宏命令:实现与叶子命令相同接口,内部持有命令列表。
  • 命令队列:生产者放命令、消费者按序执行,可持久化、可重试。
  • 区别:宏是「同步组合」,队列是「异步调度」。

原理流程

  1. 宏命令:CompositeCommand implements Command,内部 List<Command>,execute 顺序调用,undo 逆序调用。
  2. 队列:命令对象序列化为消息,投递到 MQ / 本地任务表,worker 拉取执行,失败重试。
  3. 两者可组合:宏命令作为一个整体入队。

代码或图示

public class MacroCommand implements Command {
    private final List<Command> commands;
    public MacroCommand(List<Command> commands) { this.commands = List.copyOf(commands); }
    public void execute() { commands.forEach(Command::execute); }
    public void undo() {
        for (int i = commands.size() - 1; i >= 0; i--) commands.get(i).undo();
    }
}
命令队列:
Client -> [Command1, Command2, Command3] -> Worker -> 执行 -> 失败重试
                                  ↑ 可持久化到 DB / MQ

常见误区

  • 宏命令中途失败没有回滚:部分命令已执行、后续失败,需要补偿或整体事务。
  • 队列里命令没有幂等键:重试时重复执行,造成重复扣款。
  • 宏命令里命令相互有依赖:顺序错误会失败,应在文档中显式约定顺序。

追问

  • 宏命令与数据库事务区别?答:宏是应用层组合,事务是数据库层原子性;两者不互斥,宏命令内部可包一个事务。
  • 命令队列怎么保证顺序?答:按业务键(订单 ID)分区,同一业务键路由到同一 worker,实现顺序消费。

01.3.2.11-013 命令与策略、观察者、CQRS Command 有什么区别?

一句话结论

命令模式的 Command 是「动作对象」,用于排队、撤销、记录;策略模式是「可替换算法」;观察者是「事件通知」;CQRS 里的 Command 是「写操作请求」,是业务建模概念,与 GoF 命令模式不在同一层。

概念解释

  • 命令(GoF):封装动作以便调度,关心执行与撤销。
  • 策略:封装算法以便替换,关心业务规则选择。
  • 观察者:封装事件通知,关心「谁订阅了谁」。
  • CQRS Command:业务语义上的写请求(如 PlaceOrderCommand),由 CommandHandler 处理,强调读写分离与事件溯源。

原理流程

  1. 看封装目的:调度/撤销 → GoF 命令;替换算法 → 策略;通知 → 观察者。
  2. CQRS Command 是业务层概念,它可以用 GoF 命令模式实现,也可以用普通方法调用实现。
  3. 同名不同层:CQRS 的 Command 不要求撤销、不要求排队,只是「写操作的命名约定」。

代码或图示

GoF 命令:  AddCartCommand.execute() / undo()        可排队、可撤销
策略:      DiscountStrategy.apply(price)             可替换
观察者:    OrderCreatedEvent -> Listener.onEvent()   事件通知
CQRS:      PlaceOrderCommand { orderId, items }      业务写请求,Handler 处理

常见误区

  • 把 CQRS 的 Command 等同于 GoF 命令:前者是 DTO/消息,后者是行为对象,概念层级不同。
  • 用命令模式做事件通知:事件是「已发生的事实」,命令是「要做的动作」,方向相反。

追问

  • 事件溯源(Event Sourcing)与命令模式关系?答:ES 里命令产生事件,事件持久化重放;命令模式可作为命令分发的实现方式,但 ES 本身是数据架构。
  • 观察者模式里的事件是命令吗?答:不是,事件是「已发生」的事实,命令是「待执行」的动作;事件订阅者可把事件转成命令。

01.3.2.11-014 命令在框架里的真实形态是什么?任务队列、事务脚本、命令总线?

一句话结论

工程里最常见的命令形态是:本地任务队列(@Async、消息队列消费)、命令总线(Spring ApplicationEventPublisher、MediatR、Laravel Bus)、事务脚本(一个 Service 方法对应一个用例)。它们都把「一次业务操作」封装成可调度单元。

概念解释

  • 任务队列:命令对象 = 消息,worker 拉取执行,支持重试、延迟、幂等。
  • 命令总线:内存中按命令类型路由到 Handler,解耦调用方与处理方。
  • 事务脚本:一个 Service 方法对应一个用例,是命令模式的极简形态(命令 = 方法调用)。

原理流程

  1. 调用方构造命令对象(含参数)。
  2. 命令总线按类型找到对应 Handler。
  3. Handler 执行接收者业务逻辑,可能在事务内。
  4. 需要异步时,命令对象序列化后投递到 MQ。

代码或图示

// MediatR 形态(ASP.NET Core):命令即 IRequest
public record PlaceOrderCommand(Guid OrderId, string Item) : IRequest<Guid>;

public class PlaceOrderHandler : IRequestHandler<PlaceOrderCommand, Guid>
{
    public Task<Guid> Handle(PlaceOrderCommand cmd, CancellationToken ct)
    {
        // 执行业务
        return Task.FromResult(cmd.OrderId);
    }
}
// Go 任务队列形态:命令即函数
type Job func() error

func worker(jobs <-chan Job) {
    for j := range jobs {
        if err := j(); err != nil {
            // 重试或落死信
        }
    }
}
# Python:Celery 任务即命令
# @app.task
# def place_order(order_id, item):
#     ...

常见误区

  • 命令总线过度设计:小项目里直接 orderService.place() 更简单,总线适合 Handler 数量多、需要管道(校验、日志、事务)横切时。
  • 命令对象没有幂等键:MQ 重试会重复执行,必须在命令里带业务唯一键。
  • 命令里塞过多参数:参数应聚合为值对象,避免 Handler 签名膨胀。

追问

  • Spring 里 @Transactional 的方法是命令吗?答:是事务脚本式命令,方法即用例,没有显式命令对象。
  • MediatR 与 Spring Event 的区别?答:MediatR 是一对一(命令 → Handler),Spring Event 是一对多(事件 → 多个监听器),前者是命令,后者是观察者。

跨语言差异对照

语言 状态机惯用形态 命令模式惯用形态
Java 枚举状态机、状态类、Spring StateMachine Command 接口 + 线程池 / JMS 队列
Go stateFn 函数链、chan 驱动 函数闭包 + worker 池
Python 字典驱动、transitions 库 Celery 任务、函数对象
PHP 枚举 + 状态表、Spatie StateMachine Laravel Bus、Queue Job
C#/.NET enum + switch、Stateless 库 MediatR、IRequest + HostedService
TypeScript 联合类型 + reducer、XState 函数式 action + Redux dispatch
Rust enum + match、typestate 闭包 + 任务队列、tokio::spawn

跨语言差异

  • Java 与 C# 是「类/枚举状态机」的原生土壤,状态对象天然单例、可序列化。
  • Go 与 Rust 没有类继承,状态机收敛到函数式(stateFn)或类型级(typestate)。
  • Python 与 PHP 业务简单,状态表 + 枚举是主流,状态类较少使用。
  • TypeScript 在前端状态管理(Redux/Pinia)里 action 即命令,reducer 即状态迁移。
  • 所有语言的命令队列最终都依赖消息中间件或本地任务表,命令对象必须可序列化。
  • Rust 的 typestate 是独有的「编译期状态机」,其他语言只能在运行时拒绝非法迁移。

待整理清单

  • [ ] 补充 Spring StateMachine 与 Sparse State Machine 的实际配置示例
  • [ ] 补充 XState 层次状态与正交状态的实战案例
  • [ ] 补充 MediatR 管道行为(ValidationBehavior、LoggingBehavior)的命令管线
  • [ ] 补充 Saga 模式与补偿命令在跨服务场景中的落地细节