当前位置： 首页 > news >正文

设计模式-状态模式详解

news 2025/9/24 8:19:51

状态模式详解

目录

  1. 状态模式简介
  2. 核心流程
  3. 重难点分析
  4. Spring中的源码分析
  5. 具体使用场景
  6. 面试高频点
  7. 使用总结

状态模式简介

定义

状态模式（State Pattern）是一种行为型设计模式，它允许对象在内部状态发生改变时改变它的行为，对象看起来好像修改了它的类。状态模式将状态封装成独立的类，并将动作委托到代表当前状态的对象。

核心思想

  • 状态封装：将每个状态封装成独立的类
  • 行为委托：将行为委托给当前状态对象
  • 状态转换：通过状态对象管理状态转换
  • 消除条件判断：用多态替代大量的条件判断

模式结构

  • Context（环境类）：定义客户感兴趣的接口，维护一个ConcreteState子类的实例
  • State（抽象状态类）：定义一个接口以封装与Context的一个特定状态相关的行为
  • ConcreteState（具体状态类）：实现抽象状态类，每一个子类实现一个与Context的一个状态相关的行为

核心流程

状态模式流程图

状态转换
状态类层次
环境类层次
是
否
状态A -> 状态B
状态B -> 状态C
状态C -> 状态A
State抽象状态
ConcreteStateA
ConcreteStateB
ConcreteStateC
Context环境类
状态引用
状态转换方法
客户端
创建环境对象
设置初始状态
调用环境对象方法
环境对象委托给当前状态
当前状态处理请求
是否需要状态转换?
状态对象执行状态转换
返回处理结果
更新环境对象状态
返回处理结果
客户端接收结果

基本实现流程

1. 定义抽象状态类
// 抽象状态类
public abstract class State {protected Context context;public void setContext(Context context) {this.context = context;}public abstract void handleRequest1();public abstract void handleRequest2();public abstract void handleRequest3();// 状态转换方法protected void changeState(State newState) {context.changeState(newState);}
}
2. 定义环境类
// 环境类
public class Context {private State currentState;public Context() {// 设置初始状态this.currentState = new ConcreteStateA();this.currentState.setContext(this);}public void changeState(State newState) {this.currentState = newState;this.currentState.setContext(this);System.out.println("状态转换到: " + newState.getClass().getSimpleName());}public void request1() {currentState.handleRequest1();}public void request2() {currentState.handleRequest2();}public void request3() {currentState.handleRequest3();}public State getCurrentState() {return currentState;}
}
3. 实现具体状态类
// 具体状态A
public class ConcreteStateA extends State {@Overridepublic void handleRequest1() {System.out.println("状态A处理请求1");// 状态A处理请求1的逻辑}@Overridepublic void handleRequest2() {System.out.println("状态A处理请求2，转换到状态B");changeState(new ConcreteStateB());}@Overridepublic void handleRequest3() {System.out.println("状态A处理请求3，转换到状态C");changeState(new ConcreteStateC());}
}// 具体状态B
public class ConcreteStateB extends State {@Overridepublic void handleRequest1() {System.out.println("状态B处理请求1，转换到状态A");changeState(new ConcreteStateA());}@Overridepublic void handleRequest2() {System.out.println("状态B处理请求2");// 状态B处理请求2的逻辑}@Overridepublic void handleRequest3() {System.out.println("状态B处理请求3，转换到状态C");changeState(new ConcreteStateC());}
}// 具体状态C
public class ConcreteStateC extends State {@Overridepublic void handleRequest1() {System.out.println("状态C处理请求1，转换到状态A");changeState(new ConcreteStateA());}@Overridepublic void handleRequest2() {System.out.println("状态C处理请求2，转换到状态B");changeState(new ConcreteStateB());}@Overridepublic void handleRequest3() {System.out.println("状态C处理请求3");// 状态C处理请求3的逻辑}
}
4. 客户端使用
public class Client {public static void main(String[] args) {Context context = new Context();// 初始状态是ASystem.out.println("当前状态: " + context.getCurrentState().getClass().getSimpleName());// 测试状态转换context.request1(); // 状态A处理请求1context.request2(); // 状态A -> 状态Bcontext.request2(); // 状态B处理请求2context.request3(); // 状态B -> 状态Ccontext.request3(); // 状态C处理请求3context.request1(); // 状态C -> 状态A}
}

重难点分析

重难点1：状态转换的复杂性

问题描述

当状态转换逻辑复杂时，如何管理状态之间的转换关系。

解决方案
// 状态转换表
public class StateTransitionTable {private final Map<State, Map<String, State>> transitions = new HashMap<>();public void addTransition(State from, String event, State to) {transitions.computeIfAbsent(from, k -> new HashMap<>()).put(event, to);}public State getNextState(State currentState, String event) {Map<String, State> stateTransitions = transitions.get(currentState);if (stateTransitions != null) {return stateTransitions.get(event);}return null;}
}// 使用状态转换表的状态机
public class StateMachine {private State currentState;private final StateTransitionTable transitionTable;public StateMachine(State initialState, StateTransitionTable transitionTable) {this.currentState = initialState;this.transitionTable = transitionTable;this.currentState.setContext(this);}public void handleEvent(String event) {State nextState = transitionTable.getNextState(currentState, event);if (nextState != null) {changeState(nextState);} else {System.out.println("无效的状态转换: " + currentState.getClass().getSimpleName() + " -> " + event);}}private void changeState(State newState) {this.currentState = newState;this.currentState.setContext(this);System.out.println("状态转换到: " + newState.getClass().getSimpleName());}
}// 状态转换规则
public class StateTransitionRules {public static StateTransitionTable createOrderStateTransitionTable() {StateTransitionTable table = new StateTransitionTable();// 订单状态转换规则OrderState pending = new OrderState("PENDING");OrderState confirmed = new OrderState("CONFIRMED");OrderState shipped = new OrderState("SHIPPED");OrderState delivered = new OrderState("DELIVERED");OrderState cancelled = new OrderState("CANCELLED");// 添加转换规则table.addTransition(pending, "CONFIRM", confirmed);table.addTransition(pending, "CANCEL", cancelled);table.addTransition(confirmed, "SHIP", shipped);table.addTransition(confirmed, "CANCEL", cancelled);table.addTransition(shipped, "DELIVER", delivered);return table;}
}

重难点2：状态的历史记录

问题描述

如何记录状态转换的历史，支持状态回滚和重放。

解决方案
// 状态历史记录
public class StateHistory {private final List<StateRecord> history = new ArrayList<>();private int currentIndex = -1;public void addState(State state, String event) {// 移除当前位置之后的所有记录if (currentIndex < history.size() - 1) {history.subList(currentIndex + 1, history.size()).clear();}StateRecord record = new StateRecord(state, event, System.currentTimeMillis());history.add(record);currentIndex = history.size() - 1;}public StateRecord getCurrentState() {if (currentIndex >= 0 && currentIndex < history.size()) {return history.get(currentIndex);}return null;}public StateRecord getPreviousState() {if (currentIndex > 0) {currentIndex--;return history.get(currentIndex);}return null;}public StateRecord getNextState() {if (currentIndex < history.size() - 1) {currentIndex++;return history.get(currentIndex);}return null;}public List<StateRecord> getHistory() {return new ArrayList<>(history);}
}// 状态记录
public class StateRecord {private final State state;private final String event;private final long timestamp;public StateRecord(State state, String event, long timestamp) {this.state = state;this.event = event;this.timestamp = timestamp;}// getter方法public State getState() { return state; }public String getEvent() { return event; }public long getTimestamp() { return timestamp; }
}// 支持历史记录的状态机
public class HistoricalStateMachine extends StateMachine {private final StateHistory history;public HistoricalStateMachine(State initialState, StateTransitionTable transitionTable) {super(initialState, transitionTable);this.history = new StateHistory();this.history.addState(initialState, "INITIAL");}@Overridepublic void handleEvent(String event) {State nextState = transitionTable.getNextState(currentState, event);if (nextState != null) {history.addState(nextState, event);changeState(nextState);} else {System.out.println("无效的状态转换: " + currentState.getClass().getSimpleName() + " -> " + event);}}public void rollback() {StateRecord previousState = history.getPreviousState();if (previousState != null) {changeState(previousState.getState());}}public void replay() {StateRecord nextState = history.getNextState();if (nextState != null) {changeState(nextState.getState());}}
}

重难点3：状态的并发安全

问题描述

在多线程环境下，如何确保状态转换的线程安全。

解决方案
// 线程安全的状态机
public class ThreadSafeStateMachine {private volatile State currentState;private final Object stateLock = new Object();private final StateTransitionTable transitionTable;public ThreadSafeStateMachine(State initialState, StateTransitionTable transitionTable) {this.currentState = initialState;this.transitionTable = transitionTable;this.currentState.setContext(this);}public void handleEvent(String event) {synchronized (stateLock) {State nextState = transitionTable.getNextState(currentState, event);if (nextState != null) {changeState(nextState);} else {System.out.println("无效的状态转换: " + currentState.getClass().getSimpleName() + " -> " + event);}}}private void changeState(State newState) {this.currentState = newState;this.currentState.setContext(this);System.out.println("状态转换到: " + newState.getClass().getSimpleName());}public State getCurrentState() {return currentState;}
}// 使用原子操作的状态机
public class AtomicStateMachine {private final AtomicReference<State> currentState;private final StateTransitionTable transitionTable;public AtomicStateMachine(State initialState, StateTransitionTable transitionTable) {this.currentState = new AtomicReference<>(initialState);this.transitionTable = transitionTable;this.currentState.get().setContext(this);}public void handleEvent(String event) {State current = currentState.get();State nextState = transitionTable.getNextState(current, event);if (nextState != null) {if (currentState.compareAndSet(current, nextState)) {nextState.setContext(this);System.out.println("状态转换到: " + nextState.getClass().getSimpleName());} else {// 状态已被其他线程修改，重试handleEvent(event);}} else {System.out.println("无效的状态转换: " + current.getClass().getSimpleName() + " -> " + event);}}public State getCurrentState() {return currentState.get();}
}

重难点4：状态的持久化

问题描述

如何将状态信息持久化到数据库或文件中，支持系统重启后的状态恢复。

解决方案
// 状态持久化接口
public interface StatePersistence {void saveState(String contextId, State state);State loadState(String contextId);void saveStateHistory(String contextId, List<StateRecord> history);List<StateRecord> loadStateHistory(String contextId);
}// 数据库状态持久化
public class DatabaseStatePersistence implements StatePersistence {private final JdbcTemplate jdbcTemplate;public DatabaseStatePersistence(JdbcTemplate jdbcTemplate) {this.jdbcTemplate = jdbcTemplate;}@Overridepublic void saveState(String contextId, State state) {String sql = "INSERT INTO state_context (context_id, state_class, state_data, created_at) VALUES (?, ?, ?, ?) " +"ON DUPLICATE KEY UPDATE state_class = ?, state_data = ?, updated_at = ?";jdbcTemplate.update(sql, contextId, state.getClass().getName(), serializeState(state), new Date(),state.getClass().getName(), serializeState(state), new Date());}@Overridepublic State loadState(String contextId) {String sql = "SELECT state_class, state_data FROM state_context WHERE context_id = ?";try {return jdbcTemplate.queryForObject(sql, (rs, rowNum) -> {String stateClass = rs.getString("state_class");String stateData = rs.getString("state_data");return deserializeState(stateClass, stateData);}, contextId);} catch (EmptyResultDataAccessException e) {return null;}}private String serializeState(State state) {// 序列化状态对象return JSON.toJSONString(state);}private State deserializeState(String stateClass, String stateData) {// 反序列化状态对象try {Class<?> clazz = Class.forName(stateClass);return (State) JSON.parseObject(stateData, clazz);} catch (ClassNotFoundException e) {throw new RuntimeException("无法加载状态类: " + stateClass, e);}}
}// 支持持久化的状态机
public class PersistentStateMachine extends StateMachine {private final StatePersistence persistence;private final String contextId;public PersistentStateMachine(String contextId, State initialState, StateTransitionTable transitionTable, StatePersistence persistence) {super(initialState, transitionTable);this.contextId = contextId;this.persistence = persistence;// 尝试从持久化存储中恢复状态State savedState = persistence.loadState(contextId);if (savedState != null) {this.currentState = savedState;this.currentState.setContext(this);}}@Overridepublic void handleEvent(String event) {super.handleEvent(event);// 保存状态到持久化存储persistence.saveState(contextId, currentState);}
}

Spring中的源码分析

Spring的状态机实现

// Spring StateMachine接口
public interface StateMachine<S, E> extends StateMachineAccessor<S, E> {void start();void stop();boolean sendEvent(E event);boolean sendEvent(Message<E> event);void setStateMachineErrorHandler(StateMachineErrorHandler errorHandler);void addStateListener(StateMachineListener<S, E> listener);void removeStateListener(StateMachineListener<S, E> listener);
}// Spring StateMachineConfigurer接口
public interface StateMachineConfigurer<S, E> {void configure(StateMachineStateConfigurer<S, E> states) throws Exception;void configure(StateMachineTransitionConfigurer<S, E> transitions) throws Exception;void configure(StateMachineConfigurationConfigurer<S, E> config) throws Exception;
}// Spring StateMachineBuilder
public class StateMachineBuilder<S, E> {public static <S, E> StateMachineBuilder<S, E> builder() {return new StateMachineBuilder<>();}public StateMachine<S, E> build() {return new DefaultStateMachine<>(stateMachineModel, stateMachineAccessor);}public StateMachineBuilder<S, E> configure(StateMachineConfigurer<S, E> configurer) {try {configurer.configure(states);configurer.configure(transitions);configurer.configure(config);} catch (Exception e) {throw new StateMachineException("Error configuring state machine", e);}return this;}
}

Spring的状态配置

// 状态配置
@Configuration
@EnableStateMachine
public class StateMachineConfig extends StateMachineConfigurerAdapter<String, String> {@Overridepublic void configure(StateMachineStateConfigurer<String, String> states) throws Exception {states.withStates().initial("SI").state("S1").state("S2").end("SF");}@Overridepublic void configure(StateMachineTransitionConfigurer<String, String> transitions) throws Exception {transitions.withExternal().source("SI").target("S1").event("E1").and().withExternal().source("S1").target("S2").event("E2").and().withExternal().source("S2").target("SF").event("E3");}
}// 状态机监听器
@Component
public class StateMachineListener implements StateMachineListener<String, String> {@Overridepublic void stateChanged(State<String, String> from, State<String, String> to) {System.out.println("状态转换: " + from.getId() + " -> " + to.getId());}@Overridepublic void stateEntered(State<String, String> state) {System.out.println("进入状态: " + state.getId());}@Overridepublic void stateExited(State<String, String> state) {System.out.println("退出状态: " + state.getId());}
}

Spring的状态机使用

// 状态机服务
@Service
public class StateMachineService {@Autowiredprivate StateMachine<String, String> stateMachine;public void startStateMachine() {stateMachine.start();}public void stopStateMachine() {stateMachine.stop();}public boolean sendEvent(String event) {return stateMachine.sendEvent(event);}public String getCurrentState() {return stateMachine.getState().getId();}
}// 状态机控制器
@RestController
@RequestMapping("/statemachine")
public class StateMachineController {@Autowiredprivate StateMachineService stateMachineService;@PostMapping("/start")public ResponseEntity<String> start() {stateMachineService.startStateMachine();return ResponseEntity.ok("状态机已启动");}@PostMapping("/stop")public ResponseEntity<String> stop() {stateMachineService.stopStateMachine();return ResponseEntity.ok("状态机已停止");}@PostMapping("/event")public ResponseEntity<String> sendEvent(@RequestParam String event) {boolean result = stateMachineService.sendEvent(event);if (result) {return ResponseEntity.ok("事件发送成功，当前状态: " + stateMachineService.getCurrentState());} else {return ResponseEntity.badRequest().body("事件发送失败");}}
}

具体使用场景

1. 订单状态管理

// 订单状态枚举
public enum OrderStatus {PENDING("待处理"),CONFIRMED("已确认"),SHIPPED("已发货"),DELIVERED("已送达"),CANCELLED("已取消");private final String description;OrderStatus(String description) {this.description = description;}public String getDescription() {return description;}
}// 订单状态机
public class OrderStateMachine {private OrderStatus currentStatus;private final Order order;public OrderStateMachine(Order order) {this.order = order;this.currentStatus = OrderStatus.PENDING;}public boolean confirm() {if (currentStatus == OrderStatus.PENDING) {currentStatus = OrderStatus.CONFIRMED;order.setStatus(currentStatus);order.setConfirmedAt(new Date());return true;}return false;}public boolean ship() {if (currentStatus == OrderStatus.CONFIRMED) {currentStatus = OrderStatus.SHIPPED;order.setStatus(currentStatus);order.setShippedAt(new Date());return true;}return false;}public boolean deliver() {if (currentStatus == OrderStatus.SHIPPED) {currentStatus = OrderStatus.DELIVERED;order.setStatus(currentStatus);order.setDeliveredAt(new Date());return true;}return false;}public boolean cancel() {if (currentStatus == OrderStatus.PENDING || currentStatus == OrderStatus.CONFIRMED) {currentStatus = OrderStatus.CANCELLED;order.setStatus(currentStatus);order.setCancelledAt(new Date());return true;}return false;}public OrderStatus getCurrentStatus() {return currentStatus;}
}// 订单类
public class Order {private String id;private String customerId;private List<OrderItem> items;private OrderStatus status;private Date createdAt;private Date confirmedAt;private Date shippedAt;private Date deliveredAt;private Date cancelledAt;// 构造函数、getter和setter方法public Order(String id, String customerId, List<OrderItem> items) {this.id = id;this.customerId = customerId;this.items = items;this.status = OrderStatus.PENDING;this.createdAt = new Date();}// getter和setter方法public String getId() { return id; }public String getCustomerId() { return customerId; }public List<OrderItem> getItems() { return items; }public OrderStatus getStatus() { return status; }public void setStatus(OrderStatus status) { this.status = status; }public Date getCreatedAt() { return createdAt; }public Date getConfirmedAt() { return confirmedAt; }public void setConfirmedAt(Date confirmedAt) { this.confirmedAt = confirmedAt; }public Date getShippedAt() { return shippedAt; }public void setShippedAt(Date shippedAt) { this.shippedAt = shippedAt; }public Date getDeliveredAt() { return deliveredAt; }public void setDeliveredAt(Date deliveredAt) { this.deliveredAt = deliveredAt; }public Date getCancelledAt() { return cancelledAt; }public void setCancelledAt(Date cancelledAt) { this.cancelledAt = cancelledAt; }
}

2. 游戏角色状态

// 游戏角色状态接口
public interface CharacterState {void move(Character character);void attack(Character character);void defend(Character character);void useSkill(Character character, String skill);
}// 正常状态
public class NormalState implements CharacterState {@Overridepublic void move(Character character) {System.out.println(character.getName() + " 正常移动");character.setPosition(character.getPosition() + 1);}@Overridepublic void attack(Character character) {System.out.println(character.getName() + " 发起攻击");character.setHealth(character.getHealth() - 10);}@Overridepublic void defend(Character character) {System.out.println(character.getName() + " 进入防御状态");character.setState(new DefendingState());}@Overridepublic void useSkill(Character character, String skill) {System.out.println(character.getName() + " 使用技能: " + skill);character.setMana(character.getMana() - 20);}
}// 防御状态
public class DefendingState implements CharacterState {@Overridepublic void move(Character character) {System.out.println(character.getName() + " 防御状态下移动缓慢");character.setPosition(character.getPosition() + 0.5);}@Overridepublic void attack(Character character) {System.out.println(character.getName() + " 防御状态下无法攻击");}@Overridepublic void defend(Character character) {System.out.println(character.getName() + " 继续防御");}@Overridepublic void useSkill(Character character, String skill) {System.out.println(character.getName() + " 防御状态下无法使用技能");}
}// 游戏角色类
public class Character {private String name;private int health;private int mana;private double position;private CharacterState state;public Character(String name) {this.name = name;this.health = 100;this.mana = 100;this.position = 0;this.state = new NormalState();}public void move() {state.move(this);}public void attack() {state.attack(this);}public void defend() {state.defend(this);}public void useSkill(String skill) {state.useSkill(this, skill);}// getter和setter方法public String getName() { return name; }public int getHealth() { return health; }public void setHealth(int health) { this.health = health; }public int getMana() { return mana; }public void setMana(int mana) { this.mana = mana; }public double getPosition() { return position; }public void setPosition(double position) { this.position = position; }public CharacterState getState() { return state; }public void setState(CharacterState state) { this.state = state; }
}

3. 工作流状态管理

// 工作流状态接口
public interface WorkflowState {void process(WorkflowContext context);boolean canTransitionTo(WorkflowState nextState);
}// 待审批状态
public class PendingApprovalState implements WorkflowState {@Overridepublic void process(WorkflowContext context) {System.out.println("工作流处于待审批状态");// 发送审批通知sendApprovalNotification(context);}@Overridepublic boolean canTransitionTo(WorkflowState nextState) {return nextState instanceof ApprovedState || nextState instanceof RejectedState;}private void sendApprovalNotification(WorkflowContext context) {System.out.println("发送审批通知给: " + context.getApprover());}
}// 已审批状态
public class ApprovedState implements WorkflowState {@Overridepublic void process(WorkflowContext context) {System.out.println("工作流已审批通过");// 执行后续流程executeNextStep(context);}@Overridepublic boolean canTransitionTo(WorkflowState nextState) {return nextState instanceof InProgressState || nextState instanceof CompletedState;}private void executeNextStep(WorkflowContext context) {System.out.println("执行下一步: " + context.getNextStep());}
}// 工作流上下文
public class WorkflowContext {private String workflowId;private String currentStep;private String nextStep;private String approver;private Map<String, Object> data;public WorkflowContext(String workflowId) {this.workflowId = workflowId;this.data = new HashMap<>();}// getter和setter方法public String getWorkflowId() { return workflowId; }public String getCurrentStep() { return currentStep; }public void setCurrentStep(String currentStep) { this.currentStep = currentStep; }public String getNextStep() { return nextStep; }public void setNextStep(String nextStep) { this.nextStep = nextStep; }public String getApprover() { return approver; }public void setApprover(String approver) { this.approver = approver; }public Map<String, Object> getData() { return data; }public void setData(Map<String, Object> data) { this.data = data; }
}

面试高频点

面试知识点思维导图

状态模式面试点
基本概念
实现方式
重难点
Spring应用
设计原则
实际应用
状态封装
行为委托
状态转换
消除条件判断
Context环境类
State抽象状态类
ConcreteState具体状态类
状态转换逻辑
状态转换复杂性
状态历史记录
并发安全
状态持久化
Spring StateMachine
状态配置
状态监听器
状态机服务
单一职责
开闭原则
依赖倒置
接口隔离
订单状态管理
游戏角色状态
工作流状态管理
系统状态控制

1. 状态模式的基本概念

问题：什么是状态模式？

答案要点：

  • 允许对象在内部状态发生改变时改变它的行为
  • 对象看起来好像修改了它的类
  • 将状态封装成独立的类，并将动作委托到代表当前状态的对象
  • 属于行为型设计模式
问题：状态模式有哪些角色？

答案要点：

  • Context（环境类）：定义客户感兴趣的接口，维护一个ConcreteState子类的实例
  • State（抽象状态类）：定义一个接口以封装与Context的一个特定状态相关的行为
  • ConcreteState（具体状态类）：实现抽象状态类，每一个子类实现一个与Context的一个状态相关的行为

2. 实现方式相关

问题：如何实现状态模式？

答案要点：

// 1. 定义抽象状态类
public abstract class State {protected Context context;public void setContext(Context context) {this.context = context;}public abstract void handleRequest();
}// 2. 定义环境类
public class Context {private State currentState;public void changeState(State newState) {this.currentState = newState;this.currentState.setContext(this);}public void request() {currentState.handleRequest();}
}// 3. 实现具体状态类
public class ConcreteStateA extends State {@Overridepublic void handleRequest() {System.out.println("状态A处理请求");context.changeState(new ConcreteStateB());}
}

3. 重难点问题

问题：状态模式与策略模式的区别？

答案要点：

  • 目的：状态模式是处理状态转换，策略模式是选择算法
  • 状态：状态模式有状态转换，策略模式没有状态
  • 耦合度：状态模式耦合度更高，策略模式耦合度更低
  • 使用场景：状态模式用于状态管理，策略模式用于算法选择
问题：如何解决状态转换的复杂性问题？

答案要点：

// 1. 使用状态转换表
public class StateTransitionTable {private final Map<State, Map<String, State>> transitions = new HashMap<>();public void addTransition(State from, String event, State to) {transitions.computeIfAbsent(from, k -> new HashMap<>()).put(event, to);}public State getNextState(State currentState, String event) {Map<String, State> stateTransitions = transitions.get(currentState);if (stateTransitions != null) {return stateTransitions.get(event);}return null;}
}// 2. 使用状态机模式
public class StateMachine {private State currentState;private final StateTransitionTable transitionTable;public void handleEvent(String event) {State nextState = transitionTable.getNextState(currentState, event);if (nextState != null) {changeState(nextState);}}
}

4. Spring中的应用

问题：Spring中如何使用状态模式？

答案要点：

// 1. 使用Spring StateMachine
@Configuration
@EnableStateMachine
public class StateMachineConfig extends StateMachineConfigurerAdapter<String, String> {@Overridepublic void configure(StateMachineStateConfigurer<String, String> states) throws Exception {states.withStates().initial("SI").state("S1").state("S2").end("SF");}@Overridepublic void configure(StateMachineTransitionConfigurer<String, String> transitions) throws Exception {transitions.withExternal().source("SI").target("S1").event("E1").and().withExternal().source("S1").target("S2").event("E2");}
}// 2. 使用状态机服务
@Service
public class StateMachineService {@Autowiredprivate StateMachine<String, String> stateMachine;public boolean sendEvent(String event) {return stateMachine.sendEvent(event);}
}

5. 设计原则相关

问题：状态模式体现了哪些设计原则？

答案要点：

  • 单一职责：每个状态类只负责一个状态的行为
  • 开闭原则：可以添加新的状态而不修改现有代码
  • 依赖倒置：依赖抽象而不是具体实现
  • 接口隔离：客户端只依赖需要的接口

6. 实际应用场景

问题：状态模式适用于哪些场景？

答案要点：

  • 订单状态管理：订单的创建、确认、发货、送达等状态
  • 游戏角色状态：角色的正常、防御、攻击等状态
  • 工作流状态管理：工作流的审批、执行、完成等状态
  • 系统状态控制：系统的启动、运行、停止等状态

使用总结

状态模式的优势

  1. 消除条件判断：用多态替代大量的条件判断
  2. 状态封装：将每个状态封装成独立的类
  3. 行为委托：将行为委托给当前状态对象
  4. 易于扩展：可以轻松添加新的状态

状态模式的缺点

  1. 复杂度增加：增加了系统的复杂度
  2. 状态转换：状态转换逻辑可能变得复杂
  3. 学习成本：需要理解状态模式的概念
  4. 过度设计：简单场景可能不需要使用

使用建议

  1. 复杂状态：只用于复杂的状态管理场景
  2. 状态转换：考虑状态转换的复杂性
  3. 并发安全：注意多线程环境下的状态安全
  4. 状态持久化：考虑状态的持久化需求

最佳实践

  1. 状态转换表：使用状态转换表管理复杂的状态转换
  2. 状态历史：记录状态转换的历史
  3. 并发安全：使用同步机制确保状态转换的线程安全
  4. 状态持久化：实现状态的持久化存储
  5. 单元测试：为状态模式编写完整的单元测试

与其他模式的对比

  1. 与策略模式：状态模式是状态转换，策略模式是算法选择
  2. 与命令模式：状态模式是状态管理，命令模式是请求封装
  3. 与观察者模式：状态模式是状态变化，观察者模式是状态通知

状态模式是一种有用的行为型设计模式，特别适用于需要管理复杂状态、消除条件判断、封装状态行为等场景。通过合理使用状态模式，可以大大提高代码的可维护性和可扩展性。

http://www.dtcms.com/a/398672.html

相关文章：

  • 微信小程序通用弹窗组件封装与动画实现
  • 「日拱一码」099 数据处理——降维
  • 速通ACM省铜第十三天 赋源码（Watermelon）
  • 【C++进阶系列】：位图和布隆过滤器（附模拟实现的源码）
  • 洛阳网站建设建站系统怎么删除网站的死链
  • 山东省城乡建设厅网站wordpress academia
  • 广州番禺服装网站建设济南网站优化
  • 下载huggingface中数据集/模型
  • vue事件循环机制
  • 分布式专题——19 Zookeeper分布式一致性协议ZAB源码剖析
  • 前端核心框架vue之（组件篇2/5）
  • 【分布式】分布式事务方案：两阶段、TCC、SEATA
  • Kafka介绍
  • Netty 解码器 DelimiterBasedFrameDecoder
  • 位运算 常见方法总结 算法练习 C++
  • 电子商务平台网站源码国外炫网站
  • PTZ相机的知识体系
  • Nginx反向代理配置全流程实战：从环境搭建到HTTPS部署
  • HTTPS 能抓包吗？实战答案与逐步可行方案（HTTPS 抓包原理、证书Pinning双向认证应对、工具对比）
  • 对网站建设的讲话wordpress 自定义面板
  • 【23】C++实战篇——C++报错：LNK2001：无法解析的外部符号 ，LNK2019: 无法解析的外部符号，原因分析及解决方法
  • 东莞建设银行官方网站礼品网站制作
  • TiDB Cloud 可观测性最佳实践
  • python+springboot毕业季旅游一站式定制服务系统
  • docker 启用容器端口被占用报错500
  • 无人机台风天通信技术要点
  • ParaZero-无人机降落伞领先开发商：SafeAir降落伞系统、DropAir精确空投系统、DefendAir反无人机系统
  • 手机怎样创建网站网站内容保护
  • 电路基础与PCB设计（一）电路
  • YOLO入门教程（四）：搭建YOLOv1网络