Java 状态机设计：替代 if-else 的优雅架构

转载 已于 2025-08-14 17:16:21 修改 · 115 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://mp.weixin.qq.com/s/vJS2pi6F6l0ymuzIVOcdMQ
文章标签：

#架构 #设计模式

于 2025-08-14 17:15:45 首次发布

在后台系统开发中，状态流转无处不在：订单从 待支付 → 已支付 → 已发货，工单从 打开 → 处理中 → 解决。

一开始用一堆 if/else、嵌套判断能跑通，但很快会出现：

  • 代码像洋葱层层嵌套（箭头代码，难以阅读）

  • 状态规则散落在多个分支里，难以维护与测试

  • 边界条件容易遗漏，扩展差（新增状态／事件要改核心逻辑）

所以，状态机（State Machine）诞生了——它是把状态与转移规则显式化、模块化、可测试化的解法。

状态机核心概念 

状态机三要素：

要素

含义

例子（订单系统）

状态（State）

系统所处的稳定阶段

待支付 / 已支付 / 已发货

事件（Event）

能触发状态变化的动作

支付成功 / 取消订单 / 发货

转移（Transition）

从某个状态在某个事件下到另一个状态并执行处理

待支付 + 支付成功 → 已支付（并执行支付逻辑）

状态机的常见类型：

  • 有限状态机（FSM）：最常用、最简单，适合大多数业务场景。

  • 分层状态机（HSM）：支持状态继承，减少重复（复杂场景）。

  • 状态图 / Statecharts：支持并发子状态、历史状态等高级特性（用于复杂流程）。

状态机实战案例

一个清晰且可扩展的状态机实现

// TransitionHandler 是一个函数式接口，可以用 lambda 实现
@FunctionalInterface
public interface TransitionHandler {
    void handle() throws Exception;
}
// 状态与事件用 enum 表示
public enum State {
    PENDING, PAID, SHIPPED, CANCELED
}
public enum Event {
    PAY_SUCCESS, CANCEL, SHIP
}
// 转移定义
public class Transition {
    public final State from;
    public final Event event;
    public final State to;
    public final TransitionHandler handler;
    public Transition(State from, Event event, State to, TransitionHandler handler) {
        this.from = from;
        this.event = event;
        this.to = to;
        this.handler = handler;
    }
}
// 简单状态机实现（遍历转移表）
import java.util.ArrayList;
import java.util.List;
public class StateMachine {
    private State current;
    private final List<Transition> transitions = new ArrayList<>();
    public StateMachine(State initial) {
        this.current = initial;
    }
    public void addTransition(State from, Event event, State to, TransitionHandler handler) {
        transitions.add(new Transition(from, event, to, handler));
    }
    public void trigger(Event event) throws Exception {
        for (Transition t : transitions) {
            if (t.from == current && t.event == event) {
                // 执行处理
                t.handler.handle();
                // 更新状态
                current = t.to;
                return;
            }
        }
        throw new IllegalStateException("非法事件[" + event + "]或当前状态[" + current + "]不支持");
    }
    public State getCurrent() {
        return current;
    }
}

使用示例（main）：

public static void main(String[] args) throws Exception {
    StateMachine sm = new StateMachine(State.PENDING);
    sm.addTransition(State.PENDING, Event.PAY_SUCCESS, State.PAID, () -> {
        System.out.println("执行支付成功处理逻辑...");
    });
    sm.addTransition(State.PENDING, Event.CANCEL, State.CANCELED, () -> {
        System.out.println("执行订单取消逻辑...");
    });
    sm.addTransition(State.PAID, Event.SHIP, State.SHIPPED, () -> {
        System.out.println("执行发货逻辑...");
    });
    System.out.println("当前状态: " + sm.getCurrent());
    sm.trigger(Event.PAY_SUCCESS);
    System.out.println("当前状态: " + sm.getCurrent());
    sm.trigger(Event.SHIP);
    System.out.println("当前状态: " + sm.getCurrent());
}

输出：

当前状态: 待支付
执行支付成功处理逻辑...
当前状态: 已支付
执行发货逻辑...
当前状态: 已发货

优化：表驱动实现（查找 O(1)）

原实现触发时遍历转移表，性能在大量状态/事件时受影响。把转移表做成 map[State]map[Event]*Transition，触发变成两次 map 查找，既直观又高效：

import java.util.HashMap;
import java.util.Map;
public class StateMachineV2 {
    private State current;
    private Map<State, Map<Event, Transition>> transitionMap;
    public StateMachineV2(State initial) {
        this.current = initial;
        this.transitionMap = new HashMap<>();
    }
    public void addTransition(State from, Event event, State to, TransitionHandler handler) {
        transitionMap
            .computeIfAbsent(from, k -> new HashMap<>())
            .put(event, new Transition(from, event, to, handler));
    }
    public void trigger(Event event) throws Exception {
        Map<Event, Transition> events = transitionMap.get(current);
        if (events != null) {
            Transition t = events.get(event);
            if (t != null) {
                t.handler.handle();
                current = t.to;
                return;
            }
        }
        throw new IllegalStateException("非法事件[" + event + "]或当前状态[" + current + "]不支持");
    }
    public State getCurrent() {
        return current;
    }
}

面向对象风格：状态模式

用接口把每个状态封装成一个对象，状态对象实现该状态下能做的操作。好处是逻辑分散到各自状态类，遵循单一职责；坏处是类型和样板代码增多。

public interface OrderState {
    void pay(OrderContext ctx) throws Exception;
    void cancel(OrderContext ctx) throws Exception;
    void ship(OrderContext ctx) throws Exception;
}
public class PendingState implements OrderState {
    @Override
    public void pay(OrderContext ctx) {
        System.out.println("Pending -> 支付处理");
        ctx.setState(new PaidState());
    }
    @Override
    public void cancel(OrderContext ctx) {
        System.out.println("Pending -> 取消订单");
        ctx.setState(new CanceledState());
    }
    @Override
    public void ship(OrderContext ctx) {
        throw new IllegalStateException("当前状态不能发货");
    }
}
public class PaidState implements OrderState {
    @Override
    public void pay(OrderContext ctx) {
        throw new IllegalStateException("已支付，无法重复支付");
    }
    @Override
    public void cancel(OrderContext ctx) {
        System.out.println("Paid -> 已支付取消逻辑");
        ctx.setState(new CanceledState());
    }
    @Override
    public void ship(OrderContext ctx) {
        System.out.println("Paid -> 发货处理");
        ctx.setState(new ShippedState());
    }
}
// 其余状态类略...
public class OrderContext {
    private OrderState state;
    public OrderContext(OrderState state) { this.state = state; }
    public void setState(OrderState state) { this.state = state; }
    public String getStateName() { return state.getClass().getSimpleName(); }
    public void pay() throws Exception { state.pay(this); }
    public void cancel() throws Exception { state.cancel(this); }
    public void ship() throws Exception { state.ship(this); }
}

并发与安全：

在并发场景下，必须保证状态转移是原子且幂等的：

  • 简单做法：在 Trigger 外包一层 mutex.Lock() / Unlock()。

  • 更复杂：使用 DB 乐观锁（version）或分布式锁（Redis、Zookeeper）保证跨进程一致性。

  • 异步场景：用消息队列序列化事件处理，保证顺序性。


public class SafeStateMachineV2 extends StateMachineV2 {
    private final Object lock = new Object();
    public SafeStateMachineV2(State initial) { super(initial); }
    @Override
    public void trigger(Event event) throws Exception {
        synchronized (lock) {
            super.trigger(event);
        }
    }
}

持久化：

数据库里只记 order.status、事件历史（audit trail）与时间戳。代码在恢复时：从 DB 读回当前状态并注入状态机即可重建运行时行为（状态机逻辑不存入 DB）。

// 存储示例（伪代码）
orders(
  id BIGINT PRIMARY KEY,
  status VARCHAR(32),
  event_history JSON,
  version BIGINT,
  updated_at TIMESTAMP
)
// 恢复：
Order order = loadOrderFromDB(id);
StateMachineV2 sm = CreatePreconfiguredStateMachine(order.getStatusEnum());

持久化事务注意：

  • 在触发转移时，应先执行业务逻辑（可能跨系统），再持久化状态与审计（尽量保证幂等）。

  • 使用事务 + 幂等设计（或事务外补偿）保证一致性。

反模式与实践建议

别犯这些坑：

  • 过度复杂：状态超过 ~15 个，考虑拆分多个子状态机。

  • 上帝状态机：一个状态机控制太多业务，职责混乱。

  • 忽略回退：关键流程必须设计补偿／回退逻辑（尤其是跨系统流程）。

  • 缺乏监控：必须记录状态转移日志与失败告警。

监控示例（埋点）：

在 trigger 前后记录日志、耗时、失败信息，监控异常率、非法事件请求。

public void triggerWithMonitoring(Event event) throws Exception {
    long start = System.currentTimeMillis();
    State old = getCurrent();
    try {
        trigger(event);
    } finally {
        System.out.printf("state transition: %s -> %s on %s, took %d ms%n",
            old, getCurrent(), event, System.currentTimeMillis() - start);
    }
}

总结

通过本文，你应该能做到：

  • 理解状态 / 事件 / 转移三要素

  • 会写一个简单可扩展的 Java 状态机

  • 知道如何做性能优化（表驱动）与并发保护

  • 理解持久化原则：只存状态，记录历史

  • 避免常见反模式，做好监控与可恢复设计

状态机不仅是代码结构，更是工程思维

AlbenXie
关注
java实现有限状态机(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-26 1057
java实现有限状态机(附完整源码)
开放平台架构设计原理与实战：如何设计开放API
AI天才研究院
11-01 839
开放平台（Open Platform）是指第三方合作伙伴提供服务的互联网应用或网络服务平台。作为一个平台，它与其他的基础设施和应用程序服务进行集成，并向用户提供基于开放协议的接口和服务，这些协议允许第三方访问、使用或者分享相关数据和资源。开放平台提供了一种“开放-包容-共赢”的服务模式，让更多的合作者参与到该平台中来，通过对平台的开放，可以释放更多的创新价值，并且也可以提升平台的整体竞争力。在互联网的蓬勃发展下，越来越多的企业希望拥有自己的平台，这就需要平台架构师对其中的设计和运营管理有更好的把握和理解。
JAVA 状态机
zxg444098850的专栏
04-27 682
场景：处理退款流程废话不多说直接上代码：定义状态 private static final Map<String, String[]> STATE_MACHINE_MAP = new ConcurrentHashMap<>(); public static final String STATE_INIT = "INIT";
活用“状态模式”替代难以维护的 if-else 逻辑
移动端开发干货分享
06-04 1573
状态模式是一种行为型设计模式，允许对象根据内部状态改变行为，避免繁琐的条件判断。以手机通知模式为例，不同状态（正常、振动、静音）对应不同的来电处理方式。该模式通过将状态逻辑封装到独立类中（如NormalState、VibrateState），使上下文对象（如Phone类）委托行为给当前状态对象，实现状态切换和多态行为。相比if-else语句，状态模式更适用于复杂场景，符合开闭原则，但可能增加类数量。适用于行为依赖状态且状态可能扩展的系统，不推荐简单状态场景使用。
java状态机的一种优雅写法
haohulala的博客
03-27 5370
再说说execute()，这个方法接收ActionEnum作为参数，然后会遍历列表，寻找一条当前状态经过相应动作变化得到的下一个对象的这么一个状态信息，如果找到了就执行event中的handle()方法，并且将当前状态进行转移，最后将StateTransaction返回，如果没找到就返回null。我们可以用非常多的方法实现状态机，比如用茫茫多的if-else来进行条件判断，但是这种原始的方法并不够优雅，这篇文章就来介绍一个状态机优雅的实现方法。上面准备工作都做完后，我们需要一个状态机类，来进行状态转移。
Java架构-状态机如何实现
weixin_54542328的博客
10-28 1923
先来解释什么是“状态”（ State ）。现实事物是有不同状态的，例如一个自动门，就有 open 和 closed 两种状态。我们通常所说的状态机是有限状态机，也就是被描述的事物的状态的数量是有限个，例如自动门的状态就是两个 open 和 closed。状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型。说白了，一般就是指一张状态转换图。例如，根据自动门的运行规则，我们可以抽象出下面这么一个图。
Java架构师方案——状态机（附完整源码）
jack_wang001的专栏
05-24 2081
1. 简单介绍状态机 2. 状态机的本质 3. 状态机应用场景 简单介绍状态机 状态机由状态寄存器和组合逻辑电路构成，能够根据控制信号按照预先设定的状态进行状态转移，是协调相关信号动作、完成特定操作的控制中心。以上是百度百科对状态机的解释。 在百科的解释中，我们可以提炼出状态机的几个要素：存储状态，逻辑电路，预先设定的状态转移路径，外部来的信号，内置的特定操作等。由这些关键要素我们可以推断出以下几点： 状态数据有预先设定的多种值 逻辑电路是完成内置特定操作的基础“代码“(基础设施)，由工程司开发
20.状态模式
weixin_30835923的博客
08-11 272
状态模式 一、状态模式 1.状态模式 1）状态模式（State Pattern）：它主要用来解决对象在多种状态转换时，需要对外输出不同的行为的问题。状态和行为是一一对应的，状态之间可以相互转换 2）当一个对象的内在状态改变时，允许改变其行为，这个对象看起来像是改变了其类 2.原理类图 1）Context 类为环境角色，用于维护State实例，这个实例定义当前状态 2）State是抽象状...
状态机设计模式全解：对比传统if-else性能提升70%的秘密
状态机设计模式是一种将对象的行为根据其内部状态动态改变的软件设计范式。它通过封装状态相关的逻辑，使系统在面对复杂流转时仍保持高内聚、低耦合。相较于传统的条件分支控制，状态机将“做什么”与“当前所处状态...
【架构设计】《Java 架构魔法：理念与实践铸就卓越系统，架构设计需要遵循的理念及最佳实践》
Dylaniou的博客
10-28 1415
Java 架构设计的理念和最佳实践就像是一把把神奇的钥匙，能打开通往卓越系统的大门。希望本文能为你在 Java 架构设计的道路上提供有力的支持。快来评论区分享你的经验和见解吧，让我们一起把 Java 架构设计变得更加精彩！😉。
Java有状态服务架构深度解析：设计、实践与演进
最新发布
weixin_42593797的博客
08-14 718
摘要 本文深入探讨了分布式系统中有状态服务的架构设计与实现。首先解析了有状态服务的核心特征，包括状态依赖性、实例异构性和数据持久性需求，并与无状态服务进行了架构对比。随后通过Java代码示例展示了单机版有状态服务（聊天服务）的实现方式，以及其存在的扩展性限制。文章进一步提出了分布式有状态服务的四大核心组件方案：状态分片、复制、迁移和一致性协调，并给出基于一致性哈希的分片策略实现。最后介绍了如何结合Spring框架构建企业级有状态服务，为复杂业务场景提供可靠的技术支撑。
前端实时数据更新：使用 Server-Sent Events 的5个实用技巧
小白菜的博客
06-11 1323
本文旨在全面介绍Server-Sent Events技术，重点讲解如何在前端应用中有效利用SSE实现实时数据更新。我们将覆盖从基础实现到高级优化的完整知识体系。文章首先介绍SSE的基本概念，然后详细讲解5个实用技巧，包括连接管理、错误处理、性能优化等方面，最后提供实际应用案例和未来发展趋势。: 一种允许服务器向客户端推送实时更新的Web技术: 浏览器提供的用于接收SSE的JavaScript接口长连接: 保持持久化的网络连接以实现实时通信SSE是一种简单高效的服务器推送技术。
Java状态机
m0_65013257的博客
02-18 1880
我们可以定义一个状态机，并声明两个变量，一个用来记录状态变化的记录，一个用来记录要经过下一个状态需要的源状态与事件。在生成一个状态机的过程，我们将记录他需要变化的所有的状态，事件以及转换。过渡类的内容为@Data/*** 起始状态*//*** 动作*//*** 目标状态*/
Java中状态机
iaoyou1的博客
08-27 5265
状态机（State Machine）是一种数学模型，用于描述对象或系统在不同状态之间的转移和行为。它由一组状态、转移条件和动作组成，可以根据输入条件从一个状态转移到另一个状态，并执行相应的动作。离散性：状态机是离散的，它的状态和转移是离散的，不涉及连续变化。易于理解和建模：状态机可以直观地描述对象或系统的行为，使得人们能够更好地理解和建模复杂的逻辑。可扩展性：状态机可以轻松地添加新的状态和转移，以适应需求的变化。
Java 状态机详解 - 三种状态机实现方式优雅消灭 if-else 嵌套
Micro麦可乐的博客
08-13 5368
详细介绍了使用状态模式消除if-else, 通过经典状态模式、枚举状态机、Spring StateMachine 三种方式 ，从纯手写模式 → 枚举模式 → 框架模式的完整对比，进行了相关代码演示。当小伙伴们发现自己在编写大量条件语句来处理对象状态时，考虑使用状态模式重构您的代码。
状态机设计模式 Java
weixin_41800632的博客
08-11 302
我整理的一些关于【设计模式】的项目学习资料（附讲解～～）和大家一起分享、学习一下：https://d.51cto.com/bLN8S1Java中的状态机设计模式 状态机设计模式是一种行为设计模式，它通过将对象的状态与其行为分离，使得对象在不同状态下可以表现出不同的行为。该模式在处理复杂的状态变化时显得尤为重要，例如游戏开...
java状态机设计模式_状态机设计模式
weixin_28842367的博客
02-16 1669
初识我第一次知道状态机，是在大学学习《数字电子技术基础》的时候。一块控制芯片有若干输入数据总线Data_in，一个CLK时钟震荡输入，还有一定数量的以高低电平组合来控制状态的输入。不同的状态，芯片会对输入的数据进行不同的处理。再之后是读研时跟着导师做课题，用Verilog HDL写FPGA程序，仿真一些数字信号的处理算法，其中也大量使用了状态机编程。FPGA还记得有一次和导师沟通科研时，他提及说状...
IF ELSE 替代方案，让代码更加优雅
曾令胜的博客
04-11 1073
1、枚举 2、工厂模式 3、策略模式。来替代if else,使代码更加优雅
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值