Spring StateMachine嵌套状态流转

//订单状态枚举
public enum OrderState {
    PENDING_PAY,        // 顶层状态：待支付（初始状态）
    IN_PAYMENT,         // 父状态：支付中
    // 以下为 IN_PAYMENT 的内部子状态
    PAY_PREPARE,        // 子状态：支付准备中
    PAY_PROCESSING,     // 子状态：扣款中
    PENDING_DELIVER     // 结束状态：待发货
}

//订单事件枚举
public enum OrderEvent {
    GO_PAY,             // 外部事件：去支付（待支付 -> 支付中）
    BANK_CONNECT,       // 内部事件：连接渠道（支付准备中 -> 扣款中）
    PAY_SUCCESS,        // 业务结果事件：扣款成功（从扣款中跳出 -> 待发货）
    PAY_FAIL            // 业务结果事件：扣款失败（从扣款中跳出 -> 回到待支付）
}

@Configuration
@EnableStateMachineFactory(name = "paymentStateMachineFactory")
public class PaymentStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderState, OrderEvent> {
    @Override
    public void configure(StateMachineStateConfigurer<OrderState, OrderEvent> states) throws Exception {
        states
            .withStates()
                //注册最外层的顶层独立状态
                .initial(OrderState.PENDING_PAY) //顶层起点：待支付
                .end(OrderState.PENDING_DELIVER) //顶层终点：待发货
                .state(OrderState.IN_PAYMENT)    //宏观负状态：支付中
                .and()
            //嵌套子状态
            .withStates()
                .parent(OrderState.IN_PAYMENT)   //指明父节点
                .initial(OrderState.PAY_PREPARE) //子状态的第一个状态
                .state(OrderState.PAY_PROCESSING);//扣款中
    }
}

@Override
public void configure(StateMachineTransitionConfigurer<OrderState, OrderEvent> transitions) throws Exception {
    transitions
        // 1. 待支付 -> 跳入父状态（支付中）
        // 此时状态机激活集合变为：[IN_PAYMENT, PAY_PREPARE]
        .withExternal()
            .source(OrderState.PENDING_PAY).target(OrderState.IN_PAYMENT)
            .event(OrderEvent.GO_PAY)
            .and()
        // 2. 父状态内部流转：支付准备中 -> 扣款中
        // 此时状态机激活集合变为：[IN_PAYMENT, PAY_PROCESSING]
        .withExternal()
            .source(OrderState.PAY_PREPARE).target(OrderState.PAY_PROCESSING)
            .event(OrderEvent.BANK_CONNECT)
            .and()
        // 3. 【核心流转一】：扣款成功，打破父状态，流转到顶层的“待发货”
        // 状态机将彻底销毁内部的所有子状态指针
        .withExternal()
            .source(OrderState.IN_PAYMENT).target(OrderState.PENDING_DELIVER)
            .event(OrderEvent.PAY_SUCCESS)
            .and()
        // 4. 【核心流转二】：扣款失败，打破父状态，无条件滚回到顶层的“待支付”
        // 状态机同样会销毁内部指针，让订单恢复到最初可以重新发起支付的状态
        .withExternal()
            .source(OrderState.IN_PAYMENT).target(OrderState.PENDING_PAY)
            .event(OrderEvent.PAY_FAIL);
}

public void testHierarchicalStates() {
    StateMachine<OrderState, OrderEvent> sm = factory.getStateMachine("order_999");
    sm.startReactively().block();
    System.out.println("--- 1. 初始化 ---");
    System.out.println("当前激活状态: " + sm.getState().getIds()); // [PENDING_ORDER]
    // 2. 去支付 -> 激活嵌套
    sm.sendEvent(Mono.just(MessageBuilder.withPayload(OrderEvent.GO_PAY).build())).blockLast();
    System.out.println("--- 2. 发送 GO_PAY 后 ---");
    System.out.println("当前激活状态: " + sm.getState().getIds()); 
    // 🎯 预期输出: [IN_PAYMENT, PAY_PREPARE] (父子同时激活)
    // 3. 连接银行 -> 子状态流转
    sm.sendEvent(Mono.just(MessageBuilder.withPayload(OrderEvent.BANK_CONNECT).build())).blockLast();
    System.out.println("--- 3. 发送 BANK_CONNECT 后 ---");
    System.out.println("当前激活状态: " + sm.getState().getIds()); 
    // 🎯 预期输出: [IN_PAYMENT, PAY_PROCESSING] (父状态不变，子状态向前)
    // 4. 支付成功 -> 强行打破嵌套，融合成顶层终态
    sm.sendEvent(Mono.just(MessageBuilder.withPayload(OrderEvent.PAY_SUCCESS).build())).blockLast();
    System.out.println("--- 4. 发送 PAY_SUCCESS 后 ---");
    System.out.println("当前激活状态: " + sm.getState().getIds()); 
    // 🎯 预期输出: [PENDING_DELIVER] (子状态全部销毁，回归单顶层状态)
}

--- 初始状态 ---
[PENDING_PAY]
--- 1. 点击去支付后 ---
[IN_PAYMENT, PAY_PREPARE]
--- 2. 进入银行扣款中后 ---
[IN_PAYMENT, PAY_PROCESSING]
--- 3. 收到扣款失败回调后 ---
[PENDING_PAY]
--- 4. 第二次尝试，重新进入扣款中 ---
[IN_PAYMENT, PAY_PROCESSING]
--- 5. 收到扣款成功回调后 ---
[PENDING_DELIVER]