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

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

我将为你设计一个简化版的状态机框架，包含状态、事件、转换机制，并支持插件扩展功能。这个实现会参考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或其他表达式语言支持条件判断

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