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

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

我将为你设计一个简化版的状态机框架，包含状态、事件、转换机制，并支持插件扩展功能。这个实现会参考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());

    }

}

进一步扩展建议

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