我要评论一、什么是状态机
状态机（state machine）是一种数学模型，描述一个对象在其生命周期中所经历的各种状态，以及在什么条件下从一个状态转换到另一个状态。
核心三要素：
- 状态（state）：对象当前所处的情形
- 事件（event）：触发状态变化的动作或条件
- 转换（transition）：从一个状态到另一个状态的过程
用一句话概括：在某个状态下，发生了某个事件，对象转换到了另一个状态。
二、状态机的两种实现方式
1. 显式状态机
通过独立的状态机框架或代码结构来管理状态转换，状态流转规则集中定义、显式声明。
特点：
- 状态和转换规则集中配置
- 有明确的状态转换表或图
- 非法转换会被拦截
- 通常有框架支持（如 spring statemachine）
2. 隐式状态机
没有独立的状态机组件，状态值存在数据库字段中，状态的流转逻辑分散在各个业务方法的 if/else 或 switch 中。
特点：
- 状态就是一个普通字段
- 转换逻辑散落在各处业务代码中
- 没有统一的规则校验
- 实现简单但维护成本随业务增长而上升
三、隐式状态机的典型实现方式
这是大多数业务系统中最常见的做法。用一个订单状态的例子来说明：
数据库层面
create table orders (
id int primary key,
status int not null default 0 comment '0=待支付, 1=已支付, 2=已发货, 3=已完成, 4=已取消'
);枚举定义
public enum orderstatus {
unpaid(0, "待支付"),
paid(1, "已支付"),
shipped(2, "已发货"),
completed(3, "已完成"),
cancelled(4, "已取消");
private integer code;
private string desc;
}
业务代码中的状态流转
public void payorder(integer orderid) {
order order = orderrepository.findbyid(orderid);
// 隐式校验：只有待支付才能支付
if (!orderstatus.unpaid.getcode().equals(order.getstatus())) {
throw new businessexception("当前状态不允许支付");
}
order.setstatus(orderstatus.paid.getcode());
orderrepository.save(order);
}
public void shiporder(integer orderid) {
order order = orderrepository.findbyid(orderid);
// 隐式校验：只有已支付才能发货
if (!orderstatus.paid.getcode().equals(order.getstatus())) {
throw new businessexception("当前状态不允许发货");
}
order.setstatus(orderstatus.shipped.getcode());
orderrepository.save(order);
}
public void cancelorder(integer orderid) {
order order = orderrepository.findbyid(orderid);
// 隐式校验：已发货和已完成不能取消
if (orderstatus.shipped.getcode().equals(order.getstatus())
|| orderstatus.completed.getcode().equals(order.getstatus())) {
throw new businessexception("当前状态不允许取消");
}
order.setstatus(orderstatus.cancelled.getcode());
orderrepository.save(order);
}
状态转换图：
unpaid(0) ──[支付]──→ paid(1) ──[发货]──→ shipped(2) ──[确认收货]──→ completed(3)
│ │
└──[取消]──→ cancelled(4) ←──[取消]──┘
这就是隐式状态机——没有一个集中的地方定义"什么状态可以转到什么状态"，全靠每个业务方法里的 if 判断来保证。
四、显式状态机的实现方式
方式一：状态转换表
把所有合法的转换关系集中定义：
public class orderstatemachine {
// 转换规则表：map<当前状态, map<事件, 目标状态>>
private static final map<integer, map<string, integer>> transitions = new hashmap<>();
static {
// 待支付状态下的合法转换
map<string, integer> unpaidtransitions = new hashmap<>();
unpaidtransitions.put("pay", 1); // 支付 → 已支付
unpaidtransitions.put("cancel", 4); // 取消 → 已取消
transitions.put(0, unpaidtransitions);
// 已支付状态下的合法转换
map<string, integer> paidtransitions = new hashmap<>();
paidtransitions.put("ship", 2); // 发货 → 已发货
paidtransitions.put("cancel", 4); // 取消 → 已取消
transitions.put(1, paidtransitions);
// 已发货状态下的合法转换
map<string, integer> shippedtransitions = new hashmap<>();
shippedtransitions.put("confirm", 3); // 确认 → 已完成
transitions.put(2, shippedtransitions);
}
/**
* 执行状态转换.
*/
public static integer transition(integer currentstate, string event) {
map<string, integer> allowed = transitions.get(currentstate);
if (allowed == null || !allowed.containskey(event)) {
throw new illegalstateexception(
"非法状态转换: 状态=" + currentstate + ", 事件=" + event);
}
return allowed.get(event);
}
}
使用：
public void payorder(integer orderid) {
order order = orderrepository.findbyid(orderid);
// 由状态机统一校验和转换
integer newstatus = orderstatemachine.transition(order.getstatus(), "pay");
order.setstatus(newstatus);
orderrepository.save(order);
}
方式二：枚举 + 方法
public enum orderstatus {
unpaid(0) {
@override
public orderstatus onpay() { return paid; }
@override
public orderstatus oncancel() { return cancelled; }
},
paid(1) {
@override
public orderstatus onship() { return shipped; }
@override
public orderstatus oncancel() { return cancelled; }
},
shipped(2) {
@override
public orderstatus onconfirm() { return completed; }
},
completed(3),
cancelled(4);
private integer code;
// 默认实现：抛异常表示不允许该操作
public orderstatus onpay() { throw new illegalstateexception("当前状态不允许支付"); }
public orderstatus onship() { throw new illegalstateexception("当前状态不允许发货"); }
public orderstatus onconfirm() { throw new illegalstateexception("当前状态不允许确认"); }
public orderstatus oncancel() { throw new illegalstateexception("当前状态不允许取消"); }
}
五、两种方式的对比
| 维度 | 隐式状态机 | 显式状态机 |
|---|---|---|
| 实现成本 | 低，直接写 if/else | 中等，需要定义转换规则 |
| 可读性 | 差，状态规则分散在各方法中 | 好，规则集中一目了然 |
| 维护成本 | 状态少时低，状态多时急剧上升 | 稳定，新增状态只需加规则 |
| 安全性 | 容易遗漏校验导致非法转换 | 统一拦截非法转换 |
| 适用场景 | 状态少（3-5个）且变化少 | 状态多或流转规则复杂 |
六、状态机中的常见概念
守卫条件（guard）
转换发生前的额外校验，不满足则转换不执行：
// 事件是"发货"，但还需要守卫条件：库存充足
public integer transition(integer currentstate, string event, order order) {
if ("ship".equals(event) && order.getstock() <= 0) {
throw new businessexception("库存不足，无法发货");
}
return transitions.get(currentstate).get(event);
}
转换动作（action）
状态转换时附带执行的业务操作：
// 转换到"已取消"时，自动执行退款
public void cancelorder(order order) {
integer newstatus = orderstatemachine.transition(order.getstatus(), "cancel");
order.setstatus(newstatus);
// 转换动作
refundservice.refund(order.getpaymentid());
notificationservice.notifyuser(order.getuserid(), "订单已取消");
}
入口动作 / 出口动作（entry/exit action）
进入某个状态时固定执行的操作，与触发事件无关：
// 无论从哪里进入"已取消"状态，都发通知
private void onentercancelled(order order) {
notificationservice.notifyuser(order.getuserid(), "订单已取消");
inventoryservice.releasestock(order.getitems());
}
状态回退（rollback）
从某个状态回退到之前的状态，通常需要撤销该状态对应的动作：
// 从已发货回退到已支付（例如物流拦截成功）
public void rollbackshipment(order order) {
if (!orderstatus.shipped.getcode().equals(order.getstatus())) {
throw new businessexception("只有已发货状态才能回退");
}
order.setstatus(orderstatus.paid.getcode());
// 撤销动作：取消物流单、恢复库存
logisticsservice.cancelshipment(order.getlogisticsno());
inventoryservice.restorestock(order.getitems());
}
七、涉及多字段联动的复合状态
实际业务中一个对象可能有多个状态维度，形成复合状态：
// 两个独立的状态维度 private integer signstatus; // 签章状态 private integer syncycstatus; // 同步状态 // 复合状态：只有签章完成且已同步才算"流程结束" // 回退时两个维度可能都需要回退
这种场景下需要注意：
- 两个状态之间是否有依赖关系（同步必须在签章完成之后）
- 回退时是否需要联动回退（签章回退了，同步状态是否也要回退）
- 是否有外部系统已经接收了数据（不可逆操作的处理）
八、总结
状态机本质上解决的是对象生命周期管理的问题。核心关注点：
- 有哪些状态 → 枚举定义清楚
- 什么事件触发什么转换 → 转换规则集中管理
- 转换时要做什么 → 动作与转换绑定
- 非法转换怎么办 → 统一校验拦截
- 需要回退怎么办 → 逆向转换 + 补偿动作
到此这篇关于java中状态机模式的两种实现方式详解的文章就介绍到这了,更多相关java状态机内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论