項目終於用上了 Spring 狀態機,非常優雅!

来源:https://www.cnblogs.com/javastack/archive/2023/05/25/17432557.html
-Advertisement-
Play Games

來源:https://www.duidaima.com/Group/Topic/JAVA/11942 ## **1、什麼是狀態機** ### 1.1 什麼是狀態 先來解釋什麼是“狀態”( State )。現實事物是有不同狀態的,例如一個自動門,就有 open 和 closed 兩種狀態。我們通常所說 ...


來源:https://www.duidaima.com/Group/Topic/JAVA/11942

1、什麼是狀態機

1.1 什麼是狀態

先來解釋什麼是“狀態”( State )。現實事物是有不同狀態的,例如一個自動門,就有 open 和 closed 兩種狀態。我們通常所說的狀態機是有限狀態機,也就是被描述的事物的狀態的數量是有限個,例如自動門的狀態就是兩個 open 和 closed 。

狀態機,也就是 State Machine ,不是指一臺實際機器,而是指一個數學模型。說白了,一般就是指一張狀態轉換圖。例如,根據自動門的運行規則,我們可以抽象出下麵這麼一個圖。

自動門有兩個狀態,open 和 closed ,closed 狀態下,如果讀取開門信號,那麼狀態就會切換為 open 。open 狀態下如果讀取關門信號,狀態就會切換為 closed 。

狀態機的全稱是有限狀態自動機,自動兩個字也是包含重要含義的。給定一個狀態機,同時給定它的當前狀態以及輸入,那麼輸出狀態時可以明確的運算出來的。例如對於自動門,給定初始狀態 closed ,給定輸入“開門”,那麼下一個狀態時可以運算出來的。

這樣狀態機的基本定義我們就介紹完畢了。重覆一下:狀態機是有限狀態自動機的簡稱,是現實事物運行規則抽象而成的一個數學模型。

1.2 四大概念

下麵來給出狀態機的四大概念。

  • 第一個是 State ,狀態。一個狀態機至少要包含兩個狀態。例如上面自動門的例子,有 open 和 closed 兩個狀態。
  • 第二個是 Event ,事件。事件就是執行某個操作的觸發條件或者口令。對於自動門,“按下開門按鈕”就是一個事件。
  • 第三個是 Action ,動作。事件發生以後要執行動作。例如事件是“按開門按鈕”,動作是“開門”。編程的時候,一個 Action一般就對應一個函數。
  • 第四個是 Transition ,變換。也就是從一個狀態變化為另一個狀態。例如“開門過程”就是一個變換。

1.3 狀態機

有限狀態機(Finite-state machine,FSM),又稱有限狀態自動機,簡稱狀態機,是表示有限個狀態以及在這些狀態之間的轉移和動作等行為的數學模型。

FSM是一種演算法思想,簡單而言,有限狀態機由一組狀態、一個初始狀態、輸入和根據輸入及現有狀態轉換為下一個狀態的轉換函數組成。

其作用主要是描述對象在它的生命周期內所經歷的狀態序列,以及如何響應來自外界的各種事件。

推薦一個開源免費的 Spring Boot 實戰項目:

https://github.com/javastacks/spring-boot-best-practice

2、狀態機圖

做需求時,需要瞭解以下六種元素:起始、終止、現態、次態(目標狀態)、動作、條件,我們就可以完成一個狀態機圖了:

以訂單為例:以從待支付狀態轉換為待發貨狀態為例

  • ①現態:是指當前所處的狀態。待支付
  • ②條件:又稱為“事件”,當一個條件被滿足,將會觸發一個動作,或者執行一次狀態的遷移。支付事件
  • ③動作:條件滿足後執行的動作。動作執行完畢後,可以遷移到新的狀態,也可以仍舊保持原狀態。動作不是必需的,當條件滿足後,也可以不執行任何動作,直接遷移到新狀態。狀態轉換為待發貨
  • ④次態:條件滿足後要遷往的新狀態。“次態”是相對於“現態”而言的,“次態”一旦被激活,就轉變成新的“現態”了。待發貨 註意事項

1、避免把某個“程式動作”當作是一種“狀態”來處理。那麼如何區分“動作”和“狀態”?“動作”是不穩定的,即使沒有條件的觸發,“動作”一旦執行完畢就結束了;而“狀態”是相對穩定的,如果沒有外部條件的觸發,一個狀態會一直持續下去。

2、狀態劃分時漏掉一些狀態,導致跳轉邏輯不完整。所以在設計狀態機時,我們需要反覆的查看設計的狀態圖或者狀態表,最終達到一種牢不可破的設計方案。

3、spring statemachine

3.1 狀態機spring statemachine 概述

Spring Statemachine是應用程式開發人員在Spring應用程式中使用狀態機概念的框架

Spring Statemachine旨在提供以下功能:

  1. 易於使用的扁平單級狀態機,用於簡單的使用案例。
  2. 分層狀態機結構,以簡化複雜的狀態配置。
  3. 狀態機區域提供更複雜的狀態配置。
  4. 使用觸發器,轉換,警衛和操作。
  5. 鍵入安全配置適配器。
  6. 生成器模式,用於在Spring Application上下文之外使用的簡單實例化通常用例的食譜
  7. 基於Zookeeper的分散式狀態機
  8. 狀態機事件監聽器。
  9. UML Eclipse Papyrus建模。
  10. 將電腦配置存儲在永久存儲中。
  11. Spring IOC集成將bean與狀態機關聯起來。

狀態機功能強大,因為行為始終保證一致,使調試相對容易。這是因為操作規則是在機器啟動時寫成的。這個想法是你的應用程式可能存在於有限數量的狀態中,某些預定義的觸發器可以將你的應用程式從一個狀態轉移到另一個狀態。此類觸發器可以基於事件或計時器。

在應用程式之外定義高級邏輯然後依靠狀態機來管理狀態要容易得多。您可以通過發送事件,偵聽更改或僅請求當前狀態來與狀態機進行交互。

官網:spring.io/projects/sp…

3.2 快速開始

Spring Boot 基礎就不介紹了,推薦看這個實戰項目:

https://github.com/javastacks/spring-boot-best-practice

以訂單狀態扭轉的例子為例:

表結構設計如下:

CREATE TABLE `tb_order` (
      `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主鍵ID',
      `order_code` varchar(128) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '訂單編碼',
      `status` smallint(3) DEFAULT NULL COMMENT '訂單狀態',
      `name` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '訂單名稱',
      `price` decimal(12,2) DEFAULT NULL COMMENT '價格',
      `delete_flag` tinyint(2) NOT NULL DEFAULT '0' COMMENT '刪除標記,0未刪除  1已刪除',
      `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '創建時間',
      `update_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '更新時間',
      `create_user_code` varchar(32) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '創建人',
      `update_user_code` varchar(32) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '更新人',
      `version` int(11) NOT NULL DEFAULT '0' COMMENT '版本號',
      `remark` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '備註',
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin COMMENT='訂單表';

    /*Data for the table `tb_order` */

    insert  into `tb_order`(`id`,`order_code`,`status`,`name`,`price`,`delete_flag`,`create_time`,`update_time`,`create_user_code`,`update_user_code`,`version`,`remark`) values
    (2,'A111',1,'A','22.00',0,'2022-10-15 16:14:11','2022-10-02 21:29:14','zhangsan','zhangsan',0,NULL),
    (3,'A111',1,'訂單A','22.00',0,'2022-10-02 21:53:13','2022-10-02 21:29:14','zhangsan','zhangsan',0,NULL),
    (4,'A111',1,'訂單A','22.00',0,'2022-10-02 21:53:13','2022-10-02 21:29:14','zhangsan','zhangsan',0,NULL),
    (5,'A111',1,'訂單A','22.00',0,'2022-10-03 09:08:30','2022-10-02 21:29:14','zhangsan','zhangsan',0,NULL);
1)引入依賴
 <!-- redis持久化狀態機 -->
    <dependency>
        <groupId>org.springframework.statemachine</groupId>
        <artifactId>spring-statemachine-redis</artifactId>
        <version>1.2.9.RELEASE</version>
    </dependency>
    <!--狀態機-->
    <dependency>
        <groupId>org.springframework.statemachine</groupId>
        <artifactId>spring-statemachine-starter</artifactId>
        <version>2.0.1.RELEASE</version>
    </dependency>
2)定義狀態機狀態和事件

狀態枚舉:

/**
* 
*/
public enum OrderStatus {
        // 待支付,待發貨,待收貨,已完成
        WAIT_PAYMENT(1, "待支付"),
        WAIT_DELIVER(2, "待發貨"),
        WAIT_RECEIVE(3, "待收貨"),
        FINISH(4, "已完成");
        private Integer key;
        private String desc;
        OrderStatus(Integer key, String desc) {
            this.key = key;
            this.desc = desc;
        }
        public Integer getKey() {
            return key;
        }
        public String getDesc() {
            return desc;
        }
        public static OrderStatus getByKey(Integer key) {
            for (OrderStatus e : values()) {
                if (e.getKey().equals(key)) {
                    return e;
                }
            }
            throw new RuntimeException("enum not exists.");
        }
    }

事件:

/**
* 
*/
public enum OrderStatusChangeEvent {
        // 支付,發貨,確認收貨
        PAYED, DELIVERY, RECEIVED;
}
3)定義狀態機規則和配置狀態機
 @Configuration
    @EnableStateMachine(name = "orderStateMachine")
    public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStatus, OrderStatusChangeEvent> {
        /**
         * 配置狀態
         *
         * @param states
         * @throws Exception
         */
        public void configure(StateMachineStateConfigurer<OrderStatus, OrderStatusChangeEvent> states) throws Exception {
            states
                    .withStates()
                    .initial(OrderStatus.WAIT_PAYMENT)
                    .states(EnumSet.allOf(OrderStatus.class));
        }
        /**
         * 配置狀態轉換事件關係
         *
         * @param transitions
         * @throws Exception
         */
        public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderStatusChangeEvent> transitions) throws Exception {
            transitions
                    //支付事件:待支付-》待發貨
                    .withExternal().source(OrderStatus.WAIT_PAYMENT).target(OrderStatus.WAIT_DELIVER).event(OrderStatusChangeEvent.PAYED)
                    .and()
                    //發貨事件:待發貨-》待收貨
                    .withExternal().source(OrderStatus.WAIT_DELIVER).target(OrderStatus.WAIT_RECEIVE).event(OrderStatusChangeEvent.DELIVERY)
                    .and()
                    //收貨事件:待收貨-》已完成
                    .withExternal().source(OrderStatus.WAIT_RECEIVE).target(OrderStatus.FINISH).event(OrderStatusChangeEvent.RECEIVED);
        }
    }

配置持久化:

 /**
 * 
 */
    @Configuration
    @Slf4j
    public class Persist<E, S> {
        /**
         * 持久化到記憶體map中
         *
         * @return
         */
        @Bean(name = "stateMachineMemPersister")
        public static StateMachinePersister getPersister() {
            return new DefaultStateMachinePersister(new StateMachinePersist() {
                @Override
                public void write(StateMachineContext context, Object contextObj) throws Exception {
                    log.info("持久化狀態機,context:{},contextObj:{}", JSON.toJSONString(context), JSON.toJSONString(contextObj));
                    map.put(contextObj, context);
                }
                @Override
                public StateMachineContext read(Object contextObj) throws Exception {
                    log.info("獲取狀態機,contextObj:{}", JSON.toJSONString(contextObj));
                    StateMachineContext stateMachineContext = (StateMachineContext) map.get(contextObj);
                    log.info("獲取狀態機結果,stateMachineContext:{}", JSON.toJSONString(stateMachineContext));
                    return stateMachineContext;
                }
                private Map map = new HashMap();
            });
        }

        @Resource
        private RedisConnectionFactory redisConnectionFactory;
        /**
         * 持久化到redis中,在分散式系統中使用
         *
         * @return
         */
        @Bean(name = "stateMachineRedisPersister")
        public RedisStateMachinePersister<E, S> getRedisPersister() {
            RedisStateMachineContextRepository<E, S> repository = new RedisStateMachineContextRepository<>(redisConnectionFactory);
            RepositoryStateMachinePersist p = new RepositoryStateMachinePersist<>(repository);
            return new RedisStateMachinePersister<>(p);
        }
    }
4)業務系統

controller:

 /**
 * 
 */
    @RestController
    @RequestMapping("/order")
    public class OrderController {
        @Resource
        private OrderService orderService;
        /**
         * 根據id查詢訂單
         *
         * @return
         */
        @RequestMapping("/getById")
        public Order getById(@RequestParam("id") Long id) {
            //根據id查詢訂單
            Order order = orderService.getById(id);
            return order;
        }
        /**
         * 創建訂單
         *
         * @return
         */
        @RequestMapping("/create")
        public String create(@RequestBody Order order) {
            //創建訂單
            orderService.create(order);
            return "sucess";
        }
        /**
         * 對訂單進行支付
         *
         * @param id
         * @return
         */
        @RequestMapping("/pay")
        public String pay(@RequestParam("id") Long id) {
            //對訂單進行支付
            orderService.pay(id);
            return "success";
        }

        /**
         * 對訂單進行發貨
         *
         * @param id
         * @return
         */
        @RequestMapping("/deliver")
        public String deliver(@RequestParam("id") Long id) {
            //對訂單進行確認收貨
            orderService.deliver(id);
            return "success";
        }
        /**
         * 對訂單進行確認收貨
         *
         * @param id
         * @return
         */
        @RequestMapping("/receive")
        public String receive(@RequestParam("id") Long id) {
            //對訂單進行確認收貨
            orderService.receive(id);
            return "success";
        }
    }

servie:

 /**
 * 
 */
    @Service("orderService")
    @Slf4j
    public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
        @Resource
        private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;
        @Resource
        private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister;
        @Resource
        private OrderMapper orderMapper;
        /**
         * 創建訂單
         *
         * @param order
         * @return
         */
        public Order create(Order order) {
            order.setStatus(OrderStatus.WAIT_PAYMENT.getKey());
            orderMapper.insert(order);
            return order;
        }
        /**
         * 對訂單進行支付
         *
         * @param id
         * @return
         */
        public Order pay(Long id) {
            Order order = orderMapper.selectById(id);
            log.info("線程名稱:{},嘗試支付,訂單號:{}" ,Thread.currentThread().getName() , id);
            if (!sendEvent(OrderStatusChangeEvent.PAYED, order)) {
                log.error("線程名稱:{},支付失敗, 狀態異常,訂單信息:{}", Thread.currentThread().getName(), order);
                throw new RuntimeException("支付失敗, 訂單狀態異常");
            }
            return order;
        }
        /**
         * 對訂單進行發貨
         *
         * @param id
         * @return
         */
        public Order deliver(Long id) {
            Order order = orderMapper.selectById(id);
            log.info("線程名稱:{},嘗試發貨,訂單號:{}" ,Thread.currentThread().getName() , id);
            if (!sendEvent(OrderStatusChangeEvent.DELIVERY, order)) {
                log.error("線程名稱:{},發貨失敗, 狀態異常,訂單信息:{}", Thread.currentThread().getName(), order);
                throw new RuntimeException("發貨失敗, 訂單狀態異常");
            }
            return order;
        }
        /**
         * 對訂單進行確認收貨
         *
         * @param id
         * @return
         */
        public Order receive(Long id) {
            Order order = orderMapper.selectById(id);
            log.info("線程名稱:{},嘗試收貨,訂單號:{}" ,Thread.currentThread().getName() , id);
            if (!sendEvent(OrderStatusChangeEvent.RECEIVED, order)) {
                log.error("線程名稱:{},收貨失敗, 狀態異常,訂單信息:{}", Thread.currentThread().getName(), order);
                throw new RuntimeException("收貨失敗, 訂單狀態異常");
            }
            return order;
        }
        /**
         * 發送訂單狀態轉換事件
         * synchronized修飾保證這個方法是線程安全的
         *
         * @param changeEvent
         * @param order
         * @return
         */
        private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) {
            boolean result = false;
            try {
                //啟動狀態機
                orderStateMachine.start();
                //嘗試恢復狀態機狀態
                stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId()));
                Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
                result = orderStateMachine.sendEvent(message);
                //持久化狀態機狀態
                stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId()));
            } catch (Exception e) {
                log.error("訂單操作失敗:{}", e);
            } finally {
                orderStateMachine.stop();
            }
            return result;
        }
    }

監聽狀態的變化:

 /**
 * 
 */
    @Component("orderStateListener")
    @WithStateMachine(name = "orderStateMachine")
    @Slf4j
    public class OrderStateListenerImpl {
        @Resource
        private OrderMapper orderMapper;

        @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
        public void payTransition(Message<OrderStatusChangeEvent> message) {
            Order order = (Order) message.getHeaders().get("order");
            log.info("支付,狀態機反饋信息:{}",  message.getHeaders().toString());
            //更新訂單
            order.setStatus(OrderStatus.WAIT_DELIVER.getKey());
            orderMapper.updateById(order);
            //TODO 其他業務
        }
        @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
        public void deliverTransition(Message<OrderStatusChangeEvent> message) {
            Order order = (Order) message.getHeaders().get("order");
            log.info("發貨,狀態機反饋信息:{}",  message.getHeaders().toString());
            //更新訂單
            order.setStatus(OrderStatus.WAIT_RECEIVE.getKey());
            orderMapper.updateById(order);
            //TODO 其他業務
        }
        @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
        public void receiveTransition(Message<OrderStatusChangeEvent> message) {
            Order order = (Order) message.getHeaders().get("order");
            log.info("確認收貨,狀態機反饋信息:{}",  message.getHeaders().toString());
            //更新訂單
            order.setStatus(OrderStatus.FINISH.getKey());
            orderMapper.updateById(order);
            //TODO 其他業務
        }
    }

3.3 測試驗證

1)驗證業務

正常流程結束。如果對一個訂單進行支付了,再次進行支付,則會報錯:http://localhost:8084/order/pay?id=2

報錯如下:

2)驗證持久化

記憶體

使用記憶體持久化類持久化:

 /**
 * 
 */
 @Resource
    private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister;

    /**
     * 發送訂單狀態轉換事件
     * synchronized修飾保證這個方法是線程安全的
     *
     * @param changeEvent
     * @param order
     * @return
     */
    private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) {
        boolean result = false;
        try {
            //啟動狀態機
            orderStateMachine.start();
            //嘗試恢復狀態機狀態
            stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId()));
            Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
            result = orderStateMachine.sendEvent(message);
            //持久化狀態機狀態
            stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId()));
        } catch (Exception e) {
            log.error("訂單操作失敗:{}", e);
        } finally {
            orderStateMachine.stop();
        }
        return result;
    }

redis持久化

引入依賴:

<!-- redis持久化狀態機 -->
<dependency>
    <groupId>org.springframework.statemachine</groupId>
    <artifactId>spring-statemachine-redis</artifactId>
    <version>1.2.9.RELEASE</version>
</dependency>

配置yaml:

spring:
  redis:
    database: 0
    host: localhost
    jedis:
      pool:
        max-active: 8
        max-idle: 8
        max-wait: ''
        min-idle: 0
    password: ''
    port: 6379
    timeout: 0

使用redis持久化類持久化:

 /**
 * 
 */
 @Resource
    private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineRedisPersister;

    /**
     * 發送訂單狀態轉換事件
     * synchronized修飾保證這個方法是線程安全的
     *
     * @param changeEvent
     * @param order
     * @return
     */
    private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) {
        boolean result = false;
        try {
            //啟動狀態機
            orderStateMachine.start();
            //嘗試恢復狀態機狀態
            stateMachineRedisPersister.restore(orderStateMachine, String.valueOf(order.getId()));
            Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
            result = orderStateMachine.sendEvent(message);
            //持久化狀態機狀態
            stateMachineRedisPersister.persist(orderStateMachine, String.valueOf(order.getId()));
        } catch (Exception e) {
            log.error("訂單操作失敗:{}", e);
        } finally {
            orderStateMachine.stop();
        }
        return result;
    }

3.4 狀態機存在的問題

1)stateMachine無法拋出異常,異常會被狀態機給消化掉

問題現象

從orderStateMachine.sendEvent(message);獲取的結果無法感知到。無論執行正常還是拋出異常,都返回true。

 @Resource
    private OrderMapper orderMapper;

    @Resource
    private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;

    @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
    @Transactional(rollbackFor = Exception.class)
    public void payTransition(Message<OrderStatusChangeEvent> message) {
        Order order = (Order) message.getHeaders().get("order");
        log.info("支付,狀態機反饋信息:{}",  message.getHeaders().toString());
        try {
            //更新訂單
            order.setStatus(OrderStatus.WAIT_DELIVER.getKey());
            orderMapper.updateById(order);
            //TODO 其他業務
            //模擬異常
            if(Objects.equals(order.getName(),"A")){
                throw new RuntimeException("執行業務異常");
            }
        } catch (Exception e) {
            //如果出現異常,記錄異常信息,拋出異常信息進行回滾
            log.error("payTransition 出現異常:{}",e);
            throw e;
        }
    }

監聽事件拋出異常,在發送事件中無法感知:

 private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) {
        boolean result = false;
        try {
            //啟動狀態機
            orderStateMachine.start();
            //嘗試恢復狀態機狀態
            stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId()));
            Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
             //事件執行異常了,依然返回true,無法感知異常
            result = orderStateMachine.sendEvent(message);
            if(result){
                //持久化狀態機狀態,如果根據true持久化,則會出現問題
                stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId()));
            }
        } catch (Exception e) {
            log.error("訂單操作失敗:{}", e);
        } finally {
            orderStateMachine.stop();
        }
        return result;
    }

調試發現:發送事件和監聽事件是一個線程,發送事件的結果是在監聽操作執行完之後才返回

監聽線程:

解決方案:自己保存異常到資料庫或者記憶體中,進行判斷

也可以通過介面:org.springframework.statemachine.StateMachine##getExtendedState

方法把執行狀態放入這個變數中

public interface ExtendedState {
        Map<Object, Object> getVariables();
        <T> T get(Object var1, Class<T> var2);
        void setExtendedStateChangeListener(ExtendedState.ExtendedStateChangeListener var1);
        public interface ExtendedStateChangeListener {
            void changed(Object var1, Object var2);
        }
    }

org.springframework.statemachine.support.DefaultExtendedState##getVariables

private final Map<Object, Object> variables;

    public DefaultExtendedState() {
        this.variables = new ObservableMap(new ConcurrentHashMap(), new DefaultExtendedState.LocalMapChangeListener());
    }

    public Map<Object, Object> getVariables() {
        return this.variables;
    }

改造監聽狀態:把業務的執行結果進行保存,1成功,0失敗

    @Resource
    private OrderMapper orderMapper;
    @Resource
    private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;

    @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
    @Transactional(rollbackFor = Exception.class)
    public void payTransition(Message<OrderStatusChangeEvent> message) {
        Order order = (Order) message.getHeaders().get("order");
        log.info("支付,狀態機反饋信息:{}",  message.getHeaders().toString());
        try {
            //更新訂單
            order.setStatus(OrderStatus.WAIT_DELIVER.getKey());
            orderMapper.updateById(order);
            //TODO 其他業務
            //模擬異常
            if(Objects.equals(order.getName(),"A")){
                throw new RuntimeException("執行業務異常");
            }
            //成功 則為1
            orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(),1);
        } catch (Exception e) {
            //如果出現異常,則進行回滾
            log.error("payTransition 出現異常:{}",e);
            //將異常信息變數信息中,失敗則為0
            orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(), 0);
            throw e;
        }
    }

發送事件改造:如果獲取到業務執行異常,則返回失敗,不進行狀態機持久化 com.zengqingfa.springboot.state.demo.service.impl.OrderServiceImpl##sendEvent

 @Resource
    private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;
    @Resource
    private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister;

    /**
     * 發送訂單狀態轉換事件
     * synchronized修飾保證這個方法是線程安全的
     *
     * @param changeEvent
     * @param order
     * @return
     */
    private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order){
        boolean result = false;
        try {
            //啟動狀態機
            orderStateMachine.start();
            //嘗試恢復狀態機狀態
            stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId()));
            Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
            result = orderStateMachine.sendEvent(message);
            if(!result){
                return false;
            }
            //獲取到監聽的結果信息
            Integer o = (Integer) orderStateMachine.getExtendedState().getVariables().get(CommonConstants.payTransition + order.getId());
            //操作完成之後,刪除本次對應的key信息
            orderStateMachine.getExtendedState().getVariables().remove(CommonConstants.payTransition+order.getId());
            //如果事務執行成功,則持久化狀態機
            if(Objects.equals(1,Integer.valueOf(o))){
                //持久化狀態機狀態
                stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId()));
            }else {
                //訂單執行業務異常
                return false;
            }
        } catch (Exception e) {
            log.error("訂單操作失敗:{}", e);
        } finally {
            orderStateMachine.stop();
        }
        return result;
    }

代碼優化

  • 發送事件只針對了支付,如果是非支付事件呢?
//獲取到監聽的結果信息
Integer o = (Integer) orderStateMachine.getExtendedState().getVariables().get(CommonConstants.payTransition + order.getId());
  • 監聽設置狀態的代碼有重覆代碼,需要進行優化,可使用aop
try {
        //TODO 其他業務
        //成功 則為1
        orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(),1);
    } catch (Exception e) {
        //如果出現異常,則進行回滾
        log.error("payTransition 出現異常:{}",e);
        //將異常信息變數信息中,失敗則為0
        orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(), 0);
        throw e;
    }

常量類:

public interface CommonConstants {
        String orderHeader="order";
        String payTransition="payTransition";
        String deliverTransition="deliverTransition";
        String receiveTransition="receiveTransition";
    }

支付發送事件:com.zengqingfa.springboot.state.demo.service.impl.OrderServiceImpl##pay

 @Resource
    private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;
    @Resource
    private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister;
    @Resource
    private OrderMapper orderMapper;

    /**
     * 對訂單進行支付
     *
     * @param id
     * @return
     */
    public Order pay(Long id) {
        Order order = orderMapper.selectById(id);
        log.info("線程名稱:{},嘗試支付,訂單號:{}" ,Thread.currentThread().getName() , id);
        if (!sendEvent(OrderStatusChangeEvent.PAYED, order,CommonConstants.payTransition)) {
            log.error("線程名稱:{},支付失敗, 狀態異常,訂單信息:{}", Thread.currentThread().getName(), order);
            throw new RuntimeException("支付失敗, 訂單狀態異常");
        }
        return order;
    }

    /**
     * 發送訂單狀態轉換事件
     * synchronized修飾保證這個方法是線程安全的
     *
     * @param changeEvent
     * @param order
     * @return
     */
    private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order,String key){
        boolean result = false;
        try {
            //啟動狀態機
            orderStateMachine.start();
            //嘗試恢復狀態機狀態
            stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId()));
            Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
            result = orderStateMachine.sendEvent(message);
            if(!result){
                return false;
            }
            //獲取到監聽的結果信息
            Integer o = (Integer) orderStateMachine.getExtendedState().getVariables().get(key + order.getId());
            //操作完成之後,刪除本次對應的key信息
            orderStateMachine.getExtendedState().getVariables().remove(key+order.getId());
            //如果事務執行成功,則持久化狀態機
            if(Objects.equals(1,Integer.valueOf(o))){
                //持久化狀態機狀態
                stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId()));
            }else {
                //訂單執行業務異常
                return false;
            }
        } catch (Exception e) {
            log.error("訂單操作失敗:{}", e);
        } finally {
            orderStateMachine.stop();
        }
        return result;
    }

使用aop對監聽事件切麵,把業務執行結果封裝到狀態機的變數中,註解:

 @Retention(RetentionPolicy.RUNTIME)
    public @interface LogResult {
        /**
         *執行的業務key
         *
         * @return String
         */
        String key();
    }

切麵:

 @Component
    @Aspect
    @Slf4j
    public class LogResultAspect {

        //攔截 LogHistory註解
        @Pointcut("@annotation(com.zengqingfa.springboot.state.demo.aop.annotation.LogResult)")
        private void logResultPointCut() {
            //logResultPointCut 日誌註解切點
        }
        @Resource
        private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;

        @Around("logResultPointCut()")
        public Object logResultAround(ProceedingJoinPoint pjp) throws Throwable {
            //獲取參數
            Object[] args = pjp.getArgs();
            log.info("參數args:{}", args);
            Message message = (Message) args[0];
            Order order = (Order) message.getHeaders().get("order");
            //獲取方法
            Method method = ((MethodSignature) pjp.getSignature()).getMethod();
            // 獲取LogHistory註解
            LogResult logResult = method.getAnnotation(LogResult.class);
            String key = logResult.key();
            Object returnVal = null;
            try {
                //執行方法
                returnVal = pjp.proceed();
                //如果業務執行正常,則保存信息
                //成功 則為1
                orderStateMachine.getExtendedState().getVariables().put(key + order.getId(), 1);
            } catch (Throwable e) {
                log.error("e:{}", e.getMessage());
                //如果業務執行異常,則保存信息
                //將異常信息變數信息中,失敗則為0
                orderStateMachine.getExtendedState().getVariables().put(key + order.getId(), 0);
                throw e;
            }
            return returnVal;
        }
    }

監聽類使用註解:

 @Component("orderStateListener")
    @WithStateMachine(name = "orderStateMachine")
    @Slf4j
    public class OrderStateListenerImpl {
        @Resource
        private OrderMapper orderMapper;

        @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
        @Transactional(rollbackFor = Exception.class)
        @LogResult(key = CommonConstants.payTransition)
        public void payTransition(Message<OrderStatusChangeEvent> message) {
            Order order = (Order) message.getHeaders().get("order");
            log.info("支付,狀態機反饋信息:{}", message.getHeaders().toString());
            //更新訂單
            order.setStatus(OrderStatus.WAIT_DELIVER.getKey());
            orderMapper.updateById(order);
            //TODO 其他業務
            //模擬異常
            if (Objects.equals(order.getName(), "A")) {
                throw new RuntimeException("執行業務異常");
            }
        }
        @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
        @LogResult(key = CommonConstants.deliverTransition)
        public void deliverTransition(Message<OrderStatusChangeEvent> message) {
            Order order = (Order) message.getHeaders().get("order");
            log.info("發貨,狀態機反饋信息:{}", message.getHeaders().toString());
            //更新訂單
            order.setStatus(OrderStatus.WAIT_RECEIVE.getKey());
            orderMapper.updateById(order);
            //TODO 其他業務
        }
        @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
        @LogResult(key = CommonConstants.receiveTransition)
        public void receiveTransition(Message<OrderStatusChangeEvent> message) {
            Order order = (Order) message.getHeaders().get("order");
            log.info("確認收貨,狀態機反饋信息:{}", message.getHeaders().toString());
            //更新訂單
            order.setStatus(OrderStatus.FINISH.getKey());
            orderMapper.updateById(order);
            //TODO 其他業務
        }
    }

近期熱文推薦:

1.1,000+ 道 Java面試題及答案整理(2022最新版)

2.勁爆!Java 協程要來了。。。

3.Spring Boot 2.x 教程,太全了!

4.別再寫滿屏的爆爆爆炸類了,試試裝飾器模式,這才是優雅的方式!!

5.《Java開發手冊(嵩山版)》最新發佈,速速下載!

覺得不錯,別忘了隨手點贊+轉發哦!


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 如果你有 *n* 個緩存伺服器,一個常見的負載均衡方式是使用以下的哈希方法: *伺服器索引 = 哈希(鍵) % N*,其中 *N* 是伺服器池的大小。 讓我們通過一個例子來說明這是如何工作的。如表5-1所示,我們有4台伺服器和8個字元串鍵及其哈希值。 ![image-2023052022160981 ...
  • ### GC 優化 #### 1.防止大對象Buffer到記憶體中 **現象**:當大包請求時,YGC 耗時嚴重 **原因**:預設情況下 Zuul2 並不會緩存請求體(DirectByteBuffer),也就意味著它會先發送接收到的請求 Headers 到後端服務,之後接收到請求體再繼續發送到後端服 ...
  • **我是 javapub,一名 `Markdown` 程式員從👨‍💻,八股文種子選手。** **面試官: 上個面試官對你的基礎有了一定瞭解,聽說你小子很不錯!下麵我們聊點有深度的。** **面試官: 簡單介紹下 CAS 你瞭解什麼?** **候選人:** CAS是Compare And Swap ...
  • NameServer是一個註冊中心,提供服務註冊和服務發現的功能。NameServer可以集群部署,集群中每個節點都是對等的關係(沒有像ZooKeeper那樣在集群中選舉出一個Master節點),節點之間互不通信。 **服務註冊** Broker啟動的時候會向所有的NameServer節點進行註冊, ...
  • 本篇帶你走進AIGC的基本使用,一步一步註冊ChatGPT,申請自己的API進行使用,解決代理的問題,最後介紹如何本地部署ChatGPT,以及通過免費雲平臺搭建代理轉發,從而不需要使用魔法就可以訪問。 ...
  • JVM(Java虛擬機)是Java程式的運行環境,它可以通過一些系統參數進行配置和優化。以下是一些常用的JVM系統參數: 1. -Xmx: 用於設置JVM堆的最大記憶體大小。例如,-Xmx1g表示將堆的最大大小設置為1GB。 2. -Xms: 用於設置JVM堆的初始記憶體大小。例如,-Xms512m表示 ...
  • 基本數據類型和字元串類型的自動轉換<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %> <%@ page contentType="text/html;charset=UTF-8" language="j ...
  • [toc] 你好!我是[@馬哥python說](https://www.zhihu.com/people/13273183132),一名10年程式猿,正在試錯用pyecharts開發可視化大屏的非常規排版。 以下,我用8種ThemeType展示的同一個可視化數據大屏,可視化主題是分析**“淄博燒烤” ...
一周排行
    -Advertisement-
    Play Games
  • 概述:在C#中,++i和i++都是自增運算符,其中++i先增加值再返回,而i++先返回值再增加。應用場景根據需求選擇,首碼適合先增後用,尾碼適合先用後增。詳細示例提供清晰的代碼演示這兩者的操作時機和實際應用。 在C#中,++i 和 i++ 都是自增運算符,但它們在操作上有細微的差異,主要體現在操作的 ...
  • 上次發佈了:Taurus.MVC 性能壓力測試(ap 壓測 和 linux 下wrk 壓測):.NET Core 版本,今天計劃準備壓測一下 .NET 版本,來測試並記錄一下 Taurus.MVC 框架在 .NET 版本的性能,以便後續持續優化改進。 為了方便對比,本文章的電腦環境和測試思路,儘量和... ...
  • .NET WebAPI作為一種構建RESTful服務的強大工具,為開發者提供了便捷的方式來定義、處理HTTP請求並返迴響應。在設計API介面時,正確地接收和解析客戶端發送的數據至關重要。.NET WebAPI提供了一系列特性,如[FromRoute]、[FromQuery]和[FromBody],用 ...
  • 原因:我之所以想做這個項目,是因為在之前查找關於C#/WPF相關資料時,我發現講解圖像濾鏡的資源非常稀缺。此外,我註意到許多現有的開源庫主要基於CPU進行圖像渲染。這種方式在處理大量圖像時,會導致CPU的渲染負擔過重。因此,我將在下文中介紹如何通過GPU渲染來有效實現圖像的各種濾鏡效果。 生成的效果 ...
  • 引言 上一章我們介紹了在xUnit單元測試中用xUnit.DependencyInject來使用依賴註入,上一章我們的Sample.Repository倉儲層有一個批量註入的介面沒有做單元測試,今天用這個示例來演示一下如何用Bogus創建模擬數據 ,和 EFCore 的種子數據生成 Bogus 的優 ...
  • 一、前言 在自己的項目中,涉及到實時心率曲線的繪製,項目上的曲線繪製,一般很難找到能直接用的第三方庫,而且有些還是定製化的功能,所以還是自己繪製比較方便。很多人一聽到自己畫就害怕,感覺很難,今天就分享一個完整的實時心率數據繪製心率曲線圖的例子;之前的博客也分享給DrawingVisual繪製曲線的方 ...
  • 如果你在自定義的 Main 方法中直接使用 App 類並啟動應用程式,但發現 App.xaml 中定義的資源沒有被正確載入,那麼問題可能在於如何正確配置 App.xaml 與你的 App 類的交互。 確保 App.xaml 文件中的 x:Class 屬性正確指向你的 App 類。這樣,當你創建 Ap ...
  • 一:背景 1. 講故事 上個月有個朋友在微信上找到我,說他們的軟體在客戶那邊隔幾天就要崩潰一次,一直都沒有找到原因,讓我幫忙看下怎麼回事,確實工控類的軟體環境複雜難搞,朋友手上有一個崩潰的dump,剛好丟給我來分析一下。 二:WinDbg分析 1. 程式為什麼會崩潰 windbg 有一個厲害之處在於 ...
  • 前言 .NET生態中有許多依賴註入容器。在大多數情況下,微軟提供的內置容器在易用性和性能方面都非常優秀。外加ASP.NET Core預設使用內置容器,使用很方便。 但是筆者在使用中一直有一個頭疼的問題:服務工廠無法提供請求的服務類型相關的信息。這在一般情況下並沒有影響,但是內置容器支持註冊開放泛型服 ...
  • 一、前言 在項目開發過程中,DataGrid是經常使用到的一個數據展示控制項,而通常表格的最後一列是作為操作列存在,比如會有編輯、刪除等功能按鈕。但WPF的原始DataGrid中,預設只支持固定左側列,這跟大家習慣性操作列放最後不符,今天就來介紹一種簡單的方式實現固定右側列。(這裡的實現方式參考的大佬 ...