Java整合Spring StateMachine 基于MySQL持久化实现复杂状态流转

Java整合Spring StateMachine与MySQL持久化实现

环境准备

确保项目中已引入Spring StateMachine核心依赖和MySQL相关驱动。Maven配置示例：

<dependency>
    <groupId>org.springframework.statemachine</groupId>
    <artifactId>spring-statemachine-core</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.28</version>
</dependency>

状态机配置

定义状态枚举和事件枚举作为状态机基础：

public enum States {
    STATE1, STATE2, STATE3
}
public enum Events {
    EVENT1, EVENT2, EVENT3
}

配置状态机模型，使用@EnableStateMachine注解启用：

@Configuration
@EnableStateMachine
public class StateMachineConfig extends EnumStateMachineConfigurerAdapter<States, Events> {
    
    @Override
    public void configure(StateMachineStateConfigurer<States, Events> states) throws Exception {
        states.withStates()
            .initial(States.STATE1)
            .states(EnumSet.allOf(States.class));
    }

    @Override
    public void configure(StateMachineTransitionConfigurer<States, Events> transitions) throws Exception {
        transitions
            .withExternal()
                .source(States.STATE1).target(States.STATE2)
                .event(Events.EVENT1)
            .and()
            .withExternal()
                .source(States.STATE2).target(States.STATE3)
                .event(Events.EVENT2);
    }
}

MySQL持久化实现

创建状态机上下文存储表结构：

CREATE TABLE state_machine_context (
    machine_id VARCHAR(36) PRIMARY KEY,
    state VARCHAR(50),
    context_data BLOB,
    created_time TIMESTAMP,
    modified_time TIMESTAMP
);

实现StateMachineRuntimePersister接口的自定义持久化类：

@Component
public class JpaStateMachinePersister implements StateMachineRuntimePersister<States, Events, String> {
    
    @Autowired
    private StateMachineContextRepository repository;

    @Override
    public StateMachineContext<States, Events> read(String contextObj) {
        return repository.findById(contextObj)
            .map(entity -> deserialize(entity.getContextData()))
            .orElse(null);
    }

    @Override
    public void write(StateMachineContext<States, Events> context, String contextObj) {
        StateMachineContextEntity entity = new StateMachineContextEntity();
        entity.setMachineId(contextObj);
        entity.setState(context.getState().toString());
        entity.setContextData(serialize(context));
        repository.save(entity);
    }
}

状态机服务封装

通过服务层封装状态机操作：

@Service
public class StateMachineService {
    
    @Autowired
    private StateMachine<States, Events> stateMachine;
    
    @Autowired
    private StateMachineRuntimePersister<States, Events, String> persister;

    public void execute(String businessId, Events event) {
        stateMachine.start();
        persister.restore(stateMachine, businessId);
        stateMachine.sendEvent(event);
        persister.persist(stateMachine, businessId);
    }
}

异常处理与恢复

实现状态机异常处理逻辑：

@Configuration
public class StateMachineErrorConfig {

    @Autowired
    private StateMachineRuntimePersister<States, Events, String> persister;

    @EventListener
    public void handleStateMachineError(StateMachineException event) {
        StateMachine<States, Events> sm = event.getStateMachine();
        String machineId = sm.getUuid().toString();
        persister.persist(sm, machineId);
    }
}

性能优化建议

对于高频状态转换场景，建议采用以下策略：

• 使用缓存减少数据库访问频率
• 批量处理状态转换事件
• 异步持久化机制

测试验证

编写集成测试验证状态持久化：

@SpringBootTest
public class StateMachineTest {
    
    @Autowired
    private StateMachineService service;

    @Test
    public void testStatePersistence() {
        String businessId = "order-123";
        service.execute(businessId, Events.EVENT1);
        service.execute(businessId, Events.EVENT2);
        // 验证数据库中的最终状态
    }
}