从订单到工单：手把手教你用状态机设计可扩展的业务系统
状态机是业务系统设计的核心模式之一，但很多开发者只停留在理论层面，面对实际业务需求时往往无从下手。本文将带你从零开始，用代码实现一个可扩展的状态机系统，涵盖状态模式与状态表两种主流实现方式，并讨论如何优雅地处理权限校验和状态变更日志。
1. 状态机基础与业务建模
在开始编码之前，我们需要明确状态机在业务系统中的核心价值。一个好的状态机设计应该能够：
- 清晰地定义业务对象的所有可能状态
- 规范状态之间的转换规则
- 明确不同状态下的操作权限
- 记录完整的状态变更历史
以课程报名系统为例，我们可以先定义基本的状态流转：
待报名 → 已报名 → 已支付 → 已开课 → 已完成 ↘ 已取消 ↗1.1 状态机核心元素
每个状态机都包含三个基本元素：
- 状态(State): 业务对象所处的当前情况
- 事件(Event): 触发状态变化的操作
- 转换(Transition): 状态之间的变化规则
# 状态枚举示例 class CourseRegistrationState(Enum): PENDING = "待报名" REGISTERED = "已报名" PAID = "已支付" STARTED = "已开课" COMPLETED = "已完成" CANCELLED = "已取消"1.2 业务规则定义
状态流转需要明确的业务规则约束。我们可以用表格形式定义：
| 当前状态 | 允许操作 | 目标状态 | 权限要求 |
|---|---|---|---|
| 待报名 | 提交报名 | 已报名 | 学员 |
| 已报名 | 支付 | 已支付 | 学员 |
| 已报名 | 取消 | 已取消 | 学员 |
| 已支付 | 开课 | 已开课 | 系统 |
| 已开课 | 完成 | 已完成 | 系统 |
注意：终态(如已完成、已取消)通常不允许再转换到其他状态
2. 状态模式实现
状态模式是面向对象设计中实现状态机的经典方式，通过将每个状态封装为独立的类来实现。
2.1 基础架构设计
// 状态接口定义 public interface RegistrationState { void handleSubmit(RegistrationContext context); void handlePay(RegistrationContext context); void handleCancel(RegistrationContext context); void handleStart(RegistrationContext context); void handleComplete(RegistrationContext context); } // 具体状态实现示例 public class PendingState implements RegistrationState { @Override public void handleSubmit(RegistrationContext context) { if (context.getUser().hasPermission("submit")) { context.setState(new RegisteredState()); logTransition(context, "已报名"); } } // 其他方法抛出UnsupportedOperationException }2.2 上下文管理
上下文对象维护当前状态并处理状态转换：
class RegistrationContext: def __init__(self): self._state = PendingState() self._history = [] def change_state(self, new_state): # 验证状态转换合法性 if self._state.can_transition_to(new_state): self._history.append({ 'timestamp': datetime.now(), 'from': self._state, 'to': new_state, 'operator': current_user }) self._state = new_state else: raise InvalidStateTransitionError()状态模式的优势：
- 符合开闭原则，新增状态不影响现有代码
- 状态行为封装在各自类中，职责清晰
- 转换逻辑与业务逻辑解耦
适用场景：
- 状态转换逻辑复杂
- 不同状态有显著不同的行为
- 需要高度可扩展的设计
3. 状态表实现
对于更简单的业务场景，状态表模式可能是更轻量级的解决方案。
3.1 状态表定义
// 状态转换规则定义 const stateTransitions = { 'pending': { 'submit': { target: 'registered', guard: (user) => user.isStudent() } }, 'registered': { 'pay': { target: 'paid', guard: (user) => user.isStudent() }, 'cancel': { target: 'cancelled', guard: (user) => user.isStudent() } } // 其他状态... }; // 状态机执行函数 function transition(currentState, event, user) { const transitions = stateTransitions[currentState]; if (!transitions || !transitions[event]) { throw new Error('Invalid transition'); } const { target, guard } = transitions[event]; if (!guard(user)) { throw new Error('Permission denied'); } return target; }3.2 状态表存储方案
对于更复杂的系统，可以考虑将状态表存储在数据库中：
CREATE TABLE state_transitions ( id INT PRIMARY KEY, current_state VARCHAR(50) NOT NULL, event VARCHAR(50) NOT NULL, target_state VARCHAR(50) NOT NULL, required_role VARCHAR(50), UNIQUE (current_state, event) ); -- 示例数据 INSERT INTO state_transitions VALUES (1, 'pending', 'submit', 'registered', 'student'), (2, 'registered', 'pay', 'paid', 'student'), (3, 'registered', 'cancel', 'cancelled', 'student');状态表模式的优势：
- 配置化，修改规则无需修改代码
- 易于理解和维护
- 可以实现动态加载状态规则
适用场景：
- 状态转换规则相对简单
- 需要频繁修改状态流转规则
- 希望将业务规则与代码分离
4. 高级功能实现
4.1 权限控制集成
无论采用哪种实现方式，权限控制都是关键环节。我们可以通过策略模式实现灵活的权限检查：
public interface TransitionGuard { boolean check(User user, BusinessObject obj); } public class StudentOnlyGuard implements TransitionGuard { @Override public boolean check(User user, BusinessObject obj) { return user.hasRole("student") && obj.belongsTo(user); } } // 使用示例 public class StateTransition { private TransitionGuard guard; public boolean isAllowed(User user, BusinessObject obj) { return guard.check(user, obj); } }4.2 状态变更日志
完整的状态变更历史对业务追溯至关重要：
class StateChangeLog(models.Model): object_id = models.CharField(max_length=100) from_state = models.CharField(max_length=50) to_state = models.CharField(max_length=50) operator = models.ForeignKey(User) timestamp = models.DateTimeField(auto_now_add=True) ip_address = models.GenericIPAddressField() remark = models.TextField(null=True) @classmethod def log_transition(cls, obj, from_state, to_state, request): cls.objects.create( object_id=obj.id, from_state=from_state, to_state=to_state, operator=request.user, ip_address=request.META['REMOTE_ADDR'] )4.3 分布式状态机
在微服务架构中，状态机可能需要跨服务协作：
// 使用Saga模式管理分布式状态 class RegistrationSaga { constructor() { this.steps = [ { name: 'validate', action: this.validate, compensation: this.cancelValidation }, { name: 'reserve_seat', action: this.reserveSeat, compensation: this.cancelReservation }, { name: 'process_payment', action: this.processPayment, compensation: this.refundPayment } ]; } async execute() { for (const step of this.steps) { try { await step.action(); } catch (error) { await this.compensate(step.name); break; } } } compensate(failedStep) { // 执行补偿操作 } }5. 实战：课程报名系统实现
让我们综合运用上述技术实现一个完整的课程报名系统。
5.1 系统架构设计
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ API Gateway │───▶│ Registration │───▶│ Payment │ └─────────────────┘ │ Service │ └─────────────────┘ └─────────────────┘ ▲ │ │ ▼ ┌─────────────────┐ │ Notification │ │ Service │ └─────────────────┘5.2 核心代码实现
// 状态机核心 class CourseRegistrationStateMachine { private currentState: RegistrationState; private transitions: Map<RegistrationState, Map<string, Transition>>; constructor(initialState: RegistrationState) { this.currentState = initialState; this.initializeTransitions(); } private initializeTransitions() { this.transitions = new Map(); // 待报名状态转换 const pendingTransitions = new Map<string, Transition>(); pendingTransitions.set('submit', { targetState: 'registered', guard: (user) => user.isStudent() }); this.transitions.set('pending', pendingTransitions); // 其他状态转换... } public transition(event: string, user: User): boolean { const stateTransitions = this.transitions.get(this.currentState); if (!stateTransitions || !stateTransitions.get(event)) { return false; } const transition = stateTransitions.get(event)!; if (!transition.guard(user)) { throw new Error('Permission denied'); } this.currentState = transition.targetState; return true; } }5.3 测试策略
状态机的测试应该覆盖以下场景：
def test_registration_flow(): # 正常流程测试 machine = RegistrationStateMachine('pending') machine.transition('submit', student_user) assert machine.current_state == 'registered' machine.transition('pay', student_user) assert machine.current_state == 'paid' # 异常流程测试 with pytest.raises(PermissionError): machine.transition('cancel', admin_user) # 非法转换测试 with pytest.raises(InvalidTransitionError): machine.transition('submit', student_user)5.4 性能优化
对于高并发场景，可以考虑以下优化：
- 状态机池：预初始化状态机实例，减少对象创建开销
- 缓存转换规则：将状态转换规则缓存在内存中
- 异步日志：使用消息队列异步处理状态变更日志
// 状态机池示例 public class StateMachinePool { private Queue<StateMachine> pool = new ConcurrentLinkedQueue<>(); public StateMachine borrowMachine() { StateMachine machine = pool.poll(); return machine != null ? machine : new StateMachine(); } public void returnMachine(StateMachine machine) { machine.reset(); pool.offer(machine); } }在实际项目中，状态机的选择应该基于业务复杂度和团队熟悉程度。对于长期维护的核心业务系统，状态模式提供了更好的扩展性；而对于需要频繁调整规则的业务场景，状态表模式可能更加适合。
