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、迁移规则复杂、新增状态会频繁修改主干代码。
原理流程
- 业务对象(上下文)持有当前状态引用。
- 外部事件到来,上下文调用
current.onEvent(event)。 - 当前状态对象判断本状态是否允许该事件,允许则修改上下文字段并把
current切换到下一状态。 - 不允许则忽略、抛业务异常或记录非法迁移。
代码或图示
订单状态机:
待支付 --支付成功--> 已支付 --发货--> 已发货 --确认--> 已完成
待支付 --取消------> 已取消
已支付 --取消------> 已取消
public interface OrderState {
OrderState pay(OrderContext ctx);
OrderState ship(OrderContext ctx);
}
常见误区
- 状态少也强行拆类:两三个状态、迁移规则简单时,枚举 + switch 更直接,拆类反而把简单流程打散。
- 状态对象里直接持有业务数据:业务数据应放在上下文,状态对象只持有迁移规则,避免多个状态实例复制数据。
追问
- 状态机必须是「有限」的吗?答:实务里几乎都是有限状态机(FSM),状态集合可枚举;无限状态机需要额外建模,超出本模式范围。
- 状态模式和状态表是同一件事吗?答:状态表是迁移的另一种表达(行=状态、列=事件、单元格=下一状态),状态对象是 OO 表达,两者可以互相转换。
01.3.2.11-002 状态转换表和状态对象怎么取舍?
一句话结论
状态转换表用数据结构(Map / 二维表)描述「当前状态 + 事件 → 下一状态」,简单、易审查、可配置;状态对象用类描述每个状态的行为与迁移,复杂行为更易内聚,但类数量膨胀。状态少、规则集中用表;每个状态有大量独立行为用状态对象。
概念解释
- 表驱动:
Map<(State, Event), State>,迁移逻辑集中在一处,业务事件只查表更新。 - 对象驱动:每个状态一个类,行为与迁移内聚在类内,符合开闭原则。
- 混合:表存合法迁移,行为放在状态对象里。
原理流程
- 数状态与事件数量:状态少、迁移简单 → 表。
- 每个状态行为差异大、会随业务演化 → 状态对象。
- 迁移规则需要审计或动态配置 → 表(甚至放数据库)。
- 两者可共存:表做合法性校验,对象做行为分发。
代码或图示
# 表驱动:行=状态,列=事件,值=下一状态
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,外部不应感知状态切换。 - 行为差异:策略切换是「业务选择」,状态切换是「流程驱动」。
原理流程
- 看切换由谁发起:外部代码 → 策略;状态对象自己 → 状态。
- 看行为是否随内部状态变化而变化:策略的行为差异来自外部选择,状态的行为差异来自当前流程节点。
- 看状态之间是否有合法迁移:策略没有「不能从 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 状态对象为什么通常无状态?共享实例要注意什么?
一句话结论
状态对象本身只承载「迁移规则与行为」,不保存业务数据,因此可以做成单例被多个上下文共享;业务数据(订单号、金额、用户)放在上下文里,事件处理时由状态对象从上下文读取。
概念解释
- 无状态状态对象:不持有字段,方法只操作传入的上下文。
- 共享实例:每个状态类只有一个对象,节省内存。
- 状态对象引用的是「类型身份」,不是「数据快照」。
原理流程
- 状态类不声明业务字段。
- 上下文持有业务数据与当前状态实例。
- 事件方法签名:
State handle(Context ctx, Event e),返回下一状态实例。 - 状态实例在 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)等方法,每个常量按需覆盖。 - 持久化:存枚举名,反序列化自动恢复单例。
原理流程
- 枚举基类声明所有事件方法,默认抛
IllegalStateException。 - 每个状态常量覆盖自己支持的事件。
- 上下文持有
OrderState state字段。 - 事件方法返回下一状态,由上下文赋值。
代码或图示
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 函数。
- 迁移:函数返回值决定下一个状态。
- 上下文:通过闭包或外部结构体在多个状态函数间共享。
原理流程
- 定义
type stateFn func() stateFn。 - 每个状态写一个函数,处理事件并返回下一个 stateFn。
- 主循环:
for s := startState; s != nil; s = s() {}。 - 需要上下文时,把上下文做成闭包变量或参数。
代码或图示
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也能写状态机。
原理流程
- 定义状态枚举与事件枚举。
- 用字典描述合法迁移。
- 上下文持有
state字段,事件方法查表并切换。 - 非法迁移抛业务异常。
代码或图示
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。
原理流程
- 简单场景:联合类型 + reducer 函数。
- 复杂场景:定义 machine 配置,组件用
useMachinehook 驱动。 - 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 编译期检查。
原理流程
- 简单状态机:enum 表示状态,方法
fn pay(self) -> Result<OrderState, Error>。 - 编译期状态:定义
struct Pending; struct Paid;,struct Order<S>,impl Order<Pending> { fn pay(self) -> Order<Paid> {} }。 - 非法迁移在编译期报错,因为方法不存在。
代码或图示
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:负责组装命令、接收者、调用者。
原理流程
- 接收者实现业务方法(如
Cart.add(item))。 - 具体命令
AddCartCommand持有Cart与item,execute()调cart.add(item)。 - 调用者(如按钮、任务队列)持有命令并
execute()。 - 新增命令不修改调用者与接收者,只加新命令类。
代码或图示
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 栈,符合「撤销后又做新动作,旧重做失效」的直觉。
原理流程
- 执行命令:
cmd.execute()→undoStack.push(cmd)→redoStack.clear()。 - 撤销:
cmd = undoStack.pop()→cmd.undo()→redoStack.push(cmd)。 - 重做:
cmd = redoStack.pop()→cmd.execute()→undoStack.push(cmd)。 - 栈深度设上限,避免内存膨胀。
代码或图示
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() 时逆序撤销;命令队列把命令对象放入队列异步消费,支持延迟、重试、顺序执行与持久化。
概念解释
- 宏命令:实现与叶子命令相同接口,内部持有命令列表。
- 命令队列:生产者放命令、消费者按序执行,可持久化、可重试。
- 区别:宏是「同步组合」,队列是「异步调度」。
原理流程
- 宏命令:
CompositeCommand implements Command,内部List<Command>,execute 顺序调用,undo 逆序调用。 - 队列:命令对象序列化为消息,投递到 MQ / 本地任务表,worker 拉取执行,失败重试。
- 两者可组合:宏命令作为一个整体入队。
代码或图示
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 处理,强调读写分离与事件溯源。
原理流程
- 看封装目的:调度/撤销 → GoF 命令;替换算法 → 策略;通知 → 观察者。
- CQRS Command 是业务层概念,它可以用 GoF 命令模式实现,也可以用普通方法调用实现。
- 同名不同层: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 方法对应一个用例,是命令模式的极简形态(命令 = 方法调用)。
原理流程
- 调用方构造命令对象(含参数)。
- 命令总线按类型找到对应 Handler。
- Handler 执行接收者业务逻辑,可能在事务内。
- 需要异步时,命令对象序列化后投递到 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 模式与补偿命令在跨服务场景中的落地细节