springboot【28】状态机的实现-Spring StateMachine框架

最新推荐文章于 2025-04-24 08:26:36 发布
原创 最新推荐文章于 2025-04-24 08:26:36 发布 · 2.5k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#springboot教程 #springboot入门 #状态机的实现 #Spring StateMachine框

本文介绍如何使用Spring StateMachine框架实现订单流程状态管理，包括状态与事件定义、状态机配置及监听器实现。

         Spring StateMachine框架的第三个Release版本1.2.0增加了对Spring Boot的自动化配置。


快速入门

         假设我们需要实现一个订单的相关流程，其中包括订单创建、订单支付、订单收货三个动作。整个实现过程：

  • 创建一个Spring Boot的基础工程，并在pom.xml中加入spring-statemachine-core的依赖，具体如下：

    <parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>1.3.7.RELEASE</version>
	<relativePath/> 
</parent>
<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.statemachine</groupId>
		<artifactId>spring-statemachine-core</artifactId>
		<version>1.2.0.RELEASE</version>
	</dependency>
</dependencies>

  • 根据上面所述的订单需求场景定义状态和事件枚举，具体如下：

    public enum States {
    UNPAID,                 // 待支付
    WAITING_FOR_RECEIVE,    // 待收货
    DONE                    // 结束
}
public enum Events {
    PAY,        // 支付
    RECEIVE     // 收货
}

    其中共有三个状态（待支付、待收货、结束）以及两个引起状态迁移的事件（支付、收货），其中支付事件PAY会触发状态从待支付UNPAID状态到待收货WAITING_FOR_RECEIVE状态的迁移，而收货事件RECEIVE会触发状态从待收货WAITING_FOR_RECEIVE状态到结束DONE状态的迁移。

  • 创建状态机配置类StateMachineConfig.java：

    package com.lyd;

@Configuration
@EnableStateMachine
public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<States, Events> {

	private Logger logger = LoggerFactory.getLogger(getClass());
	
	@Override
	public void configure(StateMachineStateConfigurer<States, Events> states) throws Exception{
		//定义状态机中的状态
		states
			.withStates()
				.initial(States.UNPAID) //初始状态
				.states(EnumSet.allOf(States.class));
	}
	
	@Override
	public void configure(StateMachineTransitionConfigurer<States, Events> transitions) throws Exception{
		transitions
			.withExternal()
				.source(States.UNPAID).target(States.WAITING_FOR_RECEIVE)  //指定状态来源和目标
				.event(Events.PAY)	//指定触发事件
				.and()
			.withExternal()
				.source(States.WAITING_FOR_RECEIVE).target(States.DONE)
				.event(Events.RECEIVE);
	}
	
	@Override
	public void configure(StateMachineConfigurationConfigurer<States, Events> config) throws Exception{
		config
			.withConfiguration()
				.listener(listener());  //指定状态机的处理监听器
	}
	
	@Bean
	public StateMachineListener<States, Events> listener(){
		return new StateMachineListenerAdapter<States, Events>(){
			
			@Override
			public void transition(Transition<States, Events> transition){
				
				if(transition.getTarget().getId() == States.UNPAID){
					logger.info("订单创建，待支付");
					return;
				}
				if(transition.getSource().getId() == States.UNPAID
						&& transition.getTarget().getId() == States.WAITING_FOR_RECEIVE){
					logger.info("用户完成支付，待收货");
					return;
				}
				if(transition.getSource().getId() == States.WAITING_FOR_RECEIVE
						&& transition.getTarget().getId() == States.DONE){
					logger.info("用户已收货，订单完成");
				}
			}
		};
	}
}

    在该类中定义了较多配置内容，下面对这些内容一一说明：

    • @EnableStateMachine注解用来启用Spring StateMachine状态机功能

    • configure(StateMachineStateConfigurer<States, Events> states)方法用来初始化当前状态机拥有哪些状态，其中initial(States.UNPAID)定义了初始状态为UNPAID，states(EnumSet.allOf(States.class))则指定了使用上一步中定义的所有状态作为该状态机的状态定义。

    • configure(StateMachineTransitionConfigurer<States, Events> transitions)方法用来初始化当前状态机有哪些状态迁移动作，其中命名中我们很容易理解每一个迁移动作，都有来源状态source，目标状态target以及触发事件event。

    • configure(StateMachineConfigurationConfigurer<States, Events> config)方法为当前的状态机指定了状态监听器，其中listener()则是调用了下一个内容创建的监听器实例，用来处理各个各个发生的状态迁移事件。

    • StateMachineListener<States, Events> listener()方法用来创建StateMachineListener状态监听器的实例，在该实例中会定义具体的状态迁移处理逻辑，上面的实现中只是做了一些输出，实际业务场景会会有更负责的逻辑，所以通常情况下，我们可以将该实例的定义放到独立的类定义中，并用注入的方式加载进来。

  • 创建应用主类来完成整个流程：

    package com.lyd;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.statemachine.StateMachine;

@SpringBootApplication
public class Application implements CommandLineRunner{

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
	
	@Autowired
	private StateMachine<States, Events> stateMachine;
	
	@Override
	public void run(String... args){
		stateMachine.start();
		stateMachine.sendEvent(Events.PAY);
		stateMachine.sendEvent(Events.RECEIVE);
	}
}

    在run函数中，我们定义了整个流程的处理过程，其中start()就是创建这个订单流程，根据之前的定义，该订单会处于待支付状态，然后通过调用sendEvent(Events.PAY)执行支付操作，最后通过掉用sendEvent(Events.RECEIVE)来完成收货操作。在运行了上述程序之后，我们可以在控制台中获得类似下面的输出内容，其中包括了状态监听器中对各个状态迁移做出的处理：



通过上面的例子，我们可以对如何使用Spring StateMachine做如下小结：

  • 定义状态和事件枚举
  • 为状态机定义使用的所有状态以及初始状态
  • 为状态机定义状态的迁移动作
  • 为状态机指定监听处理器


状态监听器

         可以看到使用Spring StateMachine来实现状态机的时候，代码逻辑变得非常简单并且具有层次化。整个状态的调度逻辑主要依靠配置方式的定义，而所有的业务逻辑操作都被定义在了状态监听器中，其实状态监听器可以实现的功能远不止上面我们所述的内容，它还有更多的事件捕获，我们可以通过查看StateMachineListener接口来了解它所有的事件定义：



注解监听器

对于状态监听器，Spring StateMachine还提供了优雅的注解配置实现方式，所有StateMachineListener接口中定义的事件都能通过注解的方式来进行配置实现。比如，我们可以将之前实现的状态监听器用注解配置来做进一步的简化。下面代码实现了与快速入门中定义的listener()方法创建的监听器相同的功能，但是由于通过注解的方式配置，省去了原来事件监听器中各种if的判断，使得代码显得更为简洁，拥有了更好的可读性：

package com.lyd;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.statemachine.annotation.OnTransition;
import org.springframework.statemachine.annotation.OnTransitionEnd;
import org.springframework.statemachine.annotation.OnTransitionStart;
import org.springframework.statemachine.annotation.WithStateMachine;

/**
 * 该配置实现了com.lyd.StateMachineConfig类中定义的状态机监听器实现。 
 */
@WithStateMachine
public class EventConfig {

	private Logger logger = LoggerFactory.getLogger(getClass());
	
	@OnTransition(target = "UNPAID")
	public void create(){
		logger.info("订单创建，待支付");
	}
	
	@OnTransition(source = "UNPAID", target = "WAITING_FOR_RECEIVE")
    public void pay() {
        logger.info("用户完成支付，待收货");
    }

    @OnTransitionStart(source = "UNPAID", target = "WAITING_FOR_RECEIVE")
    public void payStart() {
        logger.info("用户完成支付，待收货: start");
    }

    @OnTransitionEnd(source = "UNPAID", target = "WAITING_FOR_RECEIVE")
    public void payEnd() {
        logger.info("用户完成支付，待收货: end");
    }
    
    @OnTransition(source = "WAITING_FOR_RECEIVE", target = "DONE")
    public void receive() {
        logger.info("用户已收货，订单完成");
    }
}

注释掉StateMachineConfig.java中监听器配置代码，即可运行：

@Configuration
@EnableStateMachine
public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<States, Events> {

	private Logger logger = LoggerFactory.getLogger(getClass());
	
	@Override
	public void configure(StateMachineStateConfigurer<States, Events> states) throws Exception{
		//定义状态机中的状态
		states
			.withStates()
				.initial(States.UNPAID) //初始状态
				.states(EnumSet.allOf(States.class));
	}
	
	@Override
	public void configure(StateMachineTransitionConfigurer<States, Events> transitions) throws Exception{
		transitions
			.withExternal()
				.source(States.UNPAID).target(States.WAITING_FOR_RECEIVE)  //指定状态来源和目标
				.event(Events.PAY)	//指定触发事件
				.and()
			.withExternal()
				.source(States.WAITING_FOR_RECEIVE).target(States.DONE)
				.event(Events.RECEIVE);
	}



     /*@Override
	public void configure(StateMachineConfigurationConfigurer<States, Events> config) throws Exception{
		config
			.withConfiguration()
				.listener(listener());  //指定状态机的处理监听器
	}
	
	@Bean
	public StateMachineListener<States, Events> listener(){
		return new StateMachineListenerAdapter<States, Events>(){
			
			@Override
			public void transition(Transition<States, Events> transition){
				
				if(transition.getTarget().getId() == States.UNPAID){
					logger.info("订单创建，待支付");
					return;
				}
				if(transition.getSource().getId() == States.UNPAID
						&& transition.getTarget().getId() == States.WAITING_FOR_RECEIVE){
					logger.info("用户完成支付，待收货");
					return;
				}
				if(transition.getSource().getId() == States.WAITING_FOR_RECEIVE
						&& transition.getTarget().getId() == States.DONE){
					logger.info("用户已收货，订单完成");
				}
			}
		};
	}*/
}

结果：




下面是完整项目结构：





sm-demo:Spring Boot状态机演示
03-08
Spring State Machine演示-讨价还价 基于简单演示应用程序 详细说明 截屏 安装 您需要预先安装Java11。 然后，您可以将其作为常规的Spring Boot Web应用程序运行。 $ ./mvnw spring-boot:run 徽章 执照
SpringBoot状态机避坑指南：5大陷阱与最佳实践
最新发布
m0_72340523的博客
09-19 1197
还在用一长串 if-else 堆砌审核流程？状态判断满天飞，改需求改到想跑路？别让流程控制变成代码灾难！本文带你用 Spring Boot 状态机彻底告别面条代码，通过事件驱动重构审核流，实现状态与行为解耦。详解三大踩坑实录：绕开状态机、异常不回滚、重启丢状态，并给出落地方案。更有可视化流程图生成、Guard 校验、持久化集成等实战技巧，五条军规让你的流程稳如老狗。当业务变得复杂，真正优雅的不是写更多的 if，而是画一张能“自己走”的状态图。
Spring Boot使用Spring StateMachine框架实现状态机
实践求真知
11-04 8019
一 点睛 Spring StateMachine框架可能对于大部分使用Spring的开发者来说还比较生僻，它的主要功能是帮助开发者简化状态机的开发过程，让状态机结构更加层次化。它的第三个Release版本1.2.0，其中增加了对Spring Boot的自动化配置。 我们通过一个简单的示例来对Spring StateMachine有一个初步的认识。 假设我们需要实现一个订单的相关流程，其中包括...
SpringBoot集成spring-statemachine状态机实现业务流程
dylan的博客
08-05 3962
在工作中经常会遇到业务流程的实现（事件审批、请假任务审批流程等），常见的实现方式是简单的业务流程使用硬编码，通过简单状态status实现，复杂的业务流程使用流程引擎实现（Flowable、Activiti、Camunda等），但是流程引擎实现比较复杂，对一些不常变更的和简单的业务流程使用流程引擎比较大材小用；在一些比较简单的业务流程中，经常使用硬编码的方式实现，即多个,代码耦合性比较强，并在流程变更时，需要修改的代码比较多，整体逻辑比较混乱，不利于维护；所以需要寻一种硬编码和流程引擎之外的实现方式；
Spring Boot的场景下的状态机
2401_83127745的博客
03-03 2866
框架集成：Spring State Machine与Spring Boot的集成提供了一致的配置和管理体验，使得状态机的实现和管理能够无缝地融入到Spring Boot应用程序中。这种集成还包括对Spring事件监听、事务管理、持久化支持等特性的支持。声明式配置：Spring State Machine支持基于注解和Java配置的声明式配置，这使得状态机的定义更加直观和易于维护。开发者可以通过简洁的配置定义状态、事件和转换，而无需编写冗长的条件逻辑代码。灵活的持久化选项。
SpringBoot状态机
编码浪子的专栏
12-24 2308
Spring Boot 状态机（State Machine）是 Spring Framework 提供的一种用于实现复杂业务逻辑的状态管理工具。它基于有限状态机（Finite State Machine, FSM）的概念，允许开发者定义一组状态、事件以及它们之间的转换规则。这在处理具有多个步骤或条件的工作流时特别有用。
Spring Boot 揭秘与实战（七） 实用技术篇 - StateMachine 状态机机制
weixin_33953384的博客
03-21 545
原文地址：Spring Boot 揭秘与实战（七） 实用技术篇 - StateMachine 状态机机制博客地址：blog.720ui.com/ Spring StateMachine 让状态机结构更加层次化，可以帮助开发者简化状态机的开发过程。之前，我们使用二维数组实现状态机机制，现在，我们来用 Spring StateMachine 进行改造。 环境依赖 修改 POM 文件，添加 spri...
springboot+状态机
qq_38564282的博客
05-10 3826
最近好多业务都是流程状态的传递，借此机会写词文章，记录一下，什么样的场景设计需要我们的状态机：目前市场流行的状态机：2.阿里COLA4.4。
使用Spring StateMachine框架实现状态机
2401_84048445的博客
04-19 1439
手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）**手绘了下图所示的kafka知识大纲流程图（xmind文件不能上传，导出图片展现），但都可提供源文件给每位爱学习的朋友[外链图片转存中…(img-plBvCsxx-1713524824138)]
simple-state-machine:一个用于Spring Boot项目的简单Java状态机
05-31
简单状态机 Spring Boot 项目的简单状态机 导入到像 STS 这样的 IDE 后，可以作为 Spring Boot 应用程序运行。 该项目包含一个框架和一个框架的使用说明，用于示例项目，如在线订单处理。 用法 初始状态 活动前 处理器 事后 最终状态 默认 -> 提交-> orderProcessor() -> 订单创建 -> 正在等待中 PMTPENDING -> 支付 -> 支付处理器（）-> paymentError-> 正在等待中 PMTPENDING -> 支付 -> 支付处理器（）-> 支付成功 -> 完全的 要使用这个框架，首先要像上面一样创建一个状态转换表。 然后实现接口 ProcessState 和 ProcessEvent。 有关示例，请参阅 OrderState 和 OrderEvent 类 确定流程的主键。 对于订单流程，它将是
JAVA：Spring StateMachine 状态机框架的技术指南
木头
04-24 731
JAVA：Spring StateMachine 状态机框架的技术指南
基于Spring-statemachine的有限状态机(FSM)的介绍及示例
热门推荐
马猴烧酒└(┐卍^o^)卍ﾄﾞｩﾙﾙﾙ~楪詩月「YUZURIHA SHIZUKI」
11-26 5万+
前言本文主要介绍一下状态机以及相关的一些概念。结合一个简单的订单状态流程，示例怎样在Springboot中集成Spring-statemachine。有限状态机（Finite-state machine）有限状态机（英语：finite-state machine，缩写：FSM），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。示例中以一个常见的“订单”的状态转移为例。
一个轻量实用的Java状态机框架--Cola-StateMachine
qq_36551991的博客
01-17 1万+
详解Java状态机框架--Cola-StateMachine
Spring Boot集成Spring Statemachine
java程序员的蜕变之路
03-12 1780
java// 定义状态枚举// 定义事件枚举java// 定义订单状态枚举// 定义订单事件枚举。
SpringBoot集成Spring Statemachine（状态机）完整示例
2401_89221445的博客
11-27 1436
总结：以上就是状态机的基础用法，一个事件对应一种来源状态(sourceStatus)和目标状态(targetStatus)。在我自己使用到的场景中还包含一个事件需要根据不同的条件将同一来源状态流转到不同的目标状态。扩展（新增一个放款事件，该事件会将订单状态由【审核成功】流转到【放款成功】或者【部分放款成功】，具体流流转哪一个状态是由订单的放款金额决定的，如果申请金额和放款金额一致就是【放款成功】，放款金额小于申请金额就是【部分放款成功】），并传入相应的事件来改变订单的状态。
Springboot使用mechineState状态机
青春不散场的专栏
08-23 566
参考:https://docs.spring.io/spring-statemachine/docs/1.0.0.M3/reference/htmlsingle/#sm-statecontext。
【SpringBoot 技术专题】「StateMachine」FSM 状态机设计及实现
很多时候犯错都是在不知情的情况下发生的
03-25 1454
前言介绍 本文主要介绍一下状态机以及相关的一些概念。结合一个简单的订单状态流程，示例怎样在 Springboot 中集成 Spring-statemachine。 有限状态机（Finite-state machine） 有限状态机（英语：finite-state machine，缩写：FSM），简称状态机，是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。 应用 FSM 模型可以帮助对象生命周期的状态的顺序以及导致状态变化的事件进行管理。将状态和事件控制从不同的业务 Se
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、付费专栏及课程。

余额充值