Spring状态机

if-else实现状态机

public class BasketballMusicSateMachineUsingIfElse{
	
	private boolean isPlayingMusic;

	public BasketballMusicSateMachineUsingIfElse(){
		this.isPlayMusic = false;//初始状态为音乐未播放
	}

	public void playMusic(){
		
		if(!isPlayingMusic){
			System.out.println("Music starts playing...");
			ifPlayingMusic = true;
		}
	}

	public void stopMusic(){
		if(isPlayingMusic){
			System.out.println("Music stops playing...");
			isPlayingMusic = false;
		}
	} 

	public void performActivity(String activity){
		if ("basketball".equals(activity)) {
            System.out.println("Music~");
            playMusic(); // 打篮球时播放音乐
        } else if ("sing_rap".equals(activity)) {
            System.out.println("哎哟你干嘛!");
            stopMusic(); // 唱跳Rap时停止音乐
        } else {
            System.out.println("Invalid activity!");
        }
	}

	public static void main(String[] args) {
        BasketballMusicStateMachineUsingIfElse stateMachine = new BasketballMusicStateMachineUsingIfElse();

        // 测试状态机
        stateMachine.performActivity("basketball"); // 打篮球，音乐开始播放
        stateMachine.performActivity("sing_rap"); // 唱跳Rap，音乐停止播放
        stateMachine.performActivity("basketball"); // 再次打篮球，音乐重新开始播放
    }
}

和状态机的对比

①、引入依赖

spring-statemachine-core

②、定义状态、事件

public enum States {
    IDLE,       // 空闲状态
    PLAYING_BB, // 打篮球状态
    SINGING     // 唱跳Rap状态
}
public enum Event {
    START_BB_MUSIC, // 开始播放篮球音乐事件
    STOP_BB_MUSIC   // 停止篮球音乐事件
}

③、配置状态机

@Configuration
@EnableStateMachine
public class BasketballMusicStateMachineConfig extends EnumStateMachineConfigurerAdapter<States, Event> {

    @Autowired
    private BasketballMusicStateMachineEventListener eventListener;

    @Override
    public void configure(StateMachineConfigurationConfigurer<States, Event> config) throws Exception {
        config
            .withConfiguration()
            .autoStartup(true)
            .listener(eventListener); // 设置状态机事件监听器
    }

    @Override
    public void configure(StateMachineStateConfigurer<States, Event> states) throws Exception {
        states
            .withStates()
            .initial(States.IDLE)
            .states(EnumSet.allOf(States.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<States, Event> transitions) throws Exception {
        transitions
            .withExternal()
            .source(States.IDLE).target(States.PLAYING_BB).event(Event.START_BB_MUSIC)
            .and()
            .withExternal()
            .source(States.PLAYING_BB).target(States.SINGING).event(Event.STOP_BB_MUSIC)
            .and()
            .withExternal()
            .source(States.SINGING).target(States.PLAYING_BB).event(Event.START_BB_MUSIC);
    }
}

④、监听器

@Component
public class BasketballMusicStateMachineEventListener extends StateMachineListenerAdapter<States, Event> {

    @Override
    public void stateChanged(State<States, Event> from, State<States, Event> to) {
        if (from.getId() == States.IDLE && to.getId() == States.PLAYING_BB) {
            System.out.println("开始打篮球，music 起");
        } else if (from.getId() == States.PLAYING_BB && to.getId() == States.SINGING) {
            System.out.println("唱跳，你干嘛");
        } else if (from.getId() == States.SINGING && to.getId() == States.PLAYING_BB) {
            System.out.println("继续打篮球，music 继续");
        }
    }
}

⑤、单元测试

@SpringBootTest
class ChatApplicationTests {
    @Resource
    private StateMachine<States, Event> stateMachine;

    @Test
    void contextLoads() {
        //开始打球，music 起
        stateMachine.sendEvent(Event.START_BB_MUSIC);
  //开始唱跳，你干嘛
        stateMachine.sendEvent(Event.STOP_BB_MUSIC);
  //继续打球，music 继续
        stateMachine.sendEvent(Event.START_BB_MUSIC);

    }
}

==================================================

案例一：

①、依赖

spring-statemachine-core

②、模拟订单类

@Data
public class Order {
    private Long orderId;
    private OrderStatusEnum orderStatus;
}

//订单状态转换
public enum OrderStatusEnum {
    // 待支付
    WAIT_PAYMENT,
    // 待发货
    WAIT_DELIVER,
    // 待收货
    WAIT_RECEIVE,
    // 完成
    FINISH;
}

//订单状态
public enum OrderStatusChangeEventEnum {
    //支付
    PAYED,
    //发货
    DELIVERY,
    //收货
    RECEIVED;
}

③、构造订单状态机

@Configuration
@EnableStateMachine
public class OrderStatusMachineConfig extends StateMachineConfigurerAdapter<OrderStatusEnum, OrderStatusChangeEventEnum> {

    /**
     * 配置状态
     */
    @Override
    public void configure(StateMachineStateConfigurer<OrderStatusEnum, OrderStatusChangeEventEnum> states) throws Exception {
        states.withStates()
                .initial(OrderStatusEnum.WAIT_PAYMENT)
                .end(OrderStatusEnum.FINISH)
                .states(EnumSet.allOf(OrderStatusEnum.class));
    }

    /**
     * 配置状态转换事件关系
     */
    @Override
    public void configure(StateMachineTransitionConfigurer<OrderStatusEnum, OrderStatusChangeEventEnum> transitions) 
    					throws Exception {
        transitions.withExternal().source(OrderStatusEnum.WAIT_PAYMENT).target(OrderStatusEnum.WAIT_DELIVER)
                .event(OrderStatusChangeEventEnum.PAYED)
                .and()
                .withExternal().source(OrderStatusEnum.WAIT_DELIVER).target(OrderStatusEnum.WAIT_RECEIVE)
                .event(OrderStatusChangeEventEnum.DELIVERY)
                .and()
                .withExternal().source(OrderStatusEnum.WAIT_RECEIVE).target(OrderStatusEnum.FINISH)
                .event(OrderStatusChangeEventEnum.RECEIVED);
    }
}

④、状态机监听器

监听状态变更事件，完成状态转换

@Component
@WithStateMachine
@Transactional
public class OrderStatusListener {
    @OnTransition(source = "WAIT_PAYMENT", target = "WAIT_DELIVER")
    public boolean payTransition(Message message) {
        Order order = (Order) message.getHeaders().get("order");
        order.setOrderStatus(OrderStatusEnum.WAIT_DELIVER);
        System.out.println("支付，状态机反馈信息：" + message.getHeaders().toString());
        return true;
    }

    @OnTransition(source = "WAIT_DELIVER", target = "WAIT_RECEIVE")
    public boolean deliverTransition(Message message) {
        Order order = (Order) message.getHeaders().get("order");
        order.setOrderStatus(OrderStatusEnum.WAIT_RECEIVE);
        System.out.println("发货，状态机反馈信息：" + message.getHeaders().toString());
        return true;
    }

    @OnTransition(source = "WAIT_RECEIVE", target = "FINISH")
    public boolean receiveTransition(Message message) {
        Order order = (Order) message.getHeaders().get("order");
        order.setOrderStatus(OrderStatusEnum.FINISH);
        System.out.println("收货，状态机反馈信息：" + message.getHeaders().toString());
        return true;
    }

}

⑤、编写订单服务类

@Service
public class OrderServiceImpl implements OrderService {

    @Resource
    private StateMachine<OrderStatusEnum, OrderStatusChangeEventEnum> orderStateMachine;

    private long id = 1L;

    private Map<Long, Order> orders = Maps.newConcurrentMap();

    @Override
    public Order create() {
        Order order = new Order();
        order.setOrderStatus(OrderStatusEnum.WAIT_PAYMENT);
        order.setOrderId(id++);
        orders.put(order.getOrderId(), order);
        System.out.println("订单创建成功:" + order.toString());
        return order;
    }

    @Override
    public Order pay(long id) {
        Order order = orders.get(id);
        System.out.println("尝试支付，订单号：" + id);
        Message message = MessageBuilder.withPayload(OrderStatusChangeEventEnum.PAYED).
                setHeader("order", order).build();
        if (!sendEvent(message)) {
            System.out.println(" 支付失败, 状态异常，订单号：" + id);
        }
        return orders.get(id);
    }

    @Override
    public Order deliver(long id) {
        Order order = orders.get(id);
        System.out.println(" 尝试发货，订单号：" + id);
        if (!sendEvent(MessageBuilder.withPayload(OrderStatusChangeEventEnum.DELIVERY)
                .setHeader("order", order).build())) {
            System.out.println(" 发货失败，状态异常，订单号：" + id);
        }
        return orders.get(id);
    }

    @Override
    public Order receive(long id) {
        Order order = orders.get(id);
        System.out.println(" 尝试收货，订单号：" + id);
        if (!sendEvent(MessageBuilder.withPayload(OrderStatusChangeEventEnum.RECEIVED)
                .setHeader("order", order).build())) {
            System.out.println(" 收货失败，状态异常，订单号：" + id);
        }
        return orders.get(id);
    }


    @Override
    public Map<Long, Order> getOrders() {
        return orders;
    }

    /**
     * 发送状态转换事件
     * @param message
     * @return
     */
    private synchronized boolean sendEvent(Message<OrderStatusChangeEventEnum> message) {
        boolean result = false;
        try {
            orderStateMachine.start();
            result = orderStateMachine.sendEvent(message);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (Objects.nonNull(message)) {
                Order order = (Order) message.getHeaders().get("order");
                if (Objects.nonNull(order) && Objects.equals(order.getOrderStatus(), OrderStatusEnum.FINISH)) {
                    orderStateMachine.stop();
                }
            }
        }
        return result;
    }
}

⑥、测试入口

@RestController
public class OrderController {

    @Resource
    private OrderService orderService;

    @RequestMapping("/testOrderStatusChange")
    public String testOrderStatusChange(){
        orderService.create();
        orderService.create();
        orderService.pay(1L);
        orderService.deliver(1L);
        orderService.receive(1L);
        orderService.pay(2L);
        orderService.deliver(2L);
        orderService.receive(2L);
        System.out.println("全部订单状态：" + orderService.getOrders());
        return "success";
    }

}

拓展：

消息队列方式
订单状态的流转可以通过 MQ 发布一个事件，消费者根据业务条件把订单状态进行流转，可以根据不同的事件发送到不同的 Topic。

定时任务驱动
每隔一段时间启动一下 job，根据特定的状态从数据库中拿对应的订单记录，然后判断订单是否有条件到达下一个状态。

规则引擎方式
业务团队可以在规则引擎里编写一系列的状态及其对应的转换规则，由规则引擎根据已经加载的规则对输入数据进行解析，根据解析的结果执行相应的动作，完成状态流转。

===============================================================

案例二

①、引入依赖

spring-statemachine-starter

②、定义状态和事件

public enum OrderStates {
    NEW, PAID, SHIPPED, COMPLETED, CANCELLED
}
 
public enum OrderEvents {
    PAY, SHIP, COMPLETE, CANCEL
}

③、配置状态机

@Configuration
@EnableStateMachine
public class StateMachineConfig extends StateMachineConfigurerAdapter<OrderStates, OrderEvents> {
 
    private static final Logger log = LoggerFactory.getLogger(StateMachineConfig.class);
 
    @Override
    public void configure(StateMachineConfigurationConfigurer<OrderStates, OrderEvents> config)
            throws Exception {
        config
                .withConfiguration()
                .autoStartup(true)
                .listener(listener());
    }
 
    @Override
    public void configure(StateMachineStateConfigurer<OrderStates, OrderEvents> states)
            throws Exception {
        states
                .withStates()
                .initial(OrderStates.NEW)
                .end(OrderStates.COMPLETED)
                .end(OrderStates.CANCELLED)
                .states(EnumSet.allOf(OrderStates.class));
    }
 
    @Override
    public void configure(StateMachineTransitionConfigurer<OrderStates, OrderEvents> transitions) throws Exception {
        transitions
                .withExternal()
                .source(OrderStates.NEW).target(OrderStates.PAID).event(OrderEvents.PAY)
                .and()
                .withExternal()
                .source(OrderStates.PAID).target(OrderStates.SHIPPED).event(OrderEvents.SHIP)
                .and()
                .withExternal()
                .source(OrderStates.SHIPPED).target(OrderStates.COMPLETED).event(OrderEvents.COMPLETE)
                .and()
                .withExternal()
                .source(OrderStates.NEW).target(OrderStates.CANCELLED).event(OrderEvents.CANCEL)
                .and()
                .withExternal()
                .source(OrderStates.PAID).target(OrderStates.CANCELLED).event(OrderEvents.CANCEL);
    }
 
    @Bean
    public StateMachineListener<OrderStates, OrderEvents> listener() {
        return new StateMachineListenerAdapter<>() {
            @Override
            public void stateChanged(State<OrderStates, OrderEvents> from, State<OrderStates, OrderEvents> to) {
                log.info("State change to: {}", to.getId());
            }
 
            @Override
            public void stateMachineError(StateMachine<OrderStates, OrderEvents> stateMachine, Exception exception) {
                log.error("Exception caught: {}", exception.getMessage(), exception);
            }
 
            @Override
            public void eventNotAccepted(Message<OrderEvents> message) {
                Order order = (Order) message.getHeaders().get("order");
                log.error("Order state machine can't change state {} --> {}", Objects.requireNonNull(order).getStatus(), message.getPayload());
            }
        };
    }
 
    @Bean
    public StateMachinePersist<OrderStates, OrderEvents, String> inMemoryStateMachinePersist() {
        return new StateMachinePersist<>() {
            private final Map<String, StateMachineContext<OrderStates, OrderEvents>> contexts = new HashMap<>();
 
            @Override
            public void write(StateMachineContext<OrderStates, OrderEvents> context, String contextObj) {
                contexts.put(contextObj, context);
            }
 
            @Override
            public StateMachineContext<OrderStates, OrderEvents> read(String contextObj) {
                return contexts.get(contextObj);
            }
        };
    }
}

④、配置状态改变后的处理器

使用@WithStateMachine来配置状态机流转后的后续逻辑，比如更新订单状态、发邮件等。

@Service
@WithStateMachine
public class OrderStateChangeHandler {
 
    private static final Logger log = LoggerFactory.getLogger(OrderStateChangeHandler.class);
 
    @OnTransition(source = "NEW", target = "PAID")
    public void payTransition(Message<OrderEvents> message) {
        Order order = (Order) message.getHeaders().get("order");
        log.info("Handle Pay Order：{}", order);
        // 其他业务 如保存订单状态
        Objects.requireNonNull(order).setStatus(OrderStates.PAID);
        //orderRepository.save(order);
 
    }
 
    @OnTransition(source = "PAID", target = "SHIPPED")
    public void shipTransition(Message<OrderEvents> message) {
        Order order = (Order) message.getHeaders().get("order");
        log.info("Handle Ship Order：{}", order);
        // 其他业务 如更新订单
        Objects.requireNonNull(order).setStatus(OrderStates.SHIPPED);
//        orderMapper.updateById(order);
    }
    @OnTransition(source = "SHIPPED", target = "COMPLETED")
    public void completeTransition(Message<OrderEvents> message) {
        Order order = (Order) message.getHeaders().get("order");
        log.info("Handle Complete Order：{}", order);
 
        // 其他业务 如更新订单
        Objects.requireNonNull(order).setStatus(OrderStates.COMPLETED);
//        orderMapper.updateById(order);
    }
 
}

⑤、使用状态机控制订单状态流转

@Service
public class OrderService {
 
    private static final Logger log = LoggerFactory.getLogger(OrderService.class);
 
    private final StateMachine<OrderStates, OrderEvents> stateMachine;
 
    public OrderService(StateMachine<OrderStates, OrderEvents> stateMachine) {
        this.stateMachine = stateMachine;
    }
 
    public void payOrder(Integer id) {
        log.info("Pay Order: {}", id);
        Order order = new Order("12345", "Sample Order", OrderStates.NEW, new BigDecimal("99.99"));
        // 模拟支付
//        payService.payOrder(1);
        Message<OrderEvents> message = MessageBuilder.withPayload(OrderEvents.PAY).setHeader("order", order).build();
        stateMachine.sendEvent(Mono.just(message)).subscribe();
    }
 
    public void shipOrder(Integer id) {
        log.info("Ship Order: {}", id);
        Order order = new Order("12345", "Sample Order", OrderStates.PAID, new BigDecimal("99.99"));
        // 模拟发货
//        tradeService.shipOrder(1);
        Message<OrderEvents> message = MessageBuilder.withPayload(OrderEvents.SHIP).setHeader("order", order).build();
        stateMachine.sendEvent(Mono.just(message)).subscribe();
    }
 
    public void completeOrder(Integer id) {
        log.info("Complete Order: {}", id);
        Order order = new Order("12345", "Sample Order", OrderStates.SHIPPED, new BigDecimal("99.99"));
 
        Message<OrderEvents> message = MessageBuilder.withPayload(OrderEvents.COMPLETE).setHeader("order", order).build();
        stateMachine.sendEvent(Mono.just(message)).subscribe();
    }
 
}

⑥、控制订单流转

@GetMapping("/order/pay/{id}")
public String payOrder(@PathVariable("id") Integer id) {
     orderService.payOrder(id);
     return "Order paid ";
}
 
@GetMapping("/order/ship/{id}")
public String shipOrder(@PathVariable("id") Integer id) {
    orderService.shipOrder(id);
    return "Order shipped ";
}
 
@GetMapping("/order/complete/{id}")
 public String completeOrder(@PathVariable("id") Integer id) {
    orderService.completeOrder(id);
    return "Order completed ";
}

测试：

1.NEW --> SHIPPED
因为我们配置的订单流转规则中，NEW只能转换到PAID或CANCELLED，所以我们期望的是订单不能流转成功。

在浏览器中访问：http://localhost:8082/order/ship/1

控制台中打印如下错误信息，并且处理器中业务未执行，和我们的预期一致。

2. NEW --> COMPLETE
   同上面一样，期望是会出现错误，不能转换成功。访问：http://localhost:8082/order/complete/1

3. NEW --> PAID
   由于在状态机的配置，NEW是可以转换成PAID的。所以，期望能转换成功。访问：http://localhost:8082/order/pay/1

我们从控制台中可以看到， 订单状态流转成功，并且进入到handler中进行订单流转后的业务处理。这时该订单的状态已经变成PAID。

如果我们在来支付一次，结果会怎么样？

执行一次结果是报错，因为上一次请求，该订单的状态已经流转为了PAID，所以再次流转NEW --> PAY就会报错。

4. PAID --> SHIPPED
   属于配置允许的状态流转，所以期望能够转换成功。访问：http://localhost:8082/order/ship/1

从控制台中可以看到能够成功流转，因为符合我们配置的状态机流转规则。

同样如果我们再调用一次会怎么样？

和上一步的测试结果一样，因为该订单的状态已经扭转为了SHIPPED，所以它不能再次转换为SHIPPED。

5. SHIPPED --> COMPLETED
   我们之间访问：http://localhost:8082/order/complete/1

该订单当前状态为SHIPPED，根据配置的规则可以转换为COMPLETED

====================================================================

案例：

①、导入sql，订单表的创建

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);

②、引入依赖

 <!-- redis持久化状态机
	项目中：yml配置文件中进行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>

③、定义状态机状态和事件

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;
}

③、定义状态机规则和配置状态机

@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);
    }
}

监听状态的变化：

@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 其他业务
    }
}

⑤、业务系统

@Controller
@RequestMapping
public class OrderController{
	
	@Resource
	private OrderService.orderService;

	//根据id查询订单
	@RequestMapping("/getById")
	public Order getById(@RequestParam("id") Long id){
		
		Order order = orderServiceService.getById(id);
		return order;
	}
	
	//创建订单
	public String create(@RequestBody Order order){
		
		orderService.create(order);
		return "success";
	}

	//对订单进行支付
	@RequestMapping("/pay")
	public String pay(@RequestParam("id") Long id){
		
		orderService.pay(id);
		return "success";
	}

	//对订单进行发货
	@RequestMapping("/deliver")
	public String deliver(@RequestParam("id") Long id){
		
		orderService.deliver(id);
		return "success";
	}

	//对订单进行确认收货
	@RequestMapping("receive")
	public String receive(@RequestParam("id") Long id){
		
		orderService.receive(id);
		return "success";
	}
}

@Service
@Slf4j
public class OrerServiceImpl extends ServiceImpl<OrderMapper,Order> implements OrderService {
	
	@Resource
    private StateMachine<OrderStatus, OrderStatusChangeEvent> orderStateMachine;
    
    @Resource
    private StateMachinePersister<OrderStatus, OrderStatusChangeEvent, String> stateMachineMemPersister;
    
    @Resource
    private OrderMapper orderMapper;

	public Order create(Order order) {
        order.setStatus(OrderStatus.WAIT_PAYMENT.getKey());
        orderMapper.insert(order);
        return order;
    }

	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;
	}

	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;
   }

	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;
  }
	
	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;
        }
}

测试：

1）验证业务

新增一个订单
http://localhost:8084/order/create

对订单进行支付
http://localhost:8084/order/pay?id=2

对订单进行发货
http://localhost:8084/order/deliver?id=2

对订单进行确认收货
http://localhost:8084/order/receive?id=2

正常流程结束。如果对一个订单进行支付了，再次进行支付，则会报错：http://localhost:8084/order/pay?id=2