1 狀態(tài)機(jī)

1.1 什么是狀態(tài)

先來解釋什么是狀態(tài)（ State ）?，F(xiàn)實(shí)事物是有不同狀態(tài)的，例如一個(gè)自動(dòng)門，就有 open 和 closed 兩種狀態(tài)。我們通常所說的狀態(tài)機(jī)是有限狀態(tài)機(jī)，也就是被描述的事物的狀態(tài)的數(shù)量是有限個(gè)，例如自動(dòng)門的狀態(tài)就是兩個(gè) open 和 closed 。

狀態(tài)機(jī)，也就是 State Machine ，不是指一臺(tái)實(shí)際機(jī)器，而是指一個(gè)數(shù)學(xué)模型。說白了，一般就是指一張狀態(tài)轉(zhuǎn)換圖。

狀態(tài)機(jī)的全稱是有限狀態(tài)自動(dòng)機(jī)，自動(dòng)兩個(gè)字也是包含重要含義的。給定一個(gè)狀態(tài)機(jī)，同時(shí)給定它的當(dāng)前狀態(tài)以及輸入，那么輸出狀態(tài)時(shí)可以明確的運(yùn)算出來的。例如對于自動(dòng)門，給定初始狀態(tài) closed ，給定輸入“開門”，那么下一個(gè)狀態(tài)時(shí)可以運(yùn)算出來的。

1.2 四大概念

下面來給出狀態(tài)機(jī)的四大概念：

• State：狀態(tài)，一個(gè)狀態(tài)機(jī)至少要包含兩個(gè)狀態(tài)。
• Event：事件，事件就是執(zhí)行某個(gè)操作的觸發(fā)條件或者口令。對于自動(dòng)門，“按開門按鈕”就是一個(gè)事件。
• Action：動(dòng)作，事件發(fā)生以后要執(zhí)行動(dòng)作。例如事件是“按開門按鈕”，動(dòng)作是“開門”。編程的時(shí)候，一個(gè) Action一般就對應(yīng)一個(gè)函數(shù)。
• Transition：變換，也就是從一個(gè)狀態(tài)變化為另一個(gè)狀態(tài)。例如“開門過程”就是一個(gè)變換。

1.3 狀態(tài)機(jī)

有限狀態(tài)機(jī)（Finite-state machine,FSM），又稱有限狀態(tài)自動(dòng)機(jī)，簡稱狀態(tài)機(jī)，是表示有限個(gè)狀態(tài)以及在這些狀態(tài)之間的轉(zhuǎn)移和動(dòng)作等行為的數(shù)學(xué)模型。
FSM是一種算法思想，簡單而言，有限狀態(tài)機(jī)由一組狀態(tài)、一個(gè)初始狀態(tài)、輸入和根據(jù)輸入及現(xiàn)有狀態(tài)轉(zhuǎn)換為下一個(gè)狀態(tài)的轉(zhuǎn)換函數(shù)組成。
其作用主要是描述對象在它的生命周期內(nèi)所經(jīng)歷的狀態(tài)序列，以及如何響應(yīng)來自外界的各種事件。

1.4 spring statemachine

Spring Statemachine是應(yīng)用程序開發(fā)人員在Spring應(yīng)用程序中使用狀態(tài)機(jī)概念的框架
Spring Statemachine旨在提供以下功能：

• 易于使用的扁平單級狀態(tài)機(jī)，用于簡單的使用案例。
• 分層狀態(tài)機(jī)結(jié)構(gòu)，以簡化復(fù)雜的狀態(tài)配置。
• 狀態(tài)機(jī)區(qū)域提供更復(fù)雜的狀態(tài)配置。
• 使用觸發(fā)器，轉(zhuǎn)換，警衛(wèi)和操作。
• 鍵入安全配置適配器。
• 生成器模式，用于在Spring Application上下文之外使用的簡單實(shí)例化通常用例的食譜
• 基于Zookeeper的分布式狀態(tài)機(jī)
• 狀態(tài)機(jī)事件監(jiān)聽器。
• UML Eclipse Papyrus建模。
• 將計(jì)算機(jī)配置存儲(chǔ)在永久存儲(chǔ)中。
• Spring IOC集成將bean與狀態(tài)機(jī)關(guān)聯(lián)起來。

狀態(tài)機(jī)功能強(qiáng)大，因?yàn)樾袨槭冀K保證一致，使調(diào)試相對容易。這是因?yàn)椴僮饕?guī)則是在機(jī)器啟動(dòng)時(shí)寫成的。這個(gè)想法是你的應(yīng)用程序可能存在于有限數(shù)量的狀態(tài)中，某些預(yù)定義的觸發(fā)器可以將你的應(yīng)用程序從一個(gè)狀態(tài)轉(zhuǎn)移到另一個(gè)狀態(tài)。此類觸發(fā)器可以基于事件或計(jì)時(shí)器。

2 示例Demo

2.1 訂單狀態(tài)圖

做需求時(shí)，需要了解以下六種元素：起始、終止、現(xiàn)態(tài)、次態(tài)（目標(biāo)狀態(tài)）、動(dòng)作、條件，我們就可以完成一個(gè)狀態(tài)機(jī)圖了：

image.png

以訂單為例：以從待支付狀態(tài)轉(zhuǎn)換為待發(fā)貨狀態(tài)為例

• 現(xiàn)態(tài)：是指當(dāng)前所處的狀態(tài)。待支付
• 條件：又稱為“事件”，當(dāng)一個(gè)條件被滿足，將會(huì)觸發(fā)一個(gè)動(dòng)作，或者執(zhí)行一次狀態(tài)的遷移。支付事件
• 動(dòng)作：條件滿足后執(zhí)行的動(dòng)作。動(dòng)作執(zhí)行完畢后，可以遷移到新的狀態(tài)，也可以仍舊保持原狀態(tài)。動(dòng)作不是必需的，當(dāng)條件滿足后，也可以不執(zhí)行任何動(dòng)作，直接遷移到新狀態(tài)。狀態(tài)轉(zhuǎn)換為待發(fā)貨
• 次態(tài)：條件滿足后要遷往的新狀態(tài)?！按螒B(tài)”是相對于“現(xiàn)態(tài)”而言的，“次態(tài)”一旦被激活，就轉(zhuǎn)變成新的“現(xiàn)態(tài)”了。

注意：

• 避免把某個(gè)“程序動(dòng)作”當(dāng)作是一種“狀態(tài)”來處理。那么如何區(qū)分“動(dòng)作”和“狀態(tài)”？“動(dòng)作”是不穩(wěn)定的，即使沒有條件的觸發(fā)，“動(dòng)作”一旦執(zhí)行完畢就結(jié)束了；而“狀態(tài)”是相對穩(wěn)定的，如果沒有外部條件的觸發(fā)，一個(gè)狀態(tài)會(huì)一直持續(xù)下去。
• 狀態(tài)劃分時(shí)漏掉一些狀態(tài)，導(dǎo)致跳轉(zhuǎn)邏輯不完整。所以在設(shè)計(jì)狀態(tài)機(jī)時(shí)，我們需要反復(fù)的查看設(shè)計(jì)的狀態(tài)圖或者狀態(tài)表，最終達(dá)到一種牢不可破的設(shè)計(jì)方案。

2.2 建表

表結(jié)構(gòu)設(shè)計(jì)如下：

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 '訂單狀態(tài)',
      `name` varchar(64) COLLATE utf8mb4_bin DEFAULT NULL COMMENT '訂單名稱',
      `price` decimal(12,2) DEFAULT NULL COMMENT '價(jià)格',
      `delete_flag` tinyint(2) NOT NULL DEFAULT '0' COMMENT '刪除標(biāo)記，0未刪除  1已刪除',
      `create_time` timestamp DEFAULT CURRENT_TIMESTAMP  COMMENT '創(chuàng)建時(shí)間',
      `update_time` timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新時(shí)間',
      
      `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`(`order_code`,`status`,`name`,`price`,`delete_flag`) values
    ('A111',1,'A','22.00',0),
    ('A111',1,'訂單A','22.00',0),
    ('A111',1,'訂單A','22.00',0),
    ('A111',1,'訂單A','22.00',0);

2.3 依賴和配置

2.3.1 pom.xml

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.6.11</version>
</parent>

<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.83</version>
    </dependency>

    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.5.0</version>
    </dependency>
    <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>

   
    <!--狀態(tài)機(jī)-->
    <dependency>
        <groupId>org.springframework.statemachine</groupId>
        <artifactId>spring-statemachine-starter</artifactId>
        <version>2.0.1.RELEASE</version>
    </dependency>
</dependencies>

2.3.2 application.yml

spring:
  application:
    name: state-machine-demo
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/test?useSSL=false&serverTimezone=GMT&characterEncoding=utf8
mybatis-plus:
  mapper-locations: classpath:mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

2.4 狀態(tài)機(jī)配置

2.4.1 定義狀態(tài)機(jī)狀態(tài)和事件

訂單狀態(tài)

public enum OrderStatus {
        // 待支付，待發(fā)貨，待收貨，已完成
        WAIT_PAYMENT(1, "待支付"),
        WAIT_DELIVER(2, "待發(fā)貨"),
        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 {
        // 支付，發(fā)貨，確認(rèn)收貨
        PAYED, DELIVERY, RECEIVED;
}

2.4.2 定義狀態(tài)機(jī)規(guī)則

@Configuration
@EnableStateMachine(name = "orderStateMachine")
public class OrderStateMachineConfig extends StateMachineConfigurerAdapter<OrderStatus, OrderStatusChangeEvent> {
        /**
         * 配置狀態(tài)
         *
         * @param states
         * @throws Exception
         */
        public void configure(StateMachineStateConfigurer<OrderStatus, OrderStatusChangeEvent> states) throws Exception {
            states
                    .withStates()
                    .initial(OrderStatus.WAIT_PAYMENT)
                    .states(EnumSet.allOf(OrderStatus.class));
        }
        /**
         * 配置狀態(tài)轉(zhuǎn)換事件關(guān)系
         *
         * @param transitions
         * @throws Exception
         */
        public void configure(StateMachineTransitionConfigurer<OrderStatus, OrderStatusChangeEvent> transitions) throws Exception {
            transitions
                    //支付事件:待支付-》待發(fā)貨
                    .withExternal().source(OrderStatus.WAIT_PAYMENT).target(OrderStatus.WAIT_DELIVER).event(OrderStatusChangeEvent.PAYED)
                    .and()
                    //發(fā)貨事件:待發(fā)貨-》待收貨
                    .withExternal().source(OrderStatus.WAIT_DELIVER).target(OrderStatus.WAIT_RECEIVE).event(OrderStatusChangeEvent.DELIVERY)
                    .and()
                    //收貨事件:待收貨-》已完成
                    .withExternal().source(OrderStatus.WAIT_RECEIVE).target(OrderStatus.FINISH).event(OrderStatusChangeEvent.RECEIVED);
        }
    }

2.4.3 配置持久化

2.4.3.1 持久化到內(nèi)存

@Configuration
@Slf4j
public class Persist<E, S> {
    /**
     * 持久化到內(nèi)存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("持久化狀態(tài)機(jī),context:{},contextObj:{}", JSON.toJSONString(context), JSON.toJSONString(contextObj));
                map.put(contextObj, context);
            }
            @Override
            public StateMachineContext read(Object contextObj) throws Exception {
                log.info("獲取狀態(tài)機(jī),contextObj:{}", JSON.toJSONString(contextObj));
                StateMachineContext stateMachineContext = (StateMachineContext) map.get(contextObj);
                log.info("獲取狀態(tài)機(jī)結(jié)果,stateMachineContext:{}", JSON.toJSONString(stateMachineContext));
                return stateMachineContext;
            }
            private Map map = new HashMap();
        });
    }   
}

2.4.3.2 持久化到redis 方式一

<!-- redis持久化狀態(tài)機(jī) -->
<dependency>
    <groupId>org.springframework.statemachine</groupId>
    <artifactId>spring-statemachine-redis</artifactId>
    <version>1.2.9.RELEASE</version>
</dependency>

在application.yml中添加

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

在Persist中添加如下：

@Resource
private RedisConnectionFactory redisConnectionFactory;
 /**
  * 持久化到redis中，在分布式系統(tǒng)中使用
  *
  * @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);
 }

使用redis持久化：

//使用name 指定redis持久化
@Resource(name="stateMachineRedisPersister")
private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineRedisPersister;

private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) {
    boolean result = false;
    try {
        //啟動(dòng)狀態(tài)機(jī)
        orderStateMachine.start();
        //嘗試恢復(fù)狀態(tài)機(jī)狀態(tài)
        stateMachineRedisPersister.restore(orderStateMachine, String.valueOf(order.getId()));
        Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
        result = orderStateMachine.sendEvent(message);
        //持久化狀態(tài)機(jī)狀態(tài)
        stateMachineRedisPersister.persist(orderStateMachine, String.valueOf(order.getId()));
    } catch (Exception e) {
        log.error("訂單操作失敗:{}", e);
    } finally {
        orderStateMachine.stop();
    }
    return result;
}

2.4.3.3 持久化到redis 方式二

<!-- Spring Data Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>3.3.2</version>
</dependency>

配置 RedisTemplate 用于與 Redis 交互，確保狀態(tài)機(jī)上下文可以被序列化和反序列化。

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 使用 String 序列化器作為鍵
        template.setKeySerializer(new StringRedisSerializer());
        // 使用 JSON 序列化器作為值，處理 StateMachineContext
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }
}

創(chuàng)建一個(gè)自定義的 StateMachinePersist 實(shí)現(xiàn)，將狀態(tài)機(jī)上下文存儲(chǔ)到 Redis。

public class RedisStateMachinePersist<S, E> implements StateMachinePersist<S, E, String> {
    private final RedisTemplate<String, Object> redisTemplate;
    private final String prefix = "statemachine:context:"; // Redis 鍵前綴，避免沖突

    public RedisStateMachinePersist(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Override
    public void write(StateMachineContext<S, E> context, String contextObj) throws Exception {
        String key = prefix + contextObj; // 構(gòu)造 Redis 鍵，例如 "statemachine:context:order123"
        redisTemplate.opsForValue().set(key, context);
        log.info("Persisted state machine context to Redis: key={}", key);
    }

    @Override
    public StateMachineContext<S, E> read(String contextObj) throws Exception {
        String key = prefix + contextObj;
        StateMachineContext<S, E> context = (StateMachineContext<S, E>) redisTemplate.opsForValue().get(key);
        log.info("Read state machine context from Redis: key={}, context={}", key, context);
        return context;
    }
}

配置 StateMachinePersister
將 RedisStateMachinePersist 包裝為 DefaultStateMachinePersister，并注冊為 Spring Bean

@Configuration
public class StateMachineConfig {
    @Bean(name = "stateMachineRedisPersister")
    public StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineRedisPersister(
            RedisTemplate<String, Object> redisTemplate) {
        return new DefaultStateMachinePersister<>(
                new RedisStateMachinePersist<OrderStatus, OrderStatusChangeEvent>(redisTemplate));
    }
}

2.5 業(yè)務(wù)系統(tǒng)

2.5.1 controller

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

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

2.5.2 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;
   /**
    * 創(chuàng)建訂單
    *
    * @param order
    * @return
    */
   public Order create(Order order) {
       order.setStatus(OrderStatus.WAIT_PAYMENT.getKey());
       orderMapper.insert(order);
       return order;
   }
   /**
    * 對訂單進(jìn)行支付
    *
    * @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("線程名稱：{},支付失敗, 狀態(tài)異常，訂單信息：{}", Thread.currentThread().getName(), order);
           throw new RuntimeException("支付失敗, 訂單狀態(tài)異常");
       }
       return order;
   }
   /**
    * 對訂單進(jìn)行發(fā)貨
    *
    * @param id
    * @return
    */
   public Order deliver(Long id) {
       Order order = orderMapper.selectById(id);
       log.info("線程名稱：{},嘗試發(fā)貨，訂單號：{}" ,Thread.currentThread().getName() , id);
       if (!sendEvent(OrderStatusChangeEvent.DELIVERY, order)) {
           log.error("線程名稱：{},發(fā)貨失敗, 狀態(tài)異常，訂單信息：{}", Thread.currentThread().getName(), order);
           throw new RuntimeException("發(fā)貨失敗, 訂單狀態(tài)異常");
       }
       return order;
   }
   /**
    * 對訂單進(jìn)行確認(rèn)收貨
    *
    * @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("線程名稱：{},收貨失敗, 狀態(tài)異常，訂單信息：{}", Thread.currentThread().getName(), order);
           throw new RuntimeException("收貨失敗, 訂單狀態(tài)異常");
       }
       return order;
   }
   /**
    * 發(fā)送訂單狀態(tài)轉(zhuǎn)換事件
    * synchronized修飾保證這個(gè)方法是線程安全的
    *
    * @param changeEvent
    * @param order
    * @return
    */
   private synchronized boolean sendEvent(OrderStatusChangeEvent changeEvent, Order order) {
       boolean result = false;
       try {
           //啟動(dòng)狀態(tài)機(jī)
           orderStateMachine.start();
           //嘗試恢復(fù)狀態(tài)機(jī)狀態(tài)
           stateMachineMemPersister.restore(orderStateMachine, String.valueOf(order.getId()));
           Message message = MessageBuilder.withPayload(changeEvent).setHeader("order", order).build();
           result = orderStateMachine.sendEvent(message);
           //持久化狀態(tài)機(jī)狀態(tài)
           stateMachineMemPersister.persist(orderStateMachine, String.valueOf(order.getId()));
       } catch (Exception e) {
           log.error("訂單操作失敗:{}", e);
       } finally {
           orderStateMachine.stop();
       }
       return result;
   }
}

2.5.3 監(jiān)聽狀態(tài)變化

@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("支付，狀態(tài)機(jī)反饋信息：{}",  message.getHeaders().toString());
        //更新訂單
        order.setStatus(OrderStatus.WAIT_DELIVER.getKey());
        orderMapper.updateById(order);
        //TODO 其他業(yè)務(wù)
    }
    @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
    public void deliverTransition(Message<OrderStatusChangeEvent> message) {
        Order order = (Order) message.getHeaders().get("order");
        log.info("發(fā)貨，狀態(tài)機(jī)反饋信息：{}",  message.getHeaders().toString());
        //更新訂單
        order.setStatus(OrderStatus.WAIT_RECEIVE.getKey());
        orderMapper.updateById(order);
        //TODO 其他業(yè)務(wù)
    }
    @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
    public void receiveTransition(Message<OrderStatusChangeEvent> message) {
        Order order = (Order) message.getHeaders().get("order");
        log.info("確認(rèn)收貨，狀態(tài)機(jī)反饋信息：{}",  message.getHeaders().toString());
        //更新訂單
        order.setStatus(OrderStatus.FINISH.getKey());
        orderMapper.updateById(order);
        //TODO 其他業(yè)務(wù)
    }
}

或者 通過繼承 StateMachineListenerAdapter 并重寫方法（如 stateChanged）來監(jiān)聽狀態(tài)機(jī)的各種事件，可以監(jiān)聽所有狀態(tài)變化或其他狀態(tài)機(jī)事件，適合復(fù)雜場景

public class StateMachineListener extends StateMachineListenerAdapter<OrderStates, OrderEvents> {
    @Override
    public void stateChanged(State<OrderStates, OrderStatusChangeEvent > from, State<OrderStates, OrderStatusChangeEvent> to) {
        // 記錄狀態(tài)變更日志
        log.info("State changed from {} to {}", (from != null) ? from.getId() : "null", to.getId());
    }
}

2.6 狀態(tài)機(jī)存在的問題

stateMachine 無法拋出異常，異常會(huì)被狀態(tài)機(jī)給消化掉

2.6.1 問題現(xiàn)象

從 orderStateMachine.sendEvent(message); 獲取的結(jié)果無法感知到。無論執(zhí)行正常還是拋出異常，都返回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("支付，狀態(tài)機(jī)反饋信息：{}",  message.getHeaders().toString());
    try {
        //更新訂單
        order.setStatus(OrderStatus.WAIT_DELIVER.getKey());
        orderMapper.updateById(order);
        //TODO 其他業(yè)務(wù)
        //模擬異常
        if(Objects.equals(order.getName(),"A")){
            throw new RuntimeException("執(zhí)行業(yè)務(wù)異常");
        }
    } catch (Exception e) {
        //如果出現(xiàn)異常，記錄異常信息，拋出異常信息進(jìn)行回滾
        log.error("payTransition 出現(xiàn)異常：{}",e);
        throw e;
    }
}

監(jiān)聽事件拋出異常，在發(fā)送事件中無法感知：

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

調(diào)試發(fā)現(xiàn)：發(fā)送事件和監(jiān)聽事件是一個(gè)線程，發(fā)送事件的結(jié)果是在監(jiān)聽操作執(zhí)行完之后才返回

2.6.2 解決方案

保存異常到數(shù)據(jù)庫或者內(nèi)存中，進(jìn)行判斷
也可以通過接口：org.springframework.statemachine.StateMachine##getExtendedState##getVariables，方法把執(zhí)行狀態(tài)放入這個(gè)變量中

改造監(jiān)聽狀態(tài)：把業(yè)務(wù)的執(zhí)行結(jié)果進(jìn)行保存，1成功，0失敗

常量類：

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

@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("支付，狀態(tài)機(jī)反饋信息：{}",  message.getHeaders().toString());
    try {
        //更新訂單
        order.setStatus(OrderStatus.WAIT_DELIVER.getKey());
        orderMapper.updateById(order);
        //TODO 其他業(yè)務(wù)
        //模擬異常
        if(Objects.equals(order.getName(),"A")){
            throw new RuntimeException("執(zhí)行業(yè)務(wù)異常");
        }
        //成功 則為1
        orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(),1);
    } catch (Exception e) {
        //如果出現(xiàn)異常，則進(jìn)行回滾
        log.error("payTransition 出現(xiàn)異常：{}",e);
        //將異常信息變量信息中，失敗則為0
        orderStateMachine.getExtendedState().getVariables().put(CommonConstants.payTransition+order.getId(), 0);
        throw e;
    }
}

發(fā)送事件改造：如果獲取到業(yè)務(wù)執(zhí)行異常，則返回失敗，不進(jìn)行狀態(tài)機(jī)持久化

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

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