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

ShooterJ2025-06-05 17:48

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

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

核心组件设计

java 复制代码 
// 状态枚举接口
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);
}

基础实现

java 复制代码 
// 枚举状态实现
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);
        }
    }
}

转换实现

java 复制代码 
// 条件转换抽象类
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);
        }
    }
}

插件系统设计

java 复制代码 
// 插件接口
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;
        }
    }
}

使用示例

java 复制代码 
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用于配置状态机，类似：

    java 复制代码 
    machine.configure()
    .from(INIT).on(START_PROCESS).to(PROCESSING)
    .perform(action)

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

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

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

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

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

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

相关推荐
颜酱19 分钟前
# 02 | 搭骨架：用 LangGraph 编排 12 步工作流（思路）
前端·人工智能·后端
颜酱20 分钟前
02 | 搭骨架：用 LangGraph 编排 12 步工作流
前端·人工智能·后端
嘉伟桑1 小时前
Python调用电价API返回JSON示例：分时电价、现货电价和字段解析
后端
武子康2 小时前
Shippy：确定性工具、会话级 Sandbox 与 Live-Data Eval（4 类收敛 + 7 步实现方案 + 6 类评测指标）
前端·人工智能·后端
我叫黑大帅2 小时前
我为什么单一消费者的场景下，要用 Redis List 当消息队列？
redis·后端·面试
AskHarries2 小时前
文件上传系统
后端
止语Lab3 小时前
好的 DX 不等于少写代码——三种语言的摩擦力设计课
后端
吃饱了得干活3 小时前
别再手动解析 LLM 输出了！LangChain 四种结构化输出方案对比
后端·python·langchain
程序员天天困3 小时前
Arthas trace 命令怎么用？一行定位最慢那行代码
jvm·后端
Huiturn3 小时前
GPT 5.6 连续编码 10 小时，纯 Python 啃下 Word 二进制格式——doc2docx 实现拆解
后端
热门推荐
012026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片02GitHub 镜像站点03如何新建文件夹？ 电脑新建文件夹的4种方法04AI科技热点日报 | 2026年07月01日05幻兽帕鲁 - 服务器管理员权限与 GM 命令完全指南06国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）07AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路082026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？092026 年 AI 大模型 & AI 编程工具实战全总结10【解构】DeepSeek V4 发布：技术报告深度解读 + 横向对比六大开源模型，我们的判断是……