Spring StateMachine实现状态机使用示例详解

目录

• 什么是状态机
• 使用示例

什么是状态机

状态机是计算机科学中的​​核心建模工具​​，用于描述对象在其生命周期内状态变化的逻辑模型。它通过定义​​有限状态集合​​、​​状态转移规则​​和​​触发事件​​，精确控制系统的行为逻辑。

本文主要讲Spring StateMAChine实现的状态机

使用示例

导入maven依赖

        <dependency>
            <groupId>org.springframework.statemachine</groupId>
            <artifactId>spring-statemachine-core</artifactId>
            <version>4.0.0</version>
        </dpythonependency>

创建订单状态枚举类

public enum OrderStatusEnum {
    WAITING_PAYMENT,//待支付
    WAITING_RECEIVE,//待取货
    FINISHED,//已完成
    CANCELED;//已取消
}

创建订单转悠事件枚举类

public enum OrderEvent {
    CREATE_ORDER,//创建订单
    PAY_ORDER,//支付订单
    RECEIVE_ORDER,//取货
    CANCEL_ORDER,//取消订单
    FINISH_ORDER//完成订单
}

添加状态机实例并添加状态转移规则

@Configuration
@EnableStateMachine(name="orderStateMachine")
public class OrderStateMachineConfig {
    @Bean
    public StateMachine<OrderStatusEnum, OrderEvent> orderStateMachine() throws Exception {
        StateMachineBuilder.Builder<OrderStatusEnum, OrderEvent> builder = StateMachineBuilder.builder();
        // 配置状态
        builder.configureStates()
                .withStates()
                .initial(OrderStatusEnum.WAITING_PAYMENT) // 初始状态
                .states(EnumSet.allOf(OrderStatusEnum.class));// 配置所有状态
        // 配置状态转换 规则
        builder.configureTransitions()
                // 订单待支付 -> 待取货
                .withExternal()
                .source(OrderStatusEnum.WAITING_PAYMENT).target(OrderStatusEnum.WAITING_RECEIVE)
                .event(OrderEvent.PAY_ORDER)
                .and()
                // 订单待取货 -> 已完成
                .withExternal()
                .source(OrderStatusEnum.WAITING_RECEIVE).target(OrderStatusEnum.FINISHED)
                .event(OrderEvent.FINISH_ORDER)
                .and()
                // 订单待支付 -> 已取消
                .withExternal()
                .source(OrderStatusEnum.WAITING_PAYMENT).target(OrderStatusEnum.CANCELED)
                .event(OrderEvent.CANCEL_ORDER);
        return builder.build();
    }
}

注入上下文bean，编程客栈方法作用后面会说

@Bean
    public DefaultStateMachinePersister persister(){
        return new DefaultStateMachinePersister<>(new StateMachinePersist<Object, Object, Order>() {
            @Override
            public void write(StateMachineContext<Object, Object> context, Order order) throws Exception {
                //此处并没有进行持久化操作
                System.out.println("订单状态持久化：" + context.getState());
            }
            @Override
            public StateMachineContext<Object, Object> read(Order order) throws Exception {
                //此处直接获取order中的状态，其实并没有进行持久化读取操作
                return new DefaultStateMachineContext(order.getStatus(), null, null, null);
            }
        });
    }

创建调用示例服务

@Service
@RequiredArgsConstructor
public class OrderService {
    private final StateMachine<OrderStatusEnum, OrderEvent> orderStateMachine;
    private final DefaultStateMachinePersister persister;
    // 1、事件： 支付
    // 2、状态转换：待支付 → 待发货\
     public Order pay() {
         Order order = Order
                 .builder()
                 .orderId("1")
                 .status(OrderStatusEnum.WAITING_RECEIVE)
                 .build();
         System.out.println("线程名称：" + Thread.currentThread().getName() + " 尝试支付，订单号：" + order.getOrderId());
        Message message = MessageBuilder.withPayload(OrderEvent.PAY_ORDER).setHeader("order", order).build();
        if (!sendEvent(message, order)) {
            System.out.println("线程名称：" + Thread.currentThread().getName() + " 支付失败, 状态异常，订单号：" + order.getOrderId());
        }
        System.out.println("线程名称：" + Thread.currentThrksZphead().getName() + " 支付成功，订单号：" + order.getOrderId());
        return order;
    }
    /**
     * 发送订单状态转换事件
     *
     * @param message
     * @param order
     * @return
     */
    private synchronized boolean sendEvent(Message<OrderEvent> message, Order order) {
        boolean result = false;
        try {
            orderStateMachine.start();
            //尝试恢复状态机状态
            persister.restore(orderStateMachine, order);
            //添加延迟用于线程安全测试
            Thread.sleep(1000);
            result = orderStateMachine.sendEvent(message);
            //持久化状态机状态
            persister.persist(orderStateMachine, order);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            orderStateMachine.stop();
        }
        return result;
    }
}

代码python解析：

创建订单示例模拟数据库实际订单信息，基于当前订单状态变换的流转与事件创建对应message消息，同时添加head信息。调用sendEvent方法使用状态机判断。

public Order pay() {
         Order order = Order
                 .builder()
                 .orderId("编程1")
                 .status(OrderStatusEnum.WAITING_RECEIVE)
                 .build();
         System.out.println("线程名称：" + Thread.currentThread().getName() + " 尝试支付，订单号：" + order.getOrderId());
        Message message = MessageBuilder.withPayload(OrderEvent.PAY_ORDER).setHeader("order", order).build();
        if (!sendEvent(message, order)) {
            System.out.println("线程名称：" + Thread.currentThread().getName() + " 支付失败, 状态异常，订单号：" + order.getOrderId());
        }
        System.out.println("线程名称：" + Thread.currentThread().getName() + " 支付成功，订单号：" + order.getOrderId());
        return order;
    }

判断逻辑很简单，

.start()启动状态机，

.restore()方法跟踪发现实际调用的是上面上下文bean中的read()方法，作用是恢复状态机的上下文，结果一番搜索后，博主终于明白这步的作用。首先我们要知道Spring StateMachine状态机是无状态的，每次启动都会是默认的状态，而他状态判断逻辑不会从所有规则中寻找符合的规则，而是基于状态机当前的状态与传入的事件进行判断状态流转是否正确，因此需要将当前状态与状态机中的状态进行同步

.sendEvent()方法是实际调用状态机内部的进行状态流转规则的判断，符合状态流转规则时对状态进行变换，同时符合规则转换成功时返回true，否则返回false

通过dubug追踪看到，状态变换成功，同时返回true

.persist()方法内部实际调用上下文中的write方法，可以在此进行实际的数据持久化

接着在finally中停止状态机

private synchronized boolean sendEvent(Message<OrderEvent> message, Order order) {
        boolean result = false;
        try {
            orderStateMachine.start();
            //尝试恢复状态机状态
            persister.restore(orderStateMachine, order);
            //添加延迟用于线程安全测试
            Thread.sleep(1000);
            result = orderStateMachine.sendEvent(message);
            //持久化状态机状态
            persister.persist(orderStateMachine, order);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            orderStateMachine.stop();
        }
        return result;
    }

至此，基本的状态机就顺利实现

到此这篇关于Spring StateMachine实现状态机使用示例详解的文章就介绍到这了,更多相关Spring StateMachine状态机内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！