使用状态机（Spring Statemachine）实现订单状态流转控制

在电商平台中，一个订单会有多种状态，临时单、已下单、待支付、已支付、待发货、待收货、已完成等等。每一种状态都和变化前的状态以及执行的操作有关。

比如，用户将商品加入购物车后，后台会生成一个所谓的“临时单”。因为用户还没有点击下单，所以这个订单实际上还没有生成。只有当用户下单后，这个“临时单”才会转化为一个“待支付的订单”。

以上过程中只有将一个处于“临时单”状态的订单执行下单操作，才能得到一个状态为“待支付”的订单。 即一个前置状态+一个恰当的操作，才能流转订单的状态。在这个过程中如果使用硬编码，我们就需要一系列的 if-else 语句来检查订单的当前状态、可执行操作以及这两个组合得到的下一个应该被流转的状态值。如果订单的状态流转很复杂，代码逻辑就会很复杂，可读性低，后期维护困难。

处理以上问题，我们可以使用状态设计模式来处理。对应到实践，就是状态机。

状态机是状态模式的一种应用，相当于上下文角色的一个升级版。在工作流或游戏等各种系统中有大量使用，如各种工作流引擎，它几乎是状态机的子集和实现，封装状态的变化规则。状态机可以帮助开发者简化状态控制的开发过程，让状态机结构更加层次化。

Spring 提供了一个很好的解决方案，Spring Statemachine（状态机）是应用程序开发人员在 Spring 应用程序中使用状态机概念的框架。

下面用 Spring 状态机模拟订单状态流转的过程，步骤如下。

1）添加依赖

1. <dependency>
2. <groupId>org.springframework.statemachine</groupId>
3. <artifactId>spring-statemachine-core</artifactId>
4. <version>2.0.1.RELEASE</version>
5. </dependency>

2）创建订单实体类

1. package net.biancheng.c.entity;
2. public class Order {
3. private int id;
4. private OrderStatus status;
6. public void setStatus(OrderStatus status) {
7. this.status = status;
8. }
10. public OrderStatus getStatus() {
11. return status;
12. }
14. public void setId(int id) {
15. this.id = id;
16. }
18. public int getId() {
19. return id;
20. }
22. @Override
23. public String toString() {
24. return "订单号：" + id + ", 订单状态：" + status;
25. }
26. }

3）创建订单状态枚举类和状态转换枚举类。

1. package net.biancheng.c.utils;
2. /**
3. * 订单状态
4. */
5. public enum OrderStatus {
6. // 待支付，待发货，待收货，已完成
7. WAIT_PAYMENT, WAIT_DELIVER, WAIT_RECEIVE, FINISH;
8. }
10. package net.biancheng.c.utils;
11. /**
12. * 订单状态改变事件
13. */
14. public enum OrderStatusChangeEvent {
15. // 支付，发货，确认收货
16. PAYED, DELIVERY, RECEIVED;
17. }

4）添加状态流配置

1. package net.biancheng.c.utils;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.Configuration;
5. import org.springframework.statemachine.StateMachineContext;
6. import org.springframework.statemachine.StateMachinePersist;
7. import org.springframework.statemachine.config.EnableStateMachine;
8. import org.springframework.statemachine.config.StateMachineConfigurerAdapter;
9. import org.springframework.statemachine.config.builders.StateMachineStateConfigurer;
10. import org.springframework.statemachine.config.builders.StateMachineTransitionConfigurer;
11. import org.springframework.statemachine.persist.DefaultStateMachinePersister;
12. import org.springframework.statemachine.support.DefaultStateMachineContext;
14. import java.util.EnumSet;
16. /**
17. * 订单状态机配置
18. */
19. @Configuration
20. @EnableStateMachine(name = "orderStateMachine")
21. public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStatus, OrderStatusChangeEvent> {
23. /**
24. * 配置状态
25. *
26. * @param states
27. * @throws Exception
28. */
29. public void configure(StateMachineStateConfigurer<OrderStatus, OrderStatusChangeEvent> states) throws Exception {
30. states
31. .withStates()
32. .initial(OrderStatus.WAIT_PAYMENT)
33. .states(EnumSet.allOf(OrderStatus.class));
34. }
36. /**
37. * 配置状态转换事件关系
38. *
39. * @param transitions
40. * @throws Exception
41. */
42. public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderStatusChangeEvent> transitions) throws Exception {
43. transitions
44. .withExternal().source(OrderStatus.WAIT_PAYMENT).target(OrderStatus.WAIT_DELIVER).event(OrderStatusChangeEvent.PAYED)
45. .and()
46. .withExternal().source(OrderStatus.WAIT_DELIVER).target(OrderStatus.WAIT_RECEIVE).event(OrderStatusChangeEvent.DELIVERY)
47. .and()
48. .withExternal().source(OrderStatus.WAIT_RECEIVE).target(OrderStatus.FINISH).event(OrderStatusChangeEvent.RECEIVED);
49. }
51. /**
52. * 持久化配置
53. * 实际使用中，可以配合redis等，进行持久化操作
54. *
55. * @return
56. */
57. @Bean
58. public DefaultStateMachinePersister persister() {
59. return new DefaultStateMachinePersister<>(new StateMachinePersist<Object, Object, Order>() {
60. @Override
61. public void write(StateMachineContext<Object, Object> context, Order order) throws Exception {
62. //此处并没有进行持久化操作
63. }
65. @Override
66. public StateMachineContext<Object, Object> read(Order order) throws Exception {
67. //此处直接获取order中的状态，其实并没有进行持久化读取操作
68. return new DefaultStateMachineContext(order.getStatus(), null, null, null);
69. }
70. });
71. }
72. }

5）添加订单状态监听器

1. package net.biancheng.c.utils;
3. import org.springframework.messaging.Message;
4. import org.springframework.statemachine.annotation.OnTransition;
5. import org.springframework.statemachine.annotation.WithStateMachine;
6. import org.springframework.stereotype.Component;
8. @Component("orderStateListener")
9. @WithStateMachine(name = "orderStateMachine")
10. public class OrderStateListenerImpl {
12. @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
13. public boolean payTransition(Message<OrderStatusChangeEvent> message) {
14. Order order = (Order) message.getHeaders().get("order");
15. order.setStatus(OrderStatus.WAIT_DELIVER);
16. System.out.println("支付，状态机反馈信息：" + message.getHeaders().toString());
17. return true;
18. }
20. @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
21. public boolean deliverTransition(Message<OrderStatusChangeEvent> message) {
22. Order order = (Order) message.getHeaders().get("order");
23. order.setStatus(OrderStatus.WAIT_RECEIVE);
24. System.out.println("发货，状态机反馈信息：" + message.getHeaders().toString());
25. return true;
26. }
28. @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
29. public boolean receiveTransition(Message<OrderStatusChangeEvent> message) {
30. Order order = (Order) message.getHeaders().get("order");
31. order.setStatus(OrderStatus.FINISH);
32. System.out.println("收货，状态机反馈信息：" + message.getHeaders().toString());
33. return true;
34. }
35. }

6）创建 OrderService 接口。

1. package net.biancheng.c.service;
3. import net.biancheng.c.entity.Order;
4. import java.util.Map;
6. public interface OrderService {
7. //创建订单
8. Order create();
10. //发起支付
11. Order pay(int id);
13. //订单发货
14. Order deliver(int id);
16. //订单收货
17. Order receive(int id);
19. //获取所有订单信息
20. Map<Integer, Order> getOrders();
21. }

7）在 Service 业务逻辑中应用。

1. package net.biancheng.c.serviceImpl;
3. import net.biancheng.c.entity.Order;
4. import net.biancheng.c.service.OrderService;
5. import net.biancheng.c.utils.OrderStatus;
6. import net.biancheng.c.utils.OrderStatusChangeEvent;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.messaging.Message;
9. import org.springframework.messaging.support.MessageBuilder;
10. import org.springframework.statemachine.StateMachine;
11. import org.springframework.statemachine.persist.StateMachinePersister;
12. import org.springframework.stereotype.Service;
14. import java.util.HashMap;
15. import java.util.Map;
17. @Service("orderService")
18. public class OrderServiceImpl implements OrderService {
20. @Autowired
21. private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;
23. @Autowired
24. private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, Order> persister;
26. private int id = 1;
27. private Map<Integer, Order> orders = new HashMap<>();
29. public Order create() {
30. Order order = new Order();
31. order.setStatus(OrderStatus.WAIT_PAYMENT);
32. order.setId(id++);
33. orders.put(order.getId(), order);
34. return order;
35. }
37. public Order pay(int id) {
38. Order order = orders.get(id);
39. System.out.println("线程名称：" + Thread.currentThread().getName() + " 尝试支付，订单号：" + id);
40. Message message = MessageBuilder.withPayload(OrderStatusChangeEvent.PAYED).setHeader("order", order).build();
41. if (!sendEvent(message, order)) {
42. System.out.println("线程名称：" + Thread.currentThread().getName() + " 支付失败, 状态异常，订单号：" + id);
43. }
44. return orders.get(id);
45. }
47. public Order deliver(int id) {
48. Order order = orders.get(id);
49. System.out.println("线程名称：" + Thread.currentThread().getName() + " 尝试发货，订单号：" + id);
50. if (!sendEvent(MessageBuilder.withPayload(OrderStatusChangeEvent.DELIVERY).setHeader("order", order).build(), orders.get(id))) {
51. System.out.println("线程名称：" + Thread.currentThread().getName() + " 发货失败，状态异常，订单号：" + id);
52. }
53. return orders.get(id);
54. }
56. public Order receive(int id) {
57. Order order = orders.get(id);
58. System.out.println("线程名称：" + Thread.currentThread().getName() + " 尝试收货，订单号：" + id);
59. if (!sendEvent(MessageBuilder.withPayload(OrderStatusChangeEvent.RECEIVED).setHeader("order", order).build(), orders.get(id))) {
60. System.out.println("线程名称：" + Thread.currentThread().getName() + " 收货失败，状态异常，订单号：" + id);
61. }
62. return orders.get(id);
63. }
65. public Map<Integer, Order> getOrders() {
66. return orders;
67. }
69. /**
70. * 发送订单状态转换事件
71. *
72. * @param message
73. * @param order
74. * @return
75. */
76. private synchronized boolean sendEvent(Message<OrderStatusChangeEvent> message, Order order) {
77. boolean result = false;
78. try {
79. orderStateMachine.start();
80. //尝试恢复状态机状态
81. persister.restore(orderStateMachine, order);
82. //添加延迟用于线程安全测试
83. Thread.sleep(1000);
84. result = orderStateMachine.sendEvent(message);
85. //持久化状态机状态
86. persister.persist(orderStateMachine, order);
87. } catch (Exception e) {
88. e.printStackTrace();
89. } finally {
90. orderStateMachine.stop();
91. }
92. return result;
93. }
94. }

8）编写客户端测试代码。

1. import net.biancheng.c.service.OrderService;
2. import org.springframework.boot.SpringApplication;
3. import org.springframework.boot.autoconfigure.SpringBootApplication;
4. import org.springframework.context.ConfigurableApplicationContext;
6. @SpringBootApplication
7. public class Test {
8. public static void main(String[] args) {
9. Thread.currentThread().setName("主线程");
10. ConfigurableApplicationContext context = SpringApplication.run(Test.class, args);
11. OrderService orderService = (OrderService) context.getBean("orderService");
12. orderService.create();
13. orderService.create();
14. orderService.pay(1);
15. new Thread("客户线程") {
16. @Override
17. public void run() {
18. orderService.deliver(1);
19. orderService.receive(1);
20. }
21. }.start();
23. orderService.pay(2);
24. orderService.deliver(2);
25. orderService.receive(2);
27. System.out.println("全部订单状态：" + orderService.getOrders());
28. }
29. }

运行结果如下。

...
线程名称：主线程 尝试支付，订单号：2
线程名称：客户线程 尝试发货，订单号：1
2020-11-10 09:42:59.528  INFO 10796 --- [            主线程] o.s.s.support.LifecycleObjectSupport     : started org.springframework.statemachine.support.DefaultStateMachineExecutor@eb507b9
2020-11-10 09:42:59.528  INFO 10796 --- [            主线程] o.s.s.support.LifecycleObjectSupport     : started FINISH WAIT_PAYMENT WAIT_RECEIVE WAIT_DELIVER  / WAIT_PAYMENT / uuid=5aa411ad-212a-4f2a-8afd-fc1009def5d5 / id=null
2020-11-10 09:42:59.528  INFO 10796 --- [            主线程] o.s.s.support.LifecycleObjectSupport     : stopped org.springframework.statemachine.support.DefaultStateMachineExecutor@eb507b9
2020-11-10 09:42:59.528  INFO 10796 --- [            主线程] o.s.s.support.LifecycleObjectSupport     : stopped FINISH WAIT_PAYMENT WAIT_RECEIVE WAIT_DELIVER  /  / uuid=5aa411ad-212a-4f2a-8afd-fc1009def5d5 / id=null
2020-11-10 09:42:59.528  INFO 10796 --- [            主线程] o.s.s.support.LifecycleObjectSupport     : started org.springframework.statemachine.support.DefaultStateMachineExecutor@eb507b9
2020-11-10 09:42:59.528  INFO 10796 --- [            主线程] o.s.s.support.LifecycleObjectSupport     : started FINISH WAIT_PAYMENT WAIT_RECEIVE WAIT_DELIVER  / WAIT_PAYMENT / uuid=5aa411ad-212a-4f2a-8afd-fc1009def5d5 / id=null
支付，状态机反馈信息：{order=订单号：2, 订单状态：WAIT_DELIVER, id=13bd1f00-21e1-cab4-3b2a-af8a4a82507a, timestamp=1604972579527}
...

由于运行结果篇幅过长，以上只贴出了部分运行结果。通过本节的真实业务案例，相信小伙伴们对状态模式已经有非常深刻的理解了

 

转载自 http://c.biancheng.net/view/8492.html