实现一个简化版的状态机框架

实现一个简化版的状态机框架

我将为你设计一个简化版的状态机框架，包含状态、事件、转换机制，并支持插件扩展功能。这个实现会参考Spring StateMachine的设计理念。

核心组件设计

// 状态枚举接口 public interface State { String getId(); } // 事件枚举接口 public interface Event { String getId(); } // 状态上下文 public class StateContext<S extends State, E extends Event> { private S currentState; private E event; private Map<String, Object> extendedState = new HashMap<>(); // 获取当前状态 public S getCurrentState() { return currentState; } // 设置当前状态 public void setCurrentState(S currentState) { this.currentState = currentState; } // 获取触发事件 public E getEvent() { return event; } // 设置触发事件 public void setEvent(E event) { this.event = event; } // 获取扩展状态数据 public Map<String, Object> getExtendedState() { return extendedState; } // 添加扩展状态数据 public void addExtendedState(String key, Object value) { extendedState.put(key, value); } // 获取特定扩展状态数据 public Object getExtendedState(String key) { return extendedState.get(key); } } // 状态转换接口 public interface Transition<S extends State, E extends Event, C extends StateContext<S, E>> { boolean isTriggered(C context); S getSource(); S getTarget(); void executeActions(C context); } // 状态机接口 public interface StateMachine<S extends State, E extends Event, C extends StateContext<S, E>> { S getCurrentState(); void sendEvent(E event, Map<String, Object> extendedState); void addListener(StateMachineListener<S, E, C> listener); void addTransition(Transition<S, E, C> transition); } // 状态机监听器 public interface StateMachineListener<S extends State, E extends Event, C extends StateContext<S, E>> { void stateChanged(S from, S to); void eventAccepted(E event); void transitionStarted(Transition<S, E, C> transition); void transitionCompleted(Transition<S, E, C> transition); }

基础实现

// 枚举状态实现 public enum SimpleState implements State { INITIAL("INIT"), PROCESSING("PROCESS"), COMPLETED("COMPLETE"), ERROR("ERR"); private String id; SimpleState(String id) { this.id = id; } @Override public String getId() { return id; } } // 枚举事件实现 public enum SimpleEvent implements Event { START_PROCESS("START"), FINISH_PROCESS("FINISH"), ERROR_OCCURRED("ERROR"); private String id; SimpleEvent(String id) { this.id = id; } @Override public String getId() { return id; } } // 基础状态机实现 public class BasicStateMachine<S extends State, E extends Event, C extends StateContext<S, E>> implements StateMachine<S, E, C> { private S currentState; private List<Transition<S, E, C>> transitions = new ArrayList<>(); private List<StateMachineListener<S, E, C>> listeners = new ArrayList<>(); private StateMachineLogger logger = new StateMachineLogger(); public BasicStateMachine(S initialState) { this.currentState = initialState; } @Override public S getCurrentState() { return currentState; } @Override public void sendEvent(E event, Map<String, Object> extendedState) { logger.log("Processing event: " + event.getId()); // 创建状态上下文 StateContext<S, E> context = createContext(event, extendedState); // 通知监听器事件已接受 notifyEventAccepted(event); // 查找并执行适用的转换 for (Transition<S, E, C> transition : transitions) { if (transition.getSource().getId().equals(currentState.getId()) && transition.isTriggered((C) context)) { logger.log("Executing transition from " + currentState.getId() + " on " + event.getId()); // 通知监听器转换开始 notifyTransitionStarted(transition); // 执行转换动作 transition.executeActions((C) context); // 更新当前状态 currentState = transition.getTarget(); // 通知监听器状态改变 notifyStateChanged(transition.getSource(), transition.getTarget()); // 通知监听器转换完成 notifyTransitionCompleted(transition); break; } } } private StateContext<S, E> createContext(E event, Map<String, Object> extendedState) { StateContext<S, E> context = new StateContext<>(); context.setCurrentState(currentState); context.setEvent(event); if (extendedState != null) { extendedState.forEach((key, value) -> context.addExtendedState(key, value)); } return context; } @Override public void addListener(StateMachineListener<S, E, C> listener) { listeners.add(listener); } @Override public void addTransition(Transition<S, E, C> transition) { transitions.add(transition); } // 通知状态改变 private void notifyStateChanged(S from, S to) { listeners.forEach(listener -> listener.stateChanged(from, to)); } // 通知事件接受 private void notifyEventAccepted(E event) { listeners.forEach(listener -> listener.eventAccepted(event)); } // 通知转换开始 private void notifyTransitionStarted(Transition<S, E, C> transition) { listeners.forEach(listener -> listener.transitionStarted(transition)); } // 通知转换完成 private void notifyTransitionCompleted(Transition<S, E, C> transition) { listeners.forEach(listener -> listener.transitionCompleted(transition)); } // 日志工具类 private static class StateMachineLogger { public void log(String message) { System.out.println("[StateMachine] " + message); } } }

转换实现

// 条件转换抽象类 public abstract class AbstractTransition<S extends State, E extends Event, C extends StateContext<S, E>> implements Transition<S, E, C> { private S source; private S target; public AbstractTransition(S source, S target) { this.source = source; this.target = target; } @Override public S getSource() { return source; } @Override public S getTarget() { return target; } @Override public void executeActions(C context) { // 子类可以覆盖此方法以执行转换时的操作 } } // 基于事件的转换 public class EventBasedTransition<S extends State, E extends Event, C extends StateContext<S, E>> extends AbstractTransition<S, E, C> { private E event; private Consumer<C> action; public EventBasedTransition(S source, S target, E event) { this(source, target, event, null); } public EventBasedTransition(S source, S target, E event, Consumer<C> action) { super(source, target); this.event = event; this.action = action; } @Override public boolean isTriggered(C context) { return context.getEvent().getId().equals(event.getId()); } @Override public void executeActions(C context) { super.executeActions(context); if (action != null) { action.accept(context); } } } // 条件+事件混合转换 public class ConditionalTransition<S extends State, E extends Event, C extends StateContext<S, E>> extends AbstractTransition<S, E, C> { private E event; private Predicate<C> condition; private Consumer<C> action; public ConditionalTransition(S source, S target, E event, Predicate<C> condition) { this(source, target, event, condition, null); } public ConditionalTransition(S source, S target, E event, Predicate<C> condition, Consumer<C> action) { super(source, target); this.event = event; this.condition = condition; this.action = action; } @Override public boolean isTriggered(C context) { return context.getEvent().getId().equals(event.getId()) && condition.test(context); } @Override public void executeActions(C context) { super.executeActions(context); if (action != null) { action.accept(context); } } }

插件系统设计

// 插件接口 public interface StateMachinePlugin<S extends State, E extends Event, C extends StateContext<S, E>> { void configure(BasicStateMachine<S, E, C> machine); } // 插件支持的状态机 public class PluginEnabledStateMachine<S extends State, E extends Event, C extends StateContext<S, E>> extends BasicStateMachine<S, E, C> { private List<StateMachinePlugin<S, E, C>> plugins = new ArrayList<>(); public PluginEnabledStateMachine(S initialState) { super(initialState); } public void addPlugin(StateMachinePlugin<S, E, C> plugin) { plugins.add(plugin); plugin.configure(this); } } // 示例插件：自动日志记录插件 public class LoggingPlugin<S extends State, E extends Event, C extends StateContext<S, E>> implements StateMachinePlugin<S, E, C> { private final StateMachineLogger logger = new StateMachineLogger(); @Override public void configure(BasicStateMachine<S, E, C> machine) { machine.addListener(new StateMachineListener<S, E, C>() { @Override public void stateChanged(S from, S to) { logger.log("State changed from " + from.getId() + " to " + to.getId()); } @Override public void eventAccepted(E event) { logger.log("Event accepted: " + event.getId()); } @Override public void transitionStarted(Transition<S, E, C> transition) { logger.log("Transition started: " + transition.getSource().getId() + " -> " + transition.getTarget().getId()); } @Override public void transitionCompleted(Transition<S, E, C> transition) { logger.log("Transition completed: " + transition.getSource().getId() + " -> " + transition.getTarget().getId()); } }); } // 内部日志记录器 private static class StateMachineLogger { public void log(String message) { System.out.println("[StateMachine-LOG] " + message); } } } // 示例插件：持久化插件 public class PersistencePlugin<S extends State, E extends Event, C extends StateContext<S, E>> implements StateMachinePlugin<S, E, C>, StateMachineListener<S, E, C> { private final StateMachinePersister persister; public PersistencePlugin(StateMachinePersister persister) { this.persister = persister; } @Override public void configure(BasicStateMachine<S, E, C> machine) { machine.addListener(this); } @Override public void stateChanged(S from, S to) { persister.saveState(to); } @Override public void eventAccepted(E event) { // 不需要处理 } @Override public void transitionStarted(Transition<S, E, C> transition) { // 不需要处理 } @Override public void transitionCompleted(Transition<S, E, C> transition) { // 不需要处理 } // 持久化接口 public interface StateMachinePersister { void saveState(State state); State loadState(); } // 示例内存持久化实现 public static class InMemoryPersister implements StateMachinePersister { private State currentState; @Override public void saveState(State state) { currentState = state; } @Override public State loadState() { return currentState; } } }

使用示例

public class StateMachineDemo { public static void main(String[] args) { // 创建状态机并添加插件 PluginEnabledStateMachine<SimpleState, SimpleEvent, StateContext<SimpleState, SimpleEvent>> machine = new PluginEnabledStateMachine<>(SimpleState.INIT); machine.addPlugin(new LoggingPlugin<>()); InMemoryPersister persister = new PersistencePlugin.InMemoryPersister(); machine.addPlugin(new PersistencePlugin<>(persister)); // 定义状态转换 machine.addTransition(new EventBasedTransition<>( SimpleState.INIT, SimpleState.PROCESSING, SimpleEvent.START_PROCESS, context -> System.out.println("Starting processing..."))); machine.addTransition(new EventBasedTransition<>( SimpleState.PROCESSING, SimpleState.COMPLETED, SimpleEvent.FINISH_PROCESS, context -> System.out.println("Finishing process..."))); machine.addTransition(new EventBasedTransition<>( SimpleState.PROCESSING, SimpleState.ERROR, SimpleEvent.ERROR_OCCURRED, context -> System.out.println("Error occurred during processing"))); // 测试状态转换 System.out.println("Initial state: " + machine.getCurrentState().getId()); System.out.println("\nSending START_PROCESS event:"); machine.sendEvent(SimpleEvent.START_PROCESS, null); System.out.println("Current state: " + machine.getCurrentState().getId()); System.out.println("\nSending FINISH_PROCESS event:"); machine.sendEvent(SimpleEvent.FINISH_PROCESS, null); System.out.println("Current state: " + machine.getCurrentState().getId()); // 测试持久化 System.out.println("\nTesting persistence..."); ((PersistencePlugin.InMemoryPersister) persister).saveState(SimpleState.INIT); SimpleState restoredState = (SimpleState) persister.loadState(); System.out.println("Restored state: " + restoredState.getId()); } }

进一步扩展建议

1. 分层状态机：实现父子状态机结构，支持复合状态和子状态机

2. 历史状态：添加对历史状态的支持，允许状态机返回到之前的某个状态

3. 伪状态：实现初始状态、终止状态等特殊状态类型

4. 转换类型：增加外部转换、内部转换、本地转换等不同类型的转换

5. 配置DSL：创建流畅的API用于配置状态机，类似：

   machine.configure() .from(INIT).on(START_PROCESS).to(PROCESSING) .perform(action)

6. 持久化策略：添加更多持久化选项（数据库、文件等）

7. 监控插件：添加性能监控、统计信息收集等插件

8. 分布式支持：添加集群环境下状态同步的支持

9. 异常处理：完善异常处理机制，支持在转换中处理异常

10. 表达式支持：集成SpEL或其他表达式语言支持条件判断

这个实现提供了一个灵活的状态机框架基础，可以根据具体需求进一步扩展和完善。