碼上歡樂
相關內容    簡體    繁體

使用狀態機（Spring Statemachine）實現訂單狀態流轉控制

本文轉載自   查看原文   2021-09-07 15:59   574    Spring

在電商平台中，一個訂單會有多種狀態，臨時單、已下單、待支付、已支付、待發貨、待收貨、已完成等等。每一種狀態都和變化前的狀態以及執行的操作有關。

比如，用戶將商品加入購物車后，后台會生成一個所謂的“臨時單”。因為用戶還沒有點擊下單，所以這個訂單實際上還沒有生成。只有當用戶下單后，這個“臨時單”才會轉化為一個“待支付的訂單”。

以上過程中只有將一個處於“臨時單”狀態的訂單執行下單操作，才能得到一個狀態為“待支付”的訂單。 即一個前置狀態+一個恰當的操作，才能流轉訂單的狀態。在這個過程中如果使用硬編碼，我們就需要一系列的 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


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 使用Spring StateMachine框架實現狀態機 Spring StateMachine狀態機 無狀態狀態機--cola stateMachine 有限狀態機 Spring StateMachine框架 Android狀態機StateMachine使用舉例及源碼解析 android狀態機機制StateMachine spring 狀態機 Spring Boot 揭秘與實戰（七） 實用技術篇 - StateMachine 狀態機機制 Spring Boot 揭秘與實戰（七） 實用技術篇 - StateMachine 狀態機機制 徹底搞懂Spring狀態機原理，實現訂單與物流解耦
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM