StateMachine 的简单使用

最新推荐文章于 2025-10-19 02:58:09 发布
原创 最新推荐文章于 2025-10-19 02:58:09 发布 · 6.1k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#源码 #状态机

本文介绍如何使用Android平台中的StateMachine框架实现简单的状态机应用。通过一个具体的例子，详细展示了StateMachine的使用流程，包括状态机的构建、状态的定义及消息的处理等核心内容。

StateMachine 的简单使用

步骤

  1. 源码的frameworks/base/core/java/com/android/internal/util里面把StateMachine.java 、State.java 、IState.java复制到project目录中
  2. 自定义StateMachine类继承StateMachine
    • 自定义状态State继承State：重写enter、processMsg、exit
    • 设置更新状态常量,用于状态更新
    • addState加入父状态、子状态，setInitialState初始化状态
    • start启动状态机stateMachine
  3. 使用状态机，发送持有更新状态常量的Msg

Demo

public class PersonStateMachine extends StateMachine {

    //设置状态改变标志常量
    public static final int MSG_WAKEUP = 1;
    public static final int MSG_TIRED = 2;
    public static final int MSG_HUNGRY = 3;
    private static final int MSG_HALTING = 4;

    //创建状态
    private State mBoringState = new BoringState();
    private State mWorkState = new WorkState();
    private State mEatState = new EatState();
    private State mSleepState = new SleepState();


    PersonStateMachine(String name) {
        super(name);
        //加入状态，初始化状态
        addState(mBoringState, null);
        addState(mSleepState, mBoringState);
        addState(mWorkState, mBoringState);
        addState(mEatState, mBoringState);

        setInitialState(mSleepState); // sleep状态为初始状态
        start(); // 状态机进入初始状态等候外界的命令

    }

    /**
     * @return 创建启动person 状态机
     */
    public static PersonStateMachine makePerson() {
        PersonStateMachine person = new PersonStateMachine("Person");
        person.start();
        return person;
    }


    //定义状态:无聊,睡觉，工作，吃饭

    class BoringState extends State {

        @Override
        public boolean processMessage(Message msg) {
            Log.d("BoringState", "boring.....");
            return true;
        }
    }

    class SleepState extends State {
        @Override
        public void enter() {
            Log.d("SleepState", "enter Sleep");
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case MSG_WAKEUP:
                    //睡觉醒了去工作，工作的时候收到饿了的讯号
                    sendMessage(obtainMessage(MSG_HUNGRY));
                    deferMessage(msg);
                    transitionTo(mWorkState);
                    break;
                case MSG_HALTING:
                    transitionToHaltingState();
                    break;
                default:
                    return false;
            }
            return true;
        }

        @Override
        public void exit() {
            Log.d("SleepState", "exit Sleep");
        }
    }

    @Override
    protected void onHalting() {
        Log.d("PersonStateMachine", "halting");
        synchronized (this) {
            this.notifyAll();
        }
    }

    class WorkState extends State {
        @Override
        public void enter() {
            Log.d("WorkState", "enter Work");
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case MSG_HUNGRY:
                    //工作饿了去吃饭，吃饭的时候收到累了的讯号
                    sendMessage(obtainMessage(MSG_TIRED));
                    deferMessage(msg);
                    transitionTo(mEatState);
                    break;
                default:
                    return false;
            }
            return true;
        }

        @Override
        public void exit() {
            Log.d("WorkState", "exit Work");
        }
    }

    class EatState extends State {
        @Override
        public void enter() {
            Log.d("EatState", "enter Eat");
        }

        @Override
        public boolean processMessage(Message msg) {
            switch (msg.what) {
                case MSG_TIRED:
                    //吃饭吃累了去睡觉，睡觉的时候收到结束的讯号
                    sendMessage(obtainMessage(MSG_HALTING));
                    deferMessage(msg);
                    transitionTo(mSleepState);
                    break;
                default:
                    return false;
            }
            return true;
        }

        @Override
        public void exit() {
            Log.d("EatState", "exit Eat");
        }
    }

}

输出结果

  • 08-31 10:44:04.559 10555-10638/com.example.justi.googlestatemachinedemo D/SleepState: enter Sleep
  • 08-31 10:44:04.559 10555-10638/com.example.justi.googlestatemachinedemo D/BoringState: boring…..
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/SleepState: exit Sleep
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/WorkState: enter Work
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/BoringState: boring…..
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/WorkState: exit Work
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/EatState: enter Eat
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/BoringState: boring…..
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/EatState: exit Eat
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/SleepState: enter Sleep
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/BoringState: boring…..
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/SleepState: exit Sleep
  • 08-31 10:44:04.569 10555-10638/com.example.justi.googlestatemachinedemo D/PersonStateMachine: halting

Demo分析

  1. addState为每个State创建相应的StateInfo对象，通过该对象来建立各个状态之间的关系，并且一个State-StateInfo键值对的方式保存到mStateInfo Hash表中。
    • StateInfo就是包装State组成一个Node，建立State的父子关系；
    • mStateInfo =new HashMap

相关原理

Android平台中对于State模式的应用。
   **Context——StateMachine
       State   ——State**
Android 状态机 类似树的继承结构，如果当前状态不能对这个事件作出响应，会到父节点继续判断响应
===》可以简单称状态路径、状态树。

State模式

将对象的状态封装成一个独立对象,将不同的状态下调用会执行不同的操作。
根据对象的状态改变行为采用分支语句的实现方式。

StateMachine

State

状态机中的状态封装类—-实现了IState接口。

定义了状态的基本方法：enter、exit、processMessage（消息处理方法）:enter在状态机转入该状态时调用，exit方法在状态机转出该状态时调用。

构造方法声明为protect类型，其他类在状态机stateMachine只能通过StateInfo使用。

构造函数

protected类型，不能实例化，由其子类初始化操作
两个重载的构造函数：指定消息循环队列构造；新建并启动一个HandlerThread构造
都会通过initStateMachine(name,looper)初始化:指定状态机名称，创建SmHandler对象

StateMachine的三个内部类

LogRec类（实现了IState接口）

保存已处理Message的一些信息。
what、state、orgState、dstState…

LogRecords类

保存若干刚处理的LogRec的Vector集合

SmHandler类

消息处理派发和状态控制切换的核心，运行在单独的线程上
stateMachine主要工作都是SmHandler类完成，大多数方法都是对SmHandler的方法的二次封装。

stateMachine的构造函数中开启了一个特殊的子线程HandlerThread专门给SmHandler发送消息，让其处理。

成员变量

mStateInfo定义为一个Hash链表，用于保存添加的所有状态。mInitialState保存初始状态，mDestState保存切换的目的状态。
mLogRecords用于保存已处理过的消息，mStateStack和mTempStateStack是一个数组栈，用于保存状态机中的链式状态关系。

SmHandler主要的三个内部类

StateInfo

保存了StateInfo的基本信息
state、parentStateInfo、active

HaltingState
QuittingState

继承了State重写了processMessage方法

addState(State state ,State parent)

定义stateInfo，
根据传入的State从保存state和stateInfo对应关系的HashMap中获取stateInfo
注意层次结构中的子状态要加入之前，父状态没有加入会RuntimeException
状态添加过程其实就是为每个State创建相应的StateInfo对象，通过该对象来建立各个状态之间的关系，并且一个State-StateInfo键值对的方式保存到mStateInfo Hash表中。StateInfo就是包装State组成一个Node，建立State的父子关系；mStateInfo =new HashMap

completeConstruction

  • stateMachine.start()方法调用SmHander的completeConstruction；
  • 计算状态树的最大深度;
  • 根据查到的树的最大节点个数创建两个状态堆栈mStateStack,mTempStateStack，调用setupInitialStateStack填充该堆栈;
  • 初始化完状态栈后，SmHandler将向消息循环中发送一个SM_INIT_CMD消息;
  • 消息处理过程首先调用invokeEnterMethods函数将mStateStack栈中的所有状态设置为激活状态，同时调用每一个状态的enter()函数;
  • 最后调用performTransitions函数来切换状态，同时设置mIsConstructionCompleted为true，表示状态机已经启动完成，SmHandler在以后的消息处理过程中就不在重新启动状态机了。

performTransitions

处理完消息后(processMessage)，根据SmHandler中的标记mDestState进行状态路径切换（对外提供transitionTo接口方法改变mDestState），状态切换主要是执行原状态的exit方法和enter方法。
首先介绍一下状态切换的思路：以上图中，初始状态为S4，现在目标状态mDestState被设置为S7。前面介绍了保存在mStateStack数组中的节点为:
mStateStack={S0,S1,S4}
mStateStackTopIndex = 2
这是以初始状态节点为起点遍历节点树得到的节点链表。
现在要切换到S7状态节点，则以S7为起始节点，同样遍历状态节点树，查找未激活的所有节点，并保存到mTempStateStack数组中
mTempStateStack={S7,S2,S0}
mTempStateStackCount = 3
接着调用mStateStack中除S0节点外的其他所有节点的exit函数，并且将每个状态节点设置为未激活状态，因此S4，S1被设置为未激活状态；将切换后的状态节点链表mTempStateStack移动到mStateStack，
mStateStack={S0,S2,S7}
mStateStackTopIndex = 2

并调用节点S2，S7的enter函数，同时设置为激活状态。

transitionTo

StateMachine可以认为是处理Message的一个栈，它处理消息的顺序是可以任意变化的。
transitionTo可以设置先处理哪一个state
在相应的state的processMessage()处理
简单地设置了mDestState变量，并未真正更新状态栈mStateStack，在前面介绍了SmHandler在每次处理消息时都会自动更新一次mStateStack，无论mDestState变量值是否改变。由此可知目标状态的设置与状态栈的更新是异步的。

消息处理

SmHandler，就是一个Handler，运行在单独线程中。Handler是用来异步处理派发消息，这里使用Handler管理各个状态，派发消息处理到各个状态中去执行。StateMachine提供了多个消息发送接口，通过这些接口函数可以将消息发送到SmHandler中。
消息处理过程是从mStateStack栈顶派发到栈底，直到该消息被处理！

handlerMessage方法

SmHandler的主要方法,处理通过SmHandler发送的消息:
主要做了两件事：
1.将Message交给State的processMessage方法处理消息；
2.对stateStack中的state通过enter和exit处理先后顺序

状态的初始化（enter方法）、状态的处理（processMessage）、状态的转移（更新状态树）。

if (mIsConstructionCompleted) {  
    /** Normal path */  
    processMsg(msg);//第一个消息处理  
} else if (!mIsConstructionCompleted &&  
        (mMsg.what == SM_INIT_CMD) && (mMsg.obj == mSmHandlerObj)) {  
    /** Initial one time path. */  
    mIsConstructionCompleted = true;  
    invokeEnterMethods(0);//第二个状态的初始化  
} else {  
    throw new RuntimeException("StateMachine.handleMessage: " +  
                "The start method not called, received msg: " + msg);  
}  
performTransitions();//第三个执行状态转移 

processMessage

变量mIsConstructionCompleted在状态机启动完成后被设置为true，因此这里将调用processMsg函数来完成消息处理。

如果当前状态没有处理消息（processMessage返回false），那么持续调用这个状态的父状态，如果没有一个父状态处理，最后由unhandleMessage(msg)处理。

private final void processMsg(Message msg) {  
    StateInfo curStateInfo = mStateStack[mStateStackTopIndex];  
    //如果当前状态未处理该消息  
    while (!curStateInfo.state.processMessage(msg)) {  
        //将消息传给当前状态的父节点处理  
        curStateInfo = curStateInfo.parentStateInfo;  
        if (curStateInfo == null) {  
             //当前状态无父几点，则丢弃该消息  
            mSm.unhandledMessage(msg);  
            if (isQuit(msg)) {  
                transitionTo(mQuittingState);  
            }  
            break;  
        }  
    }  
    //记录处理过的消息  
    if (mSm.recordProcessedMessage(msg)) {  
        if (curStateInfo != null) {  
            State orgState = mStateStack[mStateStackTopIndex].state;  
            mProcessedMessages.add(msg, mSm.getMessageInfo(msg), curStateInfo.state,orgState);  
        } else {  
            mProcessedMessages.add(msg, mSm.getMessageInfo(msg), null, null);  
        }  
    }  
}  
StateMachine使用及源码解读，看完这篇彻底明白了
m0_61418216的博客
09-06 836
private State mDestState; private SmHandler(Looper looper, StateMachine sm) { super(looper); mSm = sm; // 默认将HaltingState和QuittingState加入状态机 addState(mHaltingState, null); addState(mQuittingState, null); } } QuittingState /** State entered.
StateMachine
12-15
StateMachine.pdf
状态机（State Machine）
最新发布
The cure for boredom is curiosity. This is the log of its adventures.
10-19 858
典型应用：业务流程：订单、审批、工单、售后、交付流水线；解析与编译：词法/协议解析器、格式校验；网络与设备：协议状态机、驱动控制、IoT设备生命周期；UI与交互：向导、多步骤表单、登录安全校验；游戏/机器人：行为切换、AI决策、动作编排。设计实践：明确定义“状态”和“事件”，集中维护转移表；单一入口方法处理事件（如 send），对非法转移抛错；将副作用（日志、外部调用）以动作函数附着在转移上；对关键路径做单元测试：合法事件的期望状态、非法事件的错误；
statemachine:易于使用的状态机实现
04-30
状态机 易于使用的状态机实现
Spring状态机 Statemachine使用
weixin_42190492的博客
06-27 1888
状态机（State Machine）是一种描述系统行为的数学模型，核心思想是将系统抽象为有限个状态，并通过状态转移规则定义系统如何响应外部事件。它由一系列状态（States）、转换（Transitions）、事件（Events）、卫兵（Guards）和动作（Actions）组成。在软件开发中，状态机常用于控制程序的流程和状态变化。其核心优势在于: 通过清晰明确的状态定义、自动状态更新，将复杂的状态流转逻辑结构化。从而使得业务逻辑与状态解耦。
StateMachine使用及源码解读
2401_84413531的博客
05-04 802
下面是辛苦给大家整理的学习路线《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》点击传送门，即可获取！// 只改变mDestState，具体的执行在performTransitions中下面是辛苦给大家整理的学习路线[外链图片转存中…(img-sfwiRnNn-1714795713248)]《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》点击传送门，即可获取！
stateMachine状态机框架
09-28
- stateMachine.h：这是框架的头文件，通常包含了状态机框架所使用的数据结构、函数声明以及宏定义等。 - stateMachine.c：这是框架的源文件，其中应该实现了stateMachine.h头文件中声明的功能，包括状态机的初始化...
_jki_lib_state_machine.zip_JKI_JKI state machine_JKI state架构_ope
07-15
JKI State架构提供了一种模块化的设计方式，允许开发者将复杂问题分解为一系列简单状态。每个状态可以独立实现，这样就提高了代码的复用性和可扩展性。此外，状态机的结构清晰，易于理解和调试。 3.2 构建与配置 ...
StateMachine状态机代码C#
03-25
用C#写的一个简单的状态机模型，大家都可以用来参考，比如一些状态的变化和切换都可以参考这个例子，不再是用各种if else，switch的复杂逻辑来切换各种状态了。 包含一个PlayerState状态抽象类，然后有攻击类，防御...
Visual State Machine v1.47
12-22
功能在编辑器中直观地创建状态机Visual State Machine通过提供简单直观的GUI，允许您为每个游戏对象创建一个StateMachine直接在检查器中定义回调在检查器中直接进入或退出状态或转换时设置回调方法，以比以往更快地...
state machine
l3142600073的博客
05-07 433
以摄像头采集图像为例，编写代码步奏如下： (1 NO state matchine) //定义图像采集状态 typedef enum //枚举具摄像头采集图像功能 { IMG_NOINIT = 0, //not start IMG_START, //start to gather image IMG_GATHER, //gathering image IMG_...
Android StateMachine使用举例及源码解析
01-03
Android frameworks源码StateMachine使用举例及源码解析 工作中有一同事说到Android状态机StateMachine。作为一名Android资深工程师，我居然没有听说过StateMachine，因此抓紧时间学习一下。 StateMachine不是Android SDK中的相关API，其存在于frameworks层源码中的一个Java类。可能因为如此，许多应用层的开发人员并未使用过。 因此这里我们先说一下StateMachine的使用方式，然后再对源码进行相关介绍。 StateMachine使用举例 StateMachine原理学习 一、StateMachine使用
EasyStateMachine:容易使用 StateMachine 的示例
06-08
易状态机 容易使用 StateMachine 的示例。
一文详解 Android状态机StateMachine 使用方式及实现原理
bjxiaxueliang的CODING小栈
02-22 8186
`StateMachine`不是`Android SDK`中的相关API，是存在于`frameworks`层源码中的一个Java类。通过这篇文章探究一下其使用方式以及实现原理。
Spring Statemachine 概念及应用
weixin_42128568的博客
06-18 1084
转自https://www.jianshu.com/p/9ee887e045dd，感谢 1 Finite-state machine 1.1 状态机定义 有限状态机，（英语：Finite-state machine, FSM），又称有限状态自动机，简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 有限状态机体现了两点：首先是离散的，然后是有限的。 State：状态这个词有些难以定义，状态存储关于过去的信息，就是说它反映从系统开始到现在时刻的输入变化。 Actions
Android StateMachine
liuning1985622的博客
05-02 1643
Android 状态机的主要作用是管理状态和处理消息。它通过定义一组状态和状态之间的转换关系，来控制系统的行为。当系统接收到消息时，StateMachine会根据当前的状态和消息类型，执行相应的操作或状态转换。在使用Android 状态时，通常需要定义一组状态和状态之间的转换关系。可以使用addState()方法来添加状态，并使用addTransition()方法来定义状态之间的转换关系。
statemachine简介及简单应用
green hand的博客
06-14 9007
1.背景 1.1 spring statemachine是干啥用的 有限状态机（英语：finite-state machine，缩写：FSM），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。将状态和事件控制从不同的业务Service方法的if else中抽离出来。FSM的应用范围很广，对于有复杂状态流，扩展性要求比较高的场景都可以使用该模型。下面是状态机模型中的4个要素，即现态、条件、动作、次态。 现态：是指当前所处的状态。 条件：又称为“事件”。当一个条件被满足，..
状态机StateMachine使用小记
热门推荐
小熙的博客
06-04 2万+
概要：Spring Statemachine 状态机之所以强大，是因为始终保证行为是一致的，这使得调试相对容易。这是因为在机器启动时，操作规则是不可更改的。其思想是，应用程序可能存在有限数量的状态，某些预定义的触发器可以将应用程序从一种状态转移到另一种状态。这样的触发器可以基于事件或计时器。 在应用程序之外定义高级逻辑，然后依靠状态机来管理状态要容易得多。您可以通过发送事件、侦听更改或请求当前状态来与状态机交互。 官网地址：https://projects.spring.io/spring-statemac
Android StateMachine使用
wd229047557的博客
12-24 1009
文章目录1. StateMachineJar的封装2. 使用示例3. 使用注意 1. StateMachineJar的封装 把源码的如下3个文件，提取为jar包使用就可以 frameworks/base/core/java/com/android/internal/util/StateMachine.java frameworks/base/core/java/com/android/intern...
spring-statemachine使用
06-04
<think>嗯，用户要求查找关于SpringStateMachine的使用指南或示例，包括配置步骤和代码示例。我已经得到了一些引用内容，虽然它们只是参考，但提供了一些有用的线索。在引用中看到，SpringStateMachine是一个用于管理状态流转的框架，特别适合订单系统、工作流引擎等场景。现在用户询问具体如何使用它创建状态机，我需要展示配置流程并提供实际代码示例。从引用中找到的关键信息包括：状态机需要分层构建、可以通过注解启用、需要定义状态和事件等元素。关于配置部分，引用提到需要定义状态、事件、状态转换规则和状态监听器。状态监听器可以在状态转换时执行特定操作，这点很重要，因为在实际使用中会需要处理业务逻辑。引用中还提到SpringBoot通过StateMachine框架提供支持，说明可以使用SpringBoot项目来整合这个框架。对于代码示例，引用中有个简单的订单流程示例，包括Order实体类和状态枚举类。状态枚举类列出可能的订单状态如待支付、已支付等；事件枚举列出触发状态变化的事件如支付、发货等。此外还需要配置状态转换规则，定义起始状态和目标状态。用户需要了解如何运行状态机，这涉及到通过Spring上下文获取状态机实例并触发事件。引用展示了一个SpringBoot应用启动类的例子，里面有创建订单并发送支付事件的代码。注意到官方文档链接在引用中，我应该推荐用户查看完整文档，因为框架的细节可能经常更新。同时提醒用户注意状态机设计的关键点：明确定义状态和事件、配置状态转换规则，以及利用状态监听器处理业务逻辑。准备在回答中包括配置依赖的示例代码、状态机和事件枚举类示例、状态机配置类示例、状态监听器实现和运行状态机的入口代码。最后总结创建状态机的主要步骤，帮用户理清思路。</think> 以下是使用 Spring StateMachine 创建状态机的完整指南和代码示例，结合官方文档和最佳实践整理： --- ### 一、核心步骤与配置 #### 1. 添加 Maven 依赖 ```xml <dependency> <groupId>org.springframework.statemachine</groupId> <artifactId>spring-statemachine-core</artifactId> <version>3.2.0</version> <!-- 使用最新版本 --> </dependency> ``` #### 2. 定义状态和事件枚举 ```java // 订单状态 public enum OrderStates { UNPAID, // 待支付 PAID, // 已支付 SHIPPED, // 已发货 RECEIVED, // 已签收 CANCELLED // 已取消 } // 订单事件 public enum OrderEvents { PAY, // 支付事件 SHIP, // 发货事件 CONFIRM_RECEIVE, // 确认收货 CANCEL // 取消订单 } ``` #### 3. 配置状态机（关键步骤） ```java @Configuration @EnableStateMachine public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderStates, OrderEvents> { @Override public void configure(StateMachineStateConfigurer<OrderStates, OrderEvents> states) throws Exception { states.withStates() .initial(OrderStates.UNPAID) // 初始状态 .states(EnumSet.allOf(OrderStates.class)); } @Override public void configure(StateMachineTransitionConfigurer<OrderStates, OrderEvents> transitions) throws Exception { transitions .withExternal() .source(OrderStates.UNPAID).target(OrderStates.PAID) .event(OrderEvents.PAY) .and() .withExternal() .source(OrderStates.PAID).target(OrderStates.SHIPPED) .event(OrderEvents.SHIP) .and() .withExternal() .source(OrderStates.SHIPPED).target(OrderStates.RECEIVED) .event(OrderEvents.CONFIRM_RECEIVE) .and() .withExternal() .source(OrderStates.UNPAID).target(OrderStates.CANCELLED) .event(OrderEvents.CANCEL); } @Bean public StateMachineListener<OrderStates, OrderEvents> listener() { return new StateMachineListenerAdapter<>() { @Override public void transition(Transition<OrderStates, OrderEvents> transition) { if (transition.getTarget() != null) { System.out.println("状态变更: " + transition.getSource().getId() + " -> " + transition.getTarget().getId()); } } }; } } ``` #### 4. 业务实体类 ```java @Data public class Order { private Long id; private OrderState state; // 使用定义的枚举类型 // 其他业务字段... } ``` #### 5. 使用状态机（在Service中） ```java @Service public class OrderService { @Autowired private StateMachineFactory<OrderStates, OrderEvents> factory; public void processOrderEvent(Long orderId, OrderEvents event) { StateMachine<OrderStates, OrderEvents> stateMachine = factory.getStateMachine(); stateMachine.start(); // 发送事件触发状态迁移 stateMachine.sendEvent(MessageBuilder .withPayload(event) .setHeader("orderId", orderId) .build()); } } ``` --- ### 二、关键特性说明 1. **层次化状态** ```java states.withStates() .parent(OrderStates.PROCESSING) // 父状态 .initial(OrderStates.PACKAGING) // 子状态 ``` 2. **动作执行** ```java transitions.withExternal() .source(OrderStates.UNPAID).target(OrderStates.PAID) .event(OrderEvents.PAY) .action(context -> { Long orderId = context.getMessage().getHeaders().get("orderId", Long.class); orderService.updatePaymentStatus(orderId); // 执行业务逻辑 }) ``` 3. **状态守卫（Guard）** ```java .guard(ctx -> { Order order = ctx.getExtendedState().get("order", Order.class); return order.getAmount() > 0; // 仅当金额>0才允许状态迁移 }) ``` --- ### 三、调试与监控 ```java // 打印状态机当前状态 System.out.println("Current state: " + stateMachine.getState().getId()); // 导出UML状态图（需添加spring-statemachine-uml） StateMachineModelVerifier<OrderStates, OrderEvents> verifier = new StateMachineModelVerifier<>(); verifier.verify(stateMachine); ``` > 官方文档推荐：[Spring StateMachine Docs](https://docs.spring.io/spring-statemachine/docs/current/reference/) > 调试工具：[State Machine Designer](https://rclayton.github.io/smithy/) --- ### 常见问题解决方案 1. **事件被拒绝？** - 检查当前状态是否支持该事件 - 验证守卫条件是否满足 - 确保状态机已启动 `.start()` 2. **并发处理** 对每笔订单创建独立状态机实例： ```java StateMachine<OrderStates, OrderEvents> stateMachine = factory.getStateMachine(orderId); ``` 3. **持久化状态** 使用`Repository`保存状态机： ```java @Bean public StateMachineRuntimePersister<...> persister() { return new JpaStateMachineRepository<>(/* JPA配置 */); } ``` --- ### 完整示例项目： GitHub 参考实现：[spring-statemachine-demo](https://github.com/spring-projects/spring-statemachine/tree/master/spring-statemachine-samples) > 最佳实践提示： > 1. 使用`@WithStateMachine`注解分离状态逻辑 > 2. 通过`StateMachineSystemConstants.TASK_EXECUTOR_BEAN_NAME`配置线程池 > 3. 使用`@EnableStateMachineFactory`创建多实例状态机工厂[^4]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值