Spring状态机的介绍与使用

1.什么是Spring的状态机

• Spring 状态机（Spring State Machine）是 Spring Framework 提供的一个模块，用于支持有限状态机（Finite State Machine，FSM）的实现。有限状态机是一个数学模型，描述了一个系统在不同状态之间的转换以及触发这些转换的事件。
  
• Spring 状态机主要用于处理对象的状态变化和状态之间的转换。它提供了一种以声明性的方式定义状态和状态之间转换的机制，并能够处理各种事件触发的状态迁移。这在某些应用中非常有用，比如工作流、订单处理、游戏引擎等领域。
  
• Spring StatsMachine主要涉及到两个重要的概念，一个是State(状态)、一个是Event(事件)。
  

2.Spring 状态机的使用

• 场景：商城项目中对于订单状态的层层转换。
  

1.使用Spring状态机先引入它的Maven依赖

1.         <dependency>
2.             <groupId>org.springframework.statemachine</groupId>
3.             <artifactId>spring-statemachine-starter</artifactId>
4.             <version>2.2.0.RELEASE</version>
5.         </dependency>
7.         <dependency>
8.          <groupId>org.springframework.statemachine</groupId>
9.         <artifactId>spring-statemachine-redis</artifactId>
10.     </dependency>               

复制代码

2.生成状态机的状态与事件：（OrderState，OrderEvents）

• OrderState：
  

1. public enum OrderState {
2.     UNPAID,                 // 待支付
3.     WAITING_FOR_RECEIVE,    // 待收货
4.     DONE                    // 结束
5. }

复制代码

• OrderEvents
  

1. public enum OrderEvents {
2.     PAY,        // 支付
3.     RECEIVE     // 收货
4. }

复制代码

3.将状态与事件进行绑定：（StateMachineConfig）

1. @Configuration
2. @EnableStateMachine(name = "StateMachineConfig")
3. public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<TestState, TestEvents> {
5.     private Logger logger = LoggerFactory.getLogger(getClass());
6.     //定义初始状态
7.     @Override
8.     public void configure(StateMachineStateConfigurer<TestState, TestEvents> states)
9.             throws Exception {
10.         states
11.             .withStates()
12.                 .initial(TestState.UNPAID)
13.                 .states(EnumSet.allOf(TestState.class));
14.     }
15.     //状态转换过程 触发什么事件就转换为什么状态
16.     @Override
17.     public void configure(StateMachineTransitionConfigurer<TestState, TestEvents> transitions)
18.             throws Exception {
19.         transitions
20.             .withExternal()
21.                 .source(TestState.UNPAID).target(TestState.WAITING_FOR_RECEIVE)
22.                 .event(TestEvents.PAY)
23.                 .and()
24.             .withExternal()
25.                 .source(TestState.WAITING_FOR_RECEIVE).target(TestState.DONE)
26.                 .event(TestEvents.RECEIVE);
27.     }
28. }

复制代码

4.将事件监听触发与配置类进行配置：（EventListener）

1. @Component
2. @WithStateMachine(name = "StateMachineConfig")
3. public class EventListener {
5.     private Logger logger = LoggerFactory.getLogger(getClass());
7.     @OnTransition(target = "UNPAID")
8.     public boolean create(Message<Order> order) {<br>　　　　 // 创建订单逻辑
9.         logger.info("订单创建，待支付");
10.         return true;
11.     }
13.     @OnTransition(source = "UNPAID", target = "WAITING_FOR_RECEIVE")
14.     public boolean pay(Message<Order> order) {
15.         // 支付逻辑 从redis根据order 来进行处理
16.         logger.info("用户完成支付，待收货");
17.         return true;
18.     }
20.     @OnTransition(source = "WAITING_FOR_RECEIVE", target = "DONE")
21.     public boolean receive(Message<Order> order) {<br>　　　　　//从redis中根据传入的order 来查询当前订单 并业务处理
22.         logger.info("用户已收货，订单完成");
23.         return true;
24.     }
26. }

复制代码

最后测试：

1. @SpringBootApplication
2. public class DemoApplication implements CommandLineRunner {
3.     public DemoApplication(StateMachine<TestState, TestEvents> stateMachine) {
4.         this.stateMachine = stateMachine;
5.     }
7.     public static void main(String[] args) {
8.         SpringApplication.run(DemoApplication.class, args);
9.     }
10.     private final StateMachine<TestState, TestEvents> stateMachine;
12.     @Override
13.     public void run(String... args) throws Exception {
14.         Order order=new Order("测试",0);
15.         // 使用 MessageBuilder 创建消息并设置负载和头信息
16.         Message message = MessageBuilder
17.                 .withPayload(TestEvents.PAY)
18.                 .setHeader("order", order)
19.                 .build();
20.         // 发送消息给状态机
21.         stateMachine.start();
22.         stateMachine.sendEvent(message);
23.     }
24. }

复制代码

测试结果：

 结论：在一些工作流、订单处理的时候可以使用状态机这种设计模式，将状态和事件进行绑定，然后对状态改变进行监听，最后只需要在监听内部对业务代码进行处理。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！