禅与计算机
sharkchili
2024-09-10
目录

来聊聊一个轻量级的有限状态机Cola-StateMachine

# 写在文章开头

简单研究了一下研究了一下市面上的几个状态机框架，包括但不限制于Spring Statemachine以及Cola-StateMachine，考虑到前者上下文会记录当前状态机的相关属性(当前状态信息、上一次状态)，对此我们就必须要通过工厂模式等方式规避这些问题，很明显这种方案对于高并发场景下非常不友好。

于是笔者选用了更加轻量级的无状态状态机框架Cola-StateMachine，而本文将用常见的下单流程演示一下Cola-StateMachine的基本使用，希望对你有帮助。

Hi，我是 sharkChili ，是个不断在硬核技术上作死的技术人，是 CSDN的博客专家 ，也是开源项目 Java Guide 的维护者之一，熟悉 Java 也会一点 Go ，偶尔也会在 C源码 边缘徘徊。写过很多有意思的技术博客，也还在研究并输出技术的路上，希望我的文章对你有帮助，非常欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 状态机基本概念扫盲

状态机通俗来说就是有限状态机(Finite-state machine,FSM)，我们可以将其理解为一个数学模型，有限状态以及这些转台之间转移和动作行为的抽象的数学模型。

我们以一个简单的开关灯为例子简单介绍一下状态机的基本概念，当我们点击开时电灯就会亮起状态就是open，按照状态机的几个核心概念：

  1. 当我们准备按下开关时，这个准备按下开关也就是需要执行的指令，也就是事件event。
  2. 实际按下开关的执行动作也就是状态机中的动作(action)。
  3. open就是状态机中的状态(state)。
  4. 电灯由暗变亮，这个就是所谓transition也就是状态的转换，这就是状态机的最后一个概念。

# 基于Cola-StateMachine落地下单业务

# 业务流程说明

现在我们就以一个订单为例子介绍一下状态机的进阶使用，如下图：

  1. 初始状态下订单状态为待支付。
  2. 用户点击付款之后会触发已付款事件。
  3. 此时订单的状态就会变为代发货。
  4. 商家完成发货之后触发已发货事件，此时订单变为待收货。
  5. 最终，买家收获之后触发已收货事件，订单变为终态已完成。

# 状态机落地

基于上述需求我们进行代码落地，首先定义订单状态枚举，代码如下所示，该枚举将交由后续状态机进行状态扭转的和事件的映射配置：

public enum OrderStatusEnum {
    WAIT_PAYMENT(0, "待支付"),
    WAIT_DELIVER(1, "待发货"),
    WAIT_RECEIVE(2, "待收货"),
    FINISH(3, "完成");

    private int code;
    private String description;

    OrderStatusEnum(int code, String description) {
        this.code = code;
        this.description = description;
    }
	//get set......

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

然后就是事件枚举，如上图所说，笔者分别定义了买家已支付事件、商家已发货事件和买家已收货的3个事件枚举：

public enum OrderEventEnum {

    PAYED(0,"已支付"),
    DELIVERY(1,"已发货"),
    RECEIVED(2,"已收货");

    private int code;
    private String description;

    OrderEventEnum(int code, String description) {
        this.code = code;
        this.description = description;
    }
	//get set ......
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

为了简洁且方便的演示实际业务持久化的场景，笔者通过一个ConcurrentHashMap模拟数据库存储：

@Component
public class OrderMapper {
    private Map<Long, Order> orders = new ConcurrentHashMap<>();

    public void put(Long id, Order order) {
        orders.put(id, order);
    }

    public Order get(Long id) {
        return orders.get(id);
    }

    public Map<Long, Order> getOrders() {
        return orders;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

重点来了，接下来就是订单状态扭转和事件的绑定，这里笔者简单说明一下，Cola-StateMachine进行配置初始化时，是通过内置的StateMachineBuilderFactory进行创建。

我们指明状态和事件类型为上文所述的OrderStatusEnum和OrderEventEnum，以及实际操作的对象是订单类order，通过externalTransition进行对应状态扭转和事件配置。

我们以第一条配置为例，当我们触发PAYED即买家已支付事件时，状态会从WAIT_PAYMENT待支付变为待发货WAIT_DELIVER，同时为了明确我们的订单是否是由待支付变为代发货，笔者通过when函数校验一下对订单状态进行了一下校验。

明确之后状态源状态是待支付之后，这条配置执行perform的动作(Action)，即将订单状态改为待发货，然后将订单最新的状态持久化入库。

而其他配置同理，读者可参考注释自行了解：

@Component
public class OrderStatusMachineConfig {

    @Autowired
    private OrderMapper orderMapper;

    @Bean
    public StateMachine stateMachine() {
        StateMachineBuilder<OrderStatusEnum, OrderEventEnum, Order> builder = StateMachineBuilderFactory.create();
        builder.externalTransition()
                .from(OrderStatusEnum.WAIT_PAYMENT)//从待支付
                .to(OrderStatusEnum.WAIT_DELIVER)//变为待发货
                .on(OrderEventEnum.PAYED)//需要通过支付事件
                .when(o -> o.getOrderStatus().equals(OrderStatusEnum.WAIT_PAYMENT))//判断条件为传入的订单是待支付的
                .perform((f, t, e, o) -> {
                    System.out.println("将" + JSONUtil.toJsonStr(o) + " 由状态 " + f.getDescription() + " 变为 " + t.getDescription());
                    //上述要求符合后执行将状态修改为代发货，并持久化
                    o.setOrderStatus(OrderStatusEnum.WAIT_DELIVER);
                    orderMapper.put(o.getOrderId(), o);
                });


        builder.externalTransition()
                .from(OrderStatusEnum.WAIT_DELIVER)//从待发货
                .to(OrderStatusEnum.WAIT_RECEIVE)//变为待收获
                .on(OrderEventEnum.DELIVERY)//通过发货事件
                .when(o -> true)//没有需要考虑的条件
                .perform((f, t, e, o) -> {//修改订单状态并持久化入库
                    o.setOrderStatus(OrderStatusEnum.WAIT_RECEIVE);
                    orderMapper.put(o.getOrderId(), o);
                    System.out.println("将" + JSONUtil.toJsonStr(o) + " 由状态 " + f.getDescription() + " 变为 " + t.getDescription());
                });

        builder.externalTransition()
                .from(OrderStatusEnum.WAIT_RECEIVE)//从待收货
                .to(OrderStatusEnum.FINISH)//到已完成
                .on(OrderEventEnum.RECEIVED)//通过收获事件触发
                .when(o -> true)//无需任何条件校验
                .perform((f, t, e, o) -> {
                    //修改状态并持久化
                    o.setOrderStatus(OrderStatusEnum.FINISH);
                    orderMapper.put(o.getOrderId(), o);
                    System.out.println("将" + JSONUtil.toJsonStr(o) + " 由状态 " + f.getDescription() + " 变为 " + t.getDescription());
                });

        return builder.build("orderStateMachine");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

完成上述配置后，我们就可以在业务代码上使用这套状态机了，我们在开发买家支付方法时，只需将状态机注入，然后调用状态机的fireEvent方法，传入订单的源状态、事件枚举、订单信息，让状态机根据我们的状态和事件进行判断，并完成状态修改和持久化：

对应代码如下，读者参考注释阅读：

@Service
public class OrderService {

    @Autowired
    StateMachine<OrderStatusEnum, OrderEventEnum, Order> stateMachine;

    private AtomicLong id = new AtomicLong(0);
    @Autowired
    private OrderMapper orderMapper;


    public Order create() {
        //创建订单
        Order order = new Order();
        //初始化状态为待支付
        order.setOrderStatus(OrderStatusEnum.WAIT_PAYMENT);
        //分配id
        order.setOrderId(id.incrementAndGet());
        orderMapper.put(order.getOrderId(), order);

        System.out.println("订单创建成功:" + JSONUtil.toJsonStr(order));

        return order;
    }


    public void pay(long id) {
        //查询订单
        Order order = orderMapper.get(id);
        System.out.println("准备下单，订单号:" + id);
        //生成事件消息，希望将订单状态改为已支付，并存入当前订单数据
        stateMachine.fireEvent(order.getOrderStatus(), OrderEventEnum.PAYED, order);

    }


    public void deliver(long id) {
        Order order = orderMapper.get(id);
        System.out.println("准备给订单发货，订单号:" + id);
        //传入订单，并触发发货事件，成功后订单状态会改为待收货
        stateMachine.fireEvent(order.getOrderStatus(), OrderEventEnum.DELIVERY, order);
    }


    public void receive(long id) {
        Order order = orderMapper.get(id);
        System.out.println("尝试收货，订单号：" + id);
        //传入订单，并触发收货事件，将订单修改为已完成
        stateMachine.fireEvent(order.getOrderStatus(), OrderEventEnum.RECEIVED, order);
    }

    public Map<Long, Order> getOrders() {
        return orderMapper.getOrders();
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# 最终效果演示

最后我们给出并发的测试用例：

CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(() -> {
            orderService.create();
            orderService.pay(1L);
            orderService.deliver(1L);
            orderService.receive(1L);
            countDownLatch.countDown();
        }).start();


        new Thread(() -> {
            orderService.create();
            orderService.pay(2L);
            orderService.deliver(2L);
            orderService.receive(2L);
            countDownLatch.countDown();
        }).start();
        countDownLatch.await();

        System.out.println("订单处理完成:" + JSONUtil.toJsonStr(orderService.getOrders()));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

可以看到订单都完成了：

订单创建成功:{"orderId":1,"orderStatus":"WAIT_PAYMENT"}
订单创建成功:{"orderId":2,"orderStatus":"WAIT_PAYMENT"}
准备下单，订单号:1
准备下单，订单号:2
将{"orderId":1,"orderStatus":"WAIT_PAYMENT"} 由状态 待支付 变为 待发货
将{"orderId":2,"orderStatus":"WAIT_PAYMENT"} 由状态 待支付 变为 待发货
准备给订单发货，订单号:1
准备给订单发货，订单号:2
将{"orderId":1,"orderStatus":"WAIT_RECEIVE"} 由状态 待发货 变为 待收货
将{"orderId":2,"orderStatus":"WAIT_RECEIVE"} 由状态 待发货 变为 待收货
尝试收货，订单号：2
尝试收货，订单号：1
将{"orderId":2,"orderStatus":"FINISH"} 由状态 待收货 变为 完成
将{"orderId":1,"orderStatus":"FINISH"} 由状态 待收货 变为 完成
订单处理完成:{"1":{"orderId":1,"orderStatus":"FINISH"},"2":{"orderId":2,"orderStatus":"FINISH"}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 小结

自此我们通过Cola-StateMachine完成一个简单的案例快速入门了状态机的使用，希望对你有帮助。

我是 sharkchili ，CSDN Java 领域博客专家，mini-redis的作者，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 参考

什么是状态机（Finite-state machine）:https://blog.csdn.net/JMW1407/article/details/108458569 (opens new window) Spring Statemachine 简介 :https://blog.csdn.net/qq_22076345/article/details/109266901 (opens new window) 聊聊Cola-StateMachine轻量级状态机的实现 :https://www.cnblogs.com/zhiyong-ITNote/p/17462747.html (opens new window)

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
安利一个轻量级流程引擎compileflow

←

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×