Java中状态机模式的两种实现方式详解

更新时间：2026年07月30日 08:43:25 作者：霸道流氓气质

状态机（State Machine）是一种数学模型,描述一个对象在其生命周期中所经历的各种状态,以及在什么条件下从一个状态转换到另一个状态,本文介绍了Java中状态机模式的两种实现方式,感兴趣的小伙伴可以了解下

一、什么是状态机

状态机（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状态机内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

java使用EasyExcel实现Sheet的复制与填充
EasyExcel是一个非常有用的工具,它提供了强大的模板填充功能,可以轻松解决各种业务需求,本文主要为大家介绍了如何使用EasyExcel实现模板Sheet复制与填充,需要的可以参考下
2023-10-10
SpringBoot控制器返回值处理的4个技巧分享
在SpringBoot应用开发中,控制器(Controller)的返回值处理是一个基础但极其重要的环节,本文将介绍SpringBoot中四种常用的控制器返回值处理技巧,有需要的可以参考下
2025-05-05
SpringBoot简单实现定时器过程
这篇文章主要介绍了SpringBoot简单实现定时器过程，对于Java后端来说肯定实现定时功能肯定是使用到Spring封装好的定时调度Scheduled
2023-04-04
java连接MySQL数据库的代码
这篇文章主要为大家详细介绍了java连接MySQL数据库的相关代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-10-10
IDEA使用lombok依赖使用log问题及解决
解决IDEA中使用@Slf4j注解报错问题详细步骤包括在pom引入lombok依赖、安装lombok插件、设置IDEA日志功能及启用注解处理等三个关键步骤帮助解决log报错问题
2026-06-06
如何利用Java使用AOP实现数据字典转换
这篇文章主要介绍了如何利用Java使用AOP实现数据字典转换，AOP也是我们常说的面向切面编程，AOP在我们开发过程中应用也比较多，在这里我们就基于AOP来实现一个数据字典转换的案例
2022-06-06
Springboot Mybatis type-aliases-package错误的解决方案
在使用Spring Boot 2.7.0整合MyBatis 2.1.3时,遇到mybatis.type-aliases-package配置后XML别名爆红的问题,通过在model类上添加@Alias注解,为类定义别名,解决了问题
2026-02-02
MyBatis-Plus解决逻辑删除与唯一索引的问题
本文主要介绍了MyBatis-Plus解决逻辑删除与唯一索引的问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2022-08-08
Java使用map实现带过期时间的缓存机制
在 Java 开发领域,缓存机制的构建通常依赖于 Redis 等专业缓存数据库,这类解决方案虽能提供强大的缓存能力,但引入中间件意味着增加系统架构复杂度、部署成本与运维负担,本文将深入探讨一种轻量级替代方案基于 Java 原生Map实现的带过期时间的缓存机制
2025-04-04
Java从入门到精通之旅类和对象全面解析
Java是一门纯面向对象的语言(OOP),在面向对象的世界里,一切皆为对象,面向对象是解决问题的一种思想,主要依靠对象之间的交互完成一件事情,这篇文章主要介绍了Java从入门到精通之旅类和对象全面解析,需要的朋友可以参考下
2025-04-04