HelloWorld
登录

玩转Spring状态机 | 京东云技术团队

京东云开发者

2023-12-20

1305 0 0

说起Spring状态机，大家很容易联想到这个状态机和设计模式中状态模式的区别是啥呢？没错，Spring状态机就是状态模式的一种实现，在介绍Spring状态机之前，让我们来看看设计模式中的状态模式。

1. 状态模式

状态模式的定义如下：

状态模式（State Pattern）是一种行为型设计模式，它允许对象在内部状态发生变化时改变其行为。在状态模式中，一个对象的行为取决于其当前状态，而且可以随时改变这个状态。状态模式将对象的状态封装在不同的状态类中，从而使代码更加清晰和易于维护。当一个对象的状态改变时，状态模式会自动更新该对象的行为，而不需要在代码中手动进行判断和处理。

通常业务系统中会存在一些拥有状态的对象，而且这些状态之间可以进行转换，并且在不同的状态下会表现出不同的行为或者不同的功能，比如交通灯控制系统中会存在红灯、绿灯和黄灯，再比如订单系统中的订单会存在已下单、待支付、待发货、待收货等状态，这些状态会通过不同的行为进行相互转换，这时候在系统设计时就可以使用状态模式。

下面是状态模式的类图：

可以看到状态模式主要包含三种类型的角色：

1、上下文(**Context**)角色：封装了状态的实例，负责维护状态实例，并将请求委托给当前的状态对象。

2、抽象状态(**State**)角色：定义了表示不同状态的接口，并封装了该状态下的行为。所有具体状态都实现这个接口。

3、具体状态(**Concrete State**)角色：具体实现了抽象状态角色的接口，并封装了该状态下的行为。

下面是使用状态模式实现红绿灯状态变更的一个简单案例：

抽象状态类：

1/**
2 * @description: 抽象状态类
3 */
4public abstract class MyState {
5    abstract void handler();
6}
7

具体状态类A

1/**
2 * @description: 具体状态A
3 */
4public class RedLightState extends MyState{
5
6    @Override
7    void handler() {
8        System.out.println("红灯停");
9    }
10}
11
12
13

具体状态类B

1/**
2 * @description: 具体状态B
3 */
4public class GreenLightState extends MyState{
5
6    @Override
7    void handler() {
8        System.out.println("绿灯行");
9    }
10}
11
12
13

环境类：维护当前状态对象，并提供了切换状态的方法。

1/**
2 * @description: 环境类
3 */
4public class MyContext {
5
6    private MyState state;
7
8    public void setState(MyState state) {
9        this.state = state;
10    }
11
12    public void handler() {
13        state.handler();
14    }
15}
16

测试类

1/**
2 * @description: 测试状态模式
3 */
4public class TestStateModel {
5    public static void main(String[] args) {
6        MyContext myContext = new MyContext();
7
8        RedLightState redLightState = new RedLightState();
9        GreenLightState greenLightState = new GreenLightState();
10
11        myContext.setState(redLightState);
12        myContext.handler(); //红灯停
13
14        myContext.setState(greenLightState);
15        myContext.handler(); //绿灯行
16    }
17}
18

下面是对应的执行结果

可以发现，使用状态模式中的状态类在一定程度上也消除了if-else逻辑校验，看到这里， 有些人可能会有疑问：状态模式和策略模式的区别是什么呢？

状态模式更关注对象在不同状态的行为和状态之间的流转，而策略模式更关注对象不同策略的选择。

上面我们介绍了设计模式中的状态模式，接下来我们来看看Spring状态机。

2. Spring状态机

状态机，也就是 State Machine ，不是指一台实际机器，而是指一个数学模型 。说白了，就是指一张状态转换图。 状态机是状态模式的一种应用，相当于上下文角色的一个升级版。在工作流或游戏等各种系统中有大量使用，如各种工作流引擎，它几乎是状态机的子集和实现，封装状态的变化规则。Spring也提供了一个很好的解决方案。Spring中的组件名称就叫作状态机（StateMachine）。状态机帮助开发者简化状态控制的开发过程，让状态机结构更加层次化。

通过定义，我们很容易分析得到状态机应当具备一下几个要素：

  1. 当前状态：也就是状态流转的起始状态。

  2. 触发事件：引起状态之间流转的一些列动作。

  3. 响应函数：触发事件到下一个状态之间的规则。

  4. 目标状态：状态流转的目标状态。

对于组件化的状态机，当前使用较多的主要是两种：一种是Spring 状态机，一种是COLA状态机，这两种状态机的对比如下表所示：

 Spring 状态机COLA 状态机
API 调用使用 Reactive 的 Mono、Flux 方式进行 API 调用同步的 API 调用，如果有需要也可以将方法通过 消息队列、定时任务、多线程等方式进行异步调用
代码量core 包 284 个接口和类36 个接口和类
生态非常丰富较为贫瘠
定制化难度困难简单

可以看到，Spring状态机锁提供的内容较为丰富，当然对于自定义的支持就不如COLA状态机好，如果对自定义的需求比较高，那建议使用COLA状态机。

本文以Spring状态机为例，展示如何在业务系统中使用状态机。

为了便于大家了解Spring状态机的实现原理和使用方式以及其提供的功能，下面列出了官方文档和源码，感兴趣的同学可以阅读阅读。

官方文档： https://docs.spring.io/spring-statemachine/docs/4.0.0/reference/index.html#statemachine-config-states

源代码： https://github.com/spring-projects/spring-statemachine

3. Spring状态机实现订单状态流转

对于状态模式，Spring封装好了一个组件，就叫状态机（StateMachine）。Spring状态机可以帮助我们开发者简化状态控制的开发过程，让状态机结构更加层次化。下面用Spring状态机模拟一个订单状态流转的过程。

3.1 环境准备

首先，如果要使用spring状态机，需要引入对应的jar包，这里我的springboot版本是：2.2.1.RELEASE

1<dependency>
2    <groupId>org.springframework.statemachine</groupId>
3    <artifactId>spring-statemachine-core</artifactId>
4    <version>${springboot.version}</version>
5</dependency>
6

下面是简化的订单的定义，以及订单状态和订单转换行为的枚举

1/**
2 * @description: 模拟订单类
3 */
4@Data
5public class Order {
6    private Long orderId;
7    private OrderStatusEnum orderStatus;
8}
9
10/**
11 * @description: 订单状态
12 */
13public enum OrderStatusEnum {
14    // 待支付
15    WAIT_PAYMENT,
16    // 待发货
17    WAIT_DELIVER,
18    // 待收货
19    WAIT_RECEIVE,
20    // 完成
21    FINISH;
22}
23
24/**
25 * @description:订单状态转换行为
26 */
27public enum OrderStatusChangeEventEnum {
28    //支付
29    PAYED,
30    //发货
31    DELIVERY,
32    //收货
33    RECEIVED;
34}
35

3.2 构造订单状态机

在引入jar包之后，需要构建一个针对订单状态流转的状态机

订单状态机配置类如下：

1/**
2 * @description: 订单状态机
3 */
4@Configuration
5@EnableStateMachine
6public class OrderStatusMachineConfig extends StateMachineConfigurerAdapter<OrderStatusEnum, OrderStatusChangeEventEnum> {
7
8    /**
9     * 配置状态
10     */
11    @Override
12    public void configure(StateMachineStateConfigurer<OrderStatusEnum, OrderStatusChangeEventEnum> states) throws Exception {
13        states.withStates()
14                .initial(OrderStatusEnum.WAIT_PAYMENT)
15                .end(OrderStatusEnum.FINISH)
16                .states(EnumSet.allOf(OrderStatusEnum.class));
17    }
18
19    /**
20     * 配置状态转换事件关系
21     */
22    @Override
23    public void configure(StateMachineTransitionConfigurer<OrderStatusEnum, OrderStatusChangeEventEnum> transitions) throws Exception {
24        transitions.withExternal().source(OrderStatusEnum.WAIT_PAYMENT).target(OrderStatusEnum.WAIT_DELIVER)
25                .event(OrderStatusChangeEventEnum.PAYED)
26                .and()
27                .withExternal().source(OrderStatusEnum.WAIT_DELIVER).target(OrderStatusEnum.WAIT_RECEIVE)
28                .event(OrderStatusChangeEventEnum.DELIVERY)
29                .and()
30                .withExternal().source(OrderStatusEnum.WAIT_RECEIVE).target(OrderStatusEnum.FINISH)
31                .event(OrderStatusChangeEventEnum.RECEIVED);
32    }
33}
34

3.3 编写状态机监听器

监听状态变更事件，完成状态转换。

1/**
2 * @description: 状态监听
3 */
4@Component
5@WithStateMachine
6@Transactional
7public class OrderStatusListener {
8    @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
9    public boolean payTransition(Message message) {
10        Order order = (Order) message.getHeaders().get("order");
11        order.setOrderStatus(OrderStatusEnum.WAIT_DELIVER);
12        System.out.println("支付，状态机反馈信息：" + message.getHeaders().toString());
13        return true;
14    }
15
16    @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
17    public boolean deliverTransition(Message message) {
18        Order order = (Order) message.getHeaders().get("order");
19        order.setOrderStatus(OrderStatusEnum.WAIT_RECEIVE);
20        System.out.println("发货，状态机反馈信息：" + message.getHeaders().toString());
21        return true;
22    }
23
24    @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
25    public boolean receiveTransition(Message message) {
26        Order order = (Order) message.getHeaders().get("order");
27        order.setOrderStatus(OrderStatusEnum.FINISH);
28        System.out.println("收货，状态机反馈信息：" + message.getHeaders().toString());
29        return true;
30    }
31
32}
33

3.4 编写订单服务类

模拟对订单的一些业务操作

1/**
2 * @description: 订单服务
3 */
4@Service
5public class OrderServiceImpl implements OrderService {
6
7    @Resource
8    private StateMachine<OrderStatusEnum, OrderStatusChangeEventEnum> orderStateMachine;
9
10    private long id = 1L;
11
12    private Map<Long, Order> orders = Maps.newConcurrentMap();
13
14    @Override
15    public Order create() {
16        Order order = new Order();
17        order.setOrderStatus(OrderStatusEnum.WAIT_PAYMENT);
18        order.setOrderId(id++);
19        orders.put(order.getOrderId(), order);
20        System.out.println("订单创建成功:" + order.toString());
21        return order;
22    }
23
24    @Override
25    public Order pay(long id) {
26        Order order = orders.get(id);
27        System.out.println("尝试支付，订单号：" + id);
28        Message message = MessageBuilder.withPayload(OrderStatusChangeEventEnum.PAYED).
29                setHeader("order", order).build();
30        if (!sendEvent(message)) {
31            System.out.println(" 支付失败, 状态异常，订单号：" + id);
32        }
33        return orders.get(id);
34    }
35
36    @Override
37    public Order deliver(long id) {
38        Order order = orders.get(id);
39        System.out.println(" 尝试发货，订单号：" + id);
40        if (!sendEvent(MessageBuilder.withPayload(OrderStatusChangeEventEnum.DELIVERY)
41                .setHeader("order", order).build())) {
42            System.out.println(" 发货失败，状态异常，订单号：" + id);
43        }
44        return orders.get(id);
45    }
46
47    @Override
48    public Order receive(long id) {
49        Order order = orders.get(id);
50        System.out.println(" 尝试收货，订单号：" + id);
51        if (!sendEvent(MessageBuilder.withPayload(OrderStatusChangeEventEnum.RECEIVED)
52                .setHeader("order", order).build())) {
53            System.out.println(" 收货失败，状态异常，订单号：" + id);
54        }
55        return orders.get(id);
56    }
57
58
59    @Override
60    public Map<Long, Order> getOrders() {
61        return orders;
62    }
63
64    /**
65     * 发送状态转换事件
66     * @param message
67     * @return
68     */
69    private synchronized boolean sendEvent(Message<OrderStatusChangeEventEnum> message) {
70        boolean result = false;
71        try {
72            orderStateMachine.start();
73            result = orderStateMachine.sendEvent(message);
74        } catch (Exception e) {
75            e.printStackTrace();
76        } finally {
77            if (Objects.nonNull(message)) {
78                Order order = (Order) message.getHeaders().get("order");
79                if (Objects.nonNull(order) && Objects.equals(order.getOrderStatus(), OrderStatusEnum.FINISH)) {
80                    orderStateMachine.stop();
81                }
82            }
83        }
84        return result;
85    }
86}
87

3.5 测试入口

这里编写一个controller模拟c端用户请求，为了便于展示，这里使用一个测试方法完成所有的操作

1@RestController
2public class OrderController {
3
4    @Resource
5    private OrderService orderService;
6
7    @RequestMapping("/testOrderStatusChange")
8    public String testOrderStatusChange(){
9        orderService.create();
10        orderService.create();
11        orderService.pay(1L);
12        orderService.deliver(1L);
13        orderService.receive(1L);
14        orderService.pay(2L);
15        orderService.deliver(2L);
16        orderService.receive(2L);
17        System.out.println("全部订单状态：" + orderService.getOrders());
18        return "success";
19    }
20
21}
22

下面是对应的执行结果

可以看到spring状态机很好的控制了订单在各个状态之间的流转。

4. 思考与总结

思考：针对状态机的特点，还有其他思路实现一个状态机吗？下面是一些常规思路，如果还有其他方法欢迎在评论区留言。

1. 消息队列方式

订单状态的流转可以通过MQ发布一个事件，消费者根据业务条件把订单状态进行流转，可以根据不同的事件发送到不同的Topic。

2. 定时任务驱动

每隔一段时间启动一下job，根据特定的状态从数据库中拿对应的订单记录，然后判断订单是否有条件到达下一个状态。

3. 规则引擎方式

业务团队可以在规则引擎里编写一系列的状态及其对应的转换规则，由规则引擎根据已经加载的规则对输入数据进行解析，根据解析的结果执行相应的动作，完成状态流转。

总结：

本文主要介绍了设计模式中的状态模式，并在此基础上介绍了Spring状态机相关的概念，并根据常见的订单流转场景，介绍了Spring状态机的使用方式。文中如有不当之处，欢迎在评论区批评指正。

5. 参考内容

https://docs.spring.io/spring-statemachine/docs/4.0.0/reference/index.html#statemachine-config-states

https://cloud.tencent.com/developer/article/2198477?areaId=106001

https://cloud.tencent.com/developer/article/2360708?areaId=106001

https://juejin.cn/post/7087064901553750030

https://my.oschina.net/u/4090830/blog/10092135

https://juejin.cn/post/7267506576448929811

作者：京东科技 孙扬威

来源：京东云开发者社区 转载请注明来源

点赞
收藏

评论区

加载中...

相关推荐

EA&UML日拱一卒

点击上方【面向对象思考】可快速关注本公众号！行为状态机概念以下内容摘自UML2，今天的内容是说明状态机具有上下文类目的情况。行为状态机可以用于定义下面的场景（不限于）主动类的类目行为一个行为化类目的除了类目行为以外的拥有行为。如果状态机有某种行为类目

UDT协议实现分析——UDT初始化和销毁

UDT协议是一个用于在高速Internet上传输大量数据的基于UDP的可靠传输协议。我们可以将UDT协议的实现看作一个比较复杂的状态机。更准确的说，是一个主状态机，外加多个子状态机。主状态机是指协议实现中全局唯一、全局共享的状态与数据结构，主要对应于CUDTUnited类。子状态机则是对于一次UDT连接或一个Listening的UDTServer的抽象

FPGA 高手养成记

来源：公众号【ZYNQ】ID  ：FreeZynq整理：李肖遥本文目录1.前言2.状态机简介3.状态机分类Mealy型状态机Moore型状态机4.状态机描述一段式状态机二段式状态机三段式状态机

Java描述设计模式(21)：状态模式

本文源码：GitHub·点这里(https://www.oschina.net/action/GoToLink?urlhttps%3A%2F%2Fgithub.com%2Fcicadasmile%2Fmodelarithmeticparent)||GitEE·点这里(https://gitee.com/cicadasmile/modela

C语言中的状态机设计

本文不是关于软件状态机的最佳设计分解实践的教程。我将重点关注状态机代码和简单的示例，这些示例具有足够的复杂性，以便于理解特性和用法。背景大多数程序员常用的设计技术是有限状态机(FSM)。设计人员使用此编程结构将复杂的问题分解为可管理的状态和状态转换。有无数种实现状态机的方法。A switch语句提供了状态机最容易实现和最常见的版本之一。

Java设计模式之状态模式详解

(本文由言念小文原创，转载请注明出处)在实际工作中经常遇到某个对象，处于不同的状态有不同行为逻辑、且状态之间可以相互迁移的业务场景，特别是在开发通信协议栈类软件中尤为多见。《设计模式之禅》这本书中对状态模式有着非常详尽的讲解（目前为止我认为讲解得最好的书），但总觉得自己没能够理解透彻、灵活运用。直到今年完成了一个通信协议软件的开发，重新研究了“状态机”，