Spring Boot集成Spring Statemachine

沙漏无语2025-03-14 23:46

Spring Statemachine 是 Spring 框架下的一个模块，用于简化状态机的创建和管理，它允许开发者使用 Spring 的特性（如依赖注入、AOP 等）来构建复杂的状态机应用。以下是关于 Spring Statemachine 的详细介绍：

主要特性

  1. 丰富的状态机模型支持：支持多种状态机模型，如简单状态机、层次状态机和并行状态机。层次状态机允许状态嵌套，并行状态机可以同时处理多个独立的状态流。
  2. 灵活的配置方式：可以使用 Java 配置、XML 配置或注解来定义状态机的状态、转移、事件等。
  3. 与 Spring 生态集成：无缝集成 Spring 框架的其他模块，如 Spring Boot、Spring MVC 等，方便构建企业级应用。
  4. 事件驱动机制：通过事件触发状态转移，易于与外部系统进行交互。
  5. 状态监听器：允许开发者在状态转移前后执行自定义逻辑，如日志记录、业务处理等。

快速入门

1. 添加依赖

如果你使用 Maven，在 pom.xml 中添加以下依赖：

xml

复制代码 
<dependency>
    <groupId>org.springframework.statemachine</groupId>
    <artifactId>spring-statemachine-core</artifactId>
    <version>3.2.1</version>
</dependency>
2. 定义状态和事件

java

复制代码 
// 定义状态枚举
public enum States {
    STATE1, STATE2, STATE3
}

// 定义事件枚举
public enum Events {
    EVENT1, EVENT2
}
3. 配置状态机

使用 Java 配置方式：

java

复制代码 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.statemachine.config.EnableStateMachine;
import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;

import java.util.EnumSet;

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

    @Override
    public void configure(StateMachineConfigurationConfigurer<States, Events> config) throws Exception {
        config
           .withConfiguration()
               .autoStartup(true);
    }

    @Override
    public void configure(StateMachineStateConfigurer<States, Events> states) throws Exception {
        states
           .withStates()
               .initial(States.STATE1)
               .states(EnumSet.allOf(States.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<States, Events> transitions) throws Exception {
        transitions
           .withExternal()
               .source(States.STATE1).target(States.STATE2).event(Events.EVENT1)
               .and()
           .withExternal()
               .source(States.STATE2).target(States.STATE3).event(Events.EVENT2);
    }
}
4. 使用状态机

java

复制代码 
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 StateMachineApp implements CommandLineRunner {

    @Autowired
    private StateMachine<States, Events> stateMachine;

    public static void main(String[] args) {
        SpringApplication.run(StateMachineApp.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        stateMachine.start();
        System.out.println("当前状态: " + stateMachine.getState().getId());

        stateMachine.sendEvent(Events.EVENT1);
        System.out.println("触发 EVENT1 后状态: " + stateMachine.getState().getId());

        stateMachine.sendEvent(Events.EVENT2);
        System.out.println("触发 EVENT2 后状态: " + stateMachine.getState().getId());
    }
}

代码解释

  1. 定义状态和事件：使用枚举类型定义状态机的状态和事件，方便管理和使用。
  2. @Configuration：表明这是一个配置类。
  3. @EnableStateMachine：启用状态机功能。
  4. 配置状态机 ：
    • configure(StateMachineConfigurationConfigurer)：配置状态机的基本属性，如自动启动。
    • configure(StateMachineStateConfigurer)：定义状态机的状态，指定初始状态STATE_A和所有可能的状态。
    • configure(StateMachineTransitionConfigurer)：定义状态之间的转移规则，包括源状态、目标状态和触发事件。EVENT_1 事件触发从 STATE_A 到 STATE_B 的转移，EVENT_2 事件触发从 STATE_B 到 STATE_C 的转移。
  5. 使用状态机 ：在 CommandLineRunner 中注入状态机实例，启动状态机并发送事件，观察状态的变化。

应用场景

  1. 工作流管理：如订单处理流程、审批流程等，通过状态机可以清晰地管理每个步骤的状态转换。
  2. 游戏开发：管理游戏角色的状态，如站立、行走、攻击等，根据用户输入和游戏逻辑进行状态转移。
  3. 设备控制：控制物联网设备的状态，如智能家电的开关、模式切换等。

Spring Statemachine 提供了强大而灵活的功能，帮助开发者更高效地实现状态机应用。

-----------------------------------------------DEMO------------------------------------------------------------------

以下为你提供一个较为完整的 Spring Boot 集成 Spring Statemachine 的示例代码，这个示例模拟了一个简单的订单状态机，包含待支付、已支付、已发货、已完成几种状态。

1. 创建 Spring Boot 项目并添加依赖

可以使用 Spring Initializr 或者 IDE 自带的 Spring Boot 项目创建功能，添加以下依赖：

xml

复制代码 
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.statemachine</groupId>
        <artifactId>spring-statemachine-core</artifactId>
        <version>3.2.1</version>
    </dependency>
</dependencies>

2. 定义状态和事件枚举

java

复制代码 
// 定义订单状态枚举
public enum OrderState {
    PENDING_PAYMENT, PAID, SHIPPED, COMPLETED
}

// 定义订单事件枚举
public enum OrderEvent {
    PAY, SHIP, DELIVER
}

3. 配置状态机

java

复制代码 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.statemachine.config.EnableStateMachine;
import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;

import java.util.EnumSet;

@Configuration
@EnableStateMachine
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderState, OrderEvent> {

    @Override
    public void configure(StateMachineConfigurationConfigurer<OrderState, OrderEvent> config) throws Exception {
        config
           .withConfiguration()
               .autoStartup(true);
    }

    @Override
    public void configure(StateMachineStateConfigurer<OrderState, OrderEvent> states) throws Exception {
        states
           .withStates()
               .initial(OrderState.PENDING_PAYMENT)
               .states(EnumSet.allOf(OrderState.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<OrderState, OrderEvent> transitions) throws Exception {
        transitions
           .withExternal()
               .source(OrderState.PENDING_PAYMENT).target(OrderState.PAID).event(OrderEvent.PAY)
               .and()
           .withExternal()
               .source(OrderState.PAID).target(OrderState.SHIPPED).event(OrderEvent.SHIP)
               .and()
           .withExternal()
               .source(OrderState.SHIPPED).target(OrderState.COMPLETED).event(OrderEvent.DELIVER);
    }
}

4. 创建状态机服务类

java

复制代码 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.statemachine.StateMachine;
import org.springframework.stereotype.Service;

@Service
public class OrderStateMachineService {

    @Autowired
    private StateMachine<OrderState, OrderEvent> stateMachine;

    public boolean sendEvent(OrderEvent event) {
        return stateMachine.sendEvent(event);
    }

    public OrderState getCurrentState() {
        return stateMachine.getState().getId();
    }
}

5. 创建控制器类

java

复制代码 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderStateMachineService orderStateMachineService;

    @GetMapping("/currentState")
    public OrderState getCurrentState() {
        return orderStateMachineService.getCurrentState();
    }

    @PostMapping("/sendEvent/{event}")
    public String sendEvent(@PathVariable OrderEvent event) {
        boolean result = orderStateMachineService.sendEvent(event);
        if (result) {
            return "事件发送成功，当前状态: " + orderStateMachineService.getCurrentState();
        } else {
            return "事件发送失败，当前状态: " + orderStateMachineService.getCurrentState();
        }
    }
}

6. 启动 Spring Boot 应用

java

复制代码 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringStatemachineDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringStatemachineDemoApplication.class, args);
    }
}

代码解释

  • 状态和事件枚举 ：OrderState 定义了订单可能的状态，OrderEvent 定义了触发状态转移的事件。
  • 状态机配置 ：OrderStateMachineConfig 类使用 @EnableStateMachine 注解启用状态机，通过重写三个配置方法分别配置状态机的基本属性、状态和转移规则。
  • 状态机服务类 ：OrderStateMachineService 封装了状态机的操作，包括发送事件和获取当前状态。
  • 控制器类 ：OrderController 提供了两个接口，一个用于获取当前订单状态，另一个用于发送事件触发状态转移。
  • 启动类 ：SpringStatemachineDemoApplication 是 Spring Boot 应用的启动类。

测试

启动应用后，可以使用以下方式进行测试：

  • 获取当前状态：访问 http://localhost:8080/order/currentState
  • 发送事件：访问 http://localhost:8080/order/sendEvent/PAY 触发支付事件，根据状态机配置，订单状态将从 PENDING_PAYMENT 转移到 PAID。
复制代码 
transitions
           .withExternal()
               .source(OrderState.PENDING_PAYMENT).target(OrderState.PAID).event(OrderEvent.PAY)
               .and()
           .withExternal()
               .source(OrderState.PAID).target(OrderState.SHIPPED).event(OrderEvent.SHIP)
               .and()
           .withExternal()
               .source(OrderState.SHIPPED).target(OrderState.COMPLETED).event(OrderEvent.DELIVER);

这段代码的主要作用是定义状态机中不同状态之间的转移规则。在一个订单处理的状态机场景里，它明确了订单在不同状态（如待支付、已支付、已发货、已完成）之间如何根据特定事件（如支付、发货、交付）进行转换。

代码结构分析

整体上，这段代码通过多次调用 withExternal() 方法来定义多个外部状态转移规则，每个状态转移规则由 source（源状态）、target（目标状态）和 event（触发事件）三个关键部分组成，不同的状态转移规则之间通过 .and() 方法进行连接。

各部分详细解释

withExternal()

withExternal() 方法用于定义外部状态转移，即状态机从一个状态转移到另一个不同的状态。与之相对的还有内部转移（withInternal()），内部转移不会改变状态机的状态，只是在当前状态下执行一些操作。

.source(OrderState.PENDING_PAYMENT).target(OrderState.PAID).event(OrderEvent.PAY)
  • source(OrderState.PENDING_PAYMENT) ：指定状态转移的起始状态，这里是 OrderState.PENDING_PAYMENT，表示订单处于待支付状态。
  • target(OrderState.PAID) ：指定状态转移的目标状态，即 OrderState.PAID，意味着订单在满足条件后将转移到已支付状态。
  • event(OrderEvent.PAY) ：指定触发状态转移的事件，当 OrderEvent.PAY 事件发生时，状态机将从待支付状态转移到已支付状态。
.and()

and() 方法用于连接多个状态转移规则，它表示一个规则定义的结束和下一个规则定义的开始，使得可以在同一个配置方法中定义多个不同的状态转移规则。

后续规则

java

复制代码 
.withExternal()
    .source(OrderState.PAID).target(OrderState.SHIPPED).event(OrderEvent.SHIP)
.and()
.withExternal()
    .source(OrderState.SHIPPED).target(OrderState.COMPLETED).event(OrderEvent.DELIVER);

这部分代码定义了另外两个状态转移规则：

  • 当 OrderEvent.SHIP 事件发生时，订单从已支付状态（OrderState.PAID）转移到已发货状态（OrderState.SHIPPED）。
  • 当 OrderEvent.DELIVER 事件发生时，订单从已发货状态（OrderState.SHIPPED）转移到已完成状态（OrderState.COMPLETED）。

示例代码扩展

如果需要在状态转移时执行一些额外的操作，比如记录日志或者更新数据库，可以使用 action() 方法。以下是一个扩展后的示例：

复制代码 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.statemachine.action.Action;
import org.springframework.statemachine.config.EnableStateMachine;
import org.springframework.statemachine.config.EnumStateMachineConfigurerAdapter;
import org.springframework.statemachine.config.builders.StateMachineConfigurationConfigurer;
import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;

import java.util.EnumSet;

@Configuration
@EnableStateMachine
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderState, OrderEvent> {

    @Override
    public void configure(StateMachineTransitionConfigurer<OrderState, OrderEvent> transitions) throws Exception {
        Action<OrderState, OrderEvent> payAction = context -> {
            System.out.println("订单已支付，更新订单状态为已支付");
            // 这里可以添加更新数据库等操作
        };

        Action<OrderState, OrderEvent> shipAction = context -> {
            System.out.println("订单已发货，更新订单状态为已发货");
            // 这里可以添加更新数据库等操作
        };

        Action<OrderState, OrderEvent> deliverAction = context -> {
            System.out.println("订单已完成，更新订单状态为已完成");
            // 这里可以添加更新数据库等操作
        };

        transitions
           .withExternal()
               .source(OrderState.PENDING_PAYMENT).target(OrderState.PAID).event(OrderEvent.PAY)
               .action(payAction)
               .and()
           .withExternal()
               .source(OrderState.PAID).target(OrderState.SHIPPED).event(OrderEvent.SHIP)
               .action(shipAction)
               .and()
           .withExternal()
               .source(OrderState.SHIPPED).target(OrderState.COMPLETED).event(OrderEvent.DELIVER)
               .action(deliverAction);
    }

    // 其他配置方法保持不变
}

在这个扩展示例中，通过定义 Action 对象，并在状态转移规则中使用 action() 方法，在状态转移时执行了相应的操作。

相关推荐
勇敢牛牛_16 分钟前
【Rust基础】Rust后端开发常用库
开发语言·后端·rust
路在脚下@2 小时前
使用RabbitMQ实现流量削峰填谷
spring boot·rabbitmq
小安同学iter3 小时前
SpringMVC（三）响应处理
java·spring
努力小贼3 小时前
SpringBoot——Maven篇
java·spring boot·maven
测试开发小白变怪兽4 小时前
Spring Boot + MyBatis-Plus 项目目录结构
spring boot·tomcat·mybatis
液态不合群4 小时前
SpringCloud带你走进微服务的世界
spring·spring cloud·微服务
zhuyasen5 小时前
Go错误码规范化指南：构建优雅的HTTP & gRPC错误处理体系
后端·go
小杨4045 小时前
springboot框架项目实践应用七（validation分组、嵌套校验）
spring boot·后端·架构
AskHarries6 小时前
Spring Boot对接twilio发送邮件信息
后端
热门推荐
01从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑02如何在WPS和Word/Excel中直接使用DeepSeek功能03DeepSeek各版本说明与优缺点分析04KGG转MP3工具|非KGM文件|解密音频05DeepSeek RAGFlow构建本地知识库系统06本地部署DeepSeek教程（Mac版本）07如何本地部署AI智能体平台，带你手搓一个AI Agent08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具10Windows 11 安装 Dify 完整指南 非docker环境