SpringBoot集成Spring Statemachine（状态机）完整示例

背景：
本文将基于借款订单状态流转这个场景来实现。如果使用if-else或者switch语句来处理这些状态，代码会变得非常臃肿且难以维护。而状态机提供了一种更加结构化和可维护的方式来管理这些状态转换。
示例中涉及到：状态机的配置、数据持久化、状态恢复查询、同一事件由同一sourceStatus流转到不同targetStatus
SpringBoot集成状态机：

1、首先，需要添加Spring Statemachine的依赖到Spring Boot项目的pom.xml文件中：

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

2、定义系统中订单存在的状态

public enum OrderStatusEnum {

// 待审核
APPROVE_PENDING,
// 审核中
APPROVE_ING,
// 审核失败
APPROVE_FAILED,
// 审核成功
APPROVE_SUCCESS;

}

3、定义系统中触发状态变更的事件

public enum OrderEvent {
// 开始审核
APPROVE_START,
// 审核通过
APPROVE_SUCCESS,
// 审核失败
APPROVE_FAILED;

}

4、状态机-状态流转配置

@Configuration
@EnableStateMachine(name = "OrderStateMachine")
@Slf4j
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderStatusEnum, OrderEvent> {

@Resource
private OrderMapper orderMapper;


/**
 * 配置状态
 *
 * @param states
 * @throws Exception
 */
@Override
public void configure(StateMachineStateConfigurer<OrderStatusEnum, OrderEvent> states) throws Exception {
    states.withStates()
            .initial(OrderStatusEnum.LOAN_PENDING) // 设置初始状态为[待审核]
            .states(EnumSet.allOf(OrderStatusEnum.class));
}


/**
 * 配置状态转换事件关系
 *
 * @param transitions
 * @throws Exception
 */
@Override
public void configure(StateMachineTransitionConfigurer<OrderStatusEnum, OrderEvent> transitions) throws Exception {
    transitions
           //当执行 【开始审核】操作时，将订单状态由待审核 -> 审核中
           .withExternal().source(OrderStatusEnum.APPROVE_PENDING).target(OrderStatusEnum.APPROVE_ING).event(OrderEvent.APPROVE_START)
            .and()
            //当执行 【审核失败】操作时，将订单状态由审核中 -> 审核失败
            .withExternal().source(OrderStatusEnum.APPROVE_ING).target(OrderStatusEnum.APPROVE_FAILED).event(OrderEvent.APPROVE_FAILED)
            .and()
            //当执行 【审核成功】操作时，将订单状态由审核中 -> 审核成功
            .withExternal().source(OrderStatusEnum.APPROVE_ING).target(OrderStatusEnum.APPROVE_SUCCESS).event(OrderEvent.APPROVE_SUCCESS);
}


/**
 * 持久化配置
 *
 * @return
 */
@Bean
public DefaultStateMachinePersister persister() {
    return new DefaultStateMachinePersister<>(new StateMachinePersist<OrderStatusEnum, OrderEvent, BizOrder>() {
        @Override
        public void write(StateMachineContext<OrderStatusEnum, OrderEvent> context, BizOrder order) throws Exception {
            OrderStatusEnum orderStatus = context.getState();
            log.info("订单状态持久化,订单ID：{},目标状态:{}", order.getId(), orderStatus);
            orderMapper.updateOrderStatus(order.getId(), orderStatus);
        }

        @Override
        public StateMachineContext<OrderStatusEnum, OrderEvent> read(BizOrder order) throws Exception {
            log.info("恢复订单状态机状态");
            return new DefaultStateMachineContext<>(order.getStatus(), null, null, null);
        }

    });
}

}

5、新建一个变更订单状态的服务

public interface BizOrderStatusService {

    /**
     *
     * 通用状态变更处理器
     * @param incomingId
     * @param event
     */
    void eventHandler(Long orderId, OrderEvent event);

}


@Service
public class BizOrderStatusServiceImpl implements BizOrderStatusService {

    @Resource
    private OrderMapper orderMapper;

    @Resource
    private StateMachine<OrderStatusEnum, OrderEvent> orderStateMachine;

    @Resource
    private StateMachinePersister<OrderStatusEnum, OrderEvent, BizOrder> persister;


/**
 * 
 * 
 * @param orderId 订单id
 * @param event   事件类型
 */
    @Override
    public void eventHandler(Long orderId, OrderEvent event) {
        BizOrder order = orderMapper.getOrderById(orderId);
        Assert.notNull(order, "订单不存在");
        // 自定义状态机参数对象(可以在此对象中定义后续需要用到的字段参数，状态配置那里如果需要做业务逻辑判断)
        StateMachineParam param = new StateMachineParam();
        param.setBizOrder(order);
        Message message = MessageBuilder.withPayload(event).build();
        if (!sendEvent(message, param)) {
            throw new ApplicationBizException("订单状态流转异常");
        }
    }


    /**
     * 发送订单状态转换事件 这里不要使用synchronized锁方法，效率比较低，
     * 分布式系统优先采用分布式锁，下单锁userId，订单状态流转锁orderId根据业务考虑使用什么。
     *
     * @param message
     * @param param
     * @return
     */
    private synchronized boolean sendEvent(Message<OrderEvent> message, StateMachineParam param) {
        boolean result = false;
        try {
            orderStateMachine.start();
            //尝试恢复状态机状态
            persister.restore(orderStateMachine, param.getBizOrder());
            orderStateMachine.getExtendedState().getVariables().put("param", param);
            result = orderStateMachine.sendEvent(message);
            //持久化状态机状态
            persister.persist(orderStateMachine, param.getBizOrder());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            orderStateMachine.stop();
        }
        return result;
    }

}

6、调用方法执行订单状态变更，并持久化到数据库

@RestController
@RequiredArgsConstructor
public class ApproveController {

 private final OrderStatusService orderStatusService;
 

/**
 * 前端调用start方法将订单状态改为审核中，并自动持久化到数据库
 * @param orderId  订单id
 * @return
 */
@PostMapping("/start")
public void start(Long orderId) {
    orderStatusService.eventHandler(orderId,OrderEvent.APPROVE_START);
}

/**
 * 前端调用start方法将订单状态改为审核成功，并自动持久化到数据库
 * @param orderId  订单id
 * @return
 */
@PostMapping("/approveSuccess")
public void approveSuccess(Long orderId) {
    orderStatusService.eventHandler(orderId,OrderEvent.APPROVE_SUCCESS);
}

/**
 * 前端调用start方法将订单状态改为审核失败，并自动持久化到数据库
 * @param orderId  订单id
 * @return
 */
@PostMapping("/approveFailed")
public void approveFailed(Long orderId) {
    orderStatusService.eventHandler(orderId,OrderEvent.APPROVE_FAILED);
}

}

现在，我们已经配置了状态机并创建了服务来操作它。接下来，你可以在应用的任何部分注入OrderStatusService，并传入相应的事件来改变订单的状态。

7、总结：以上就是状态机的基础用法，一个事件对应一种来源状态(sourceStatus)和目标状态(targetStatus)。在我自己使用到的场景中还包含一个事件需要根据不同的条件将同一来源状态流转到不同的目标状态。这时我们就需要在状态映射配置中增加业务逻辑判断。

8、扩展（新增一个放款事件，该事件会将订单状态由【审核成功】流转到【放款成功】或者【部分放款成功】，具体流流转哪一个状态是由订单的放款金额决定的，如果申请金额和放款金额一致就是【放款成功】，放款金额小于申请金额就是【部分放款成功】）

8.1 我们在订单状态枚举中新增(LOAN_SUCCESS, PARTIALLY_LOAN_SUCCESS)

// 待审核
APPROVE_PENDING,
// 审核中
APPROVE_ING,
// 审核失败
APPROVE_FAILED,
// 审核成功
APPROVE_SUCCESS,
// 放款成功
LOAN_SUCCESS,
// 部分放款成功
PARTIALLY_LOAN_SUCCESS;

8.2 我们在事件枚举中新增(LOAN)

// 开始审核
APPROVE_START,
// 审核通过
APPROVE_SUCCESS,
// 审核失败
APPROVE_FAILED,
// 操作放款
LOAN;

8.3 优化一下上面的【配置状态转换事件关系】，需要在事件后面增加条件判断(通过guard()实现)

/**
 * 配置状态转换事件关系
 *
 * @param transitions
 * @throws Exception
 */
@Override
public void configure(StateMachineTransitionConfigurer<OrderStatusEnum, OrderEvent> transitions) throws Exception {
    transitions
           //当执行 【开始审核】操作时，将订单状态由待审核 -> 审核中
           .withExternal().source(OrderStatusEnum.APPROVE_PENDING).target(OrderStatusEnum.APPROVE_ING).event(OrderEvent.APPROVE_START)
            .and()
            //当执行 【审核失败】操作时，将订单状态由审核中 -> 审核失败
            .withExternal().source(OrderStatusEnum.APPROVE_ING).target(OrderStatusEnum.APPROVE_FAILED).event(OrderEvent.APPROVE_FAILED)
            .and()
            //当执行 【审核成功】操作时，将订单状态由审核中 -> 审核成功
            .withExternal().source(OrderStatusEnum.APPROVE_ING).target(OrderStatusEnum.APPROVE_SUCCESS).event(OrderEvent.APPROVE_SUCCESS)
            .and()
            //当执行 【放款】操作时，将订单状态由审核成功 -> 放款成功
            .withExternal().source(OrderStatusEnum.APPROVE_SUCCESS).target(OrderStatusEnum.LOAN_SUCCESS).event(OrderEvent.LOAN).guard(guardForLoanSuccessByLoan())
            .and()
            //当执行 【放款】操作时，将订单状态由审核成功 -> 部分放款成功
            .withExternal().source(OrderStatusEnum.APPROVE_SUCCESS).target(OrderStatusEnum.PARTIALLY_LOAN_SUCCESS).event(OrderEvent.LOAN).guard(guardForPartiallyLoanSuccessByLoan());
}



/**
 * 订单状态由审核通过 -> 放款成功
 * 触发条件：订单申请金额=放款金额
 *
 * @return
 */
@Bean
public Guard<OrderStatusEnum, OrderEvent> guardForLoanSuccessByLoan() {
    return context -> {
        // 从扩展信息中获取参数
        StateMachineParam param = (StateMachineParam) context.getExtendedState().getVariables().get("param");
        BizOrder order = param.getBizOrder();
        // 如果申请金额=放款金额 ，返回true，状态机就会流转到调用此方法的目标状态
        if (order.getApplyAmount().compareTo(order.getLoanAmlunt) == 0) {
            return true;
        }
        return false;
    };
}

/**
 * 订单状态由审核通过 -> 部分放款成功
 * 触发条件：订单申请金额<放款金额
 *
 * @return
 */
@Bean
public Guard<OrderStatusEnum, OrderEvent> guardForPartiallyLoanSuccessByLoan() {
    return context -> {
        // 从扩展信息中获取参数
        StateMachineParam param = (StateMachineParam) context.getExtendedState().getVariables().get("param");
        BizOrder order = param.getBizOrder();
        // 如果申请金额<放款金额 ，返回true，状态机就会流转到调用此方法的目标状态
        if (order.getApplyAmount().compareTo(order.getLoanAmlunt) < 0) {
            return true;
        }
        return false;
    };
}

通过以上操作我们就可以实现业务中某些需要根据不同条件流转到不同状态的场景。

©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容