1. 状态模式基础解析
状态模式是行为型设计模式的一种，它允许对象在内部状态改变时改变其行为，使对象看起来像是修改了它的类。这种模式特别适合处理那些在不同状态下有不同行为的对象，避免了大量的条件判断语句。
1.1 状态模式三大核心组件
在Java中实现状态模式通常包含以下三个核心组件：
- 上下文（Context）：这是持有状态的对象，它会根据当前状态将行为委托给具体的状态对象。比如电商系统中的订单对象（Order），它会持有一个State接口的实例。
java复制public class Order {
private State currentState;
public void setState(State state) {
this.currentState = state;
}
public void handle() {
currentState.handle(this);
}
}
- 状态接口（State）：定义所有具体状态类需要实现的方法。这些方法通常以上下文对象作为参数，使得状态对象可以操作上下文。
java复制public interface State {
void handle(Order order);
}
- 具体状态（ConcreteState）：实现State接口，封装特定状态下的行为逻辑。例如：
java复制public class PendingState implements State {
@Override
public void handle(Order order) {
System.out.println("处理待支付订单");
// 业务逻辑...
order.setState(new PaidState());
}
}
public class PaidState implements State {
@Override
public void handle(Order order) {
System.out.println("处理已支付订单");
// 业务逻辑...
}
}
1.2 状态模式的优势
状态模式相比简单的条件判断有以下优势：
- 消除庞大的条件语句：将不同状态的行为分散到不同的状态类中，避免if-else或switch-case的膨胀
- 提高可扩展性：新增状态只需添加新的状态类，符合开闭原则
- 状态转换显式化：状态转换逻辑集中在状态类中，更易理解和维护
- 状态特定行为集中：每个状态的行为都封装在对应的类中，内聚性更高
提示：当发现一个类中有大量与对象状态相关的条件判断，且这些条件判断导致代码难以维护时，就应该考虑使用状态模式。
2. Java中的状态模式实践
2.1 线程池的状态管理实现
Java标准库中的ThreadPoolExecutor是状态模式的经典应用，虽然它的实现方式与教科书示例有所不同，但完全符合状态模式的核心思想。
2.1.1 线程池的五种状态
ThreadPoolExecutor定义了五种状态：
- RUNNING：正常运行状态，接受新任务并处理队列中的任务
- SHUTDOWN：关闭状态，不再接受新任务，但会处理完队列中的任务
- STOP：停止状态，不再接受新任务，也不处理队列中的任务，并中断正在执行的任务
- TIDYING：整理状态，所有任务已终止，workerCount为0，将执行terminated()钩子
- TERMINATED：终止状态，terminated()方法已完成
2.1.2 状态压缩与位运算优化
ThreadPoolExecutor采用了一种高效的实现方式，将状态(runState)和工作线程数(workerCount)压缩到一个原子整型变量ctl中：
java复制private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// 状态常量定义
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
这种设计有三大优势：
- 原子性保证：通过AtomicInteger保证状态和线程数的原子更新
- 空间效率：单个变量存储两种信息，减少内存占用
- 性能优化：位运算比对象引用更高效
2.1.3 状态相关的行为分派
在execute()方法中，根据当前状态决定行为：
java复制public void execute(Runnable command) {
if (command == null) throw new NullPointerException();
int c = ctl.get();
if (isRunning(c)) { // RUNNING状态
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true)) return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
// ...队列处理逻辑
} else if (!addWorker(command, false)) {
reject(command); // 拒绝策略
}
} else { // 非RUNNING状态
reject(command); // 直接拒绝
}
}
2.1.4 状态转换控制
状态转换通过advanceRunState()方法严格控制：
java复制private boolean advanceRunState(int targetState) {
for (;;) {
int c = ctl.get();
if (runStateAtLeast(c, targetState))
return false;
if (ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
return true;
}
}
这种实现确保了状态转换的原子性和线程安全性，同时遵循了状态只能向前推进的约束（RUNNING→SHUTDOWN→STOP→TIDYING→TERMINATED）。
2.2 状态模式与枚举的结合
Java枚举天然适合实现状态模式，特别是在状态数量固定且行为简单的场景：
java复制public enum OrderState {
PENDING {
@Override
public void handle(Order order) {
System.out.println("处理待支付订单");
order.setState(PAID);
}
},
PAID {
@Override
public void handle(Order order) {
System.out.println("处理已支付订单");
order.setState(SHIPPED);
}
},
SHIPPED {
@Override
public void handle(Order order) {
System.out.println("处理已发货订单");
}
};
public abstract void handle(Order order);
}
枚举实现的优势：
- 类型安全：编译器会检查状态转换的有效性
- 单例保证：每个枚举常量都是单例实例
- 代码简洁：将状态定义和行为集中在一处
3. 状态模式的高级应用技巧
3.1 状态转换的几种实现方式
在实际项目中，状态转换可以有以下几种实现方式：
- 由上下文控制转换：
java复制public class Order {
public void pay() {
if (currentState == PENDING) {
currentState = PAID;
} else {
throw new IllegalStateException();
}
}
}
- 由状态类控制转换（更符合纯状态模式）：
java复制public class PendingState implements State {
@Override
public void handle(Order order) {
// 业务逻辑...
order.setState(new PaidState());
}
}
- 使用状态机框架：对于复杂状态转换，可以使用Spring State Machine或Apache Commons SCXML等框架。
3.2 状态模式的线程安全性考虑
在多线程环境下使用状态模式需要注意：
- 状态变量的可见性：确保状态变量的修改对所有线程可见
java复制public class Order {
private volatile State currentState;
// 或使用原子引用
private final AtomicReference<State> stateRef = new AtomicReference<>();
}
- 状态转换的原子性：复杂的状态转换可能需要同步控制
java复制public synchronized void changeState(State newState) {
// 验证当前状态是否符合转换条件
if (currentState.canTransitionTo(newState)) {
currentState = newState;
}
}
- 无状态的状态对象：如果状态对象是无状态的（只有行为没有数据），可以共享实例减少对象创建
3.3 状态模式与策略模式的区别
状态模式和策略模式在结构上相似，但有以下关键区别：
| 特性 | 状态模式 | 策略模式 |
|---|---|---|
| 目的 | 处理对象内部状态变化引起的行为变化 | 封装可互换的算法或策略 |
| 状态知晓 | 状态对象通常知晓并可以触发状态转换 | 策略对象不知道其他策略的存在 |
| 运行时变化频率 | 状态可能在运行时频繁变化 | 策略通常在配置时选定，运行时较少变化 |
| 相互知晓 | 状态之间可能相互知晓，能触发彼此的状态转换 | 策略之间通常相互独立，不知道其他策略的存在 |
| 典型应用 | 订单状态、线程状态、游戏角色状态等 | 排序算法、压缩算法、支付方式等 |
4. 状态模式实战：电商订单系统案例
4.1 订单状态建模
一个典型的电商订单可能包含以下状态：
- 待支付（Pending）：订单刚创建，等待用户付款
- 已支付（Paid）：用户完成支付，等待商家发货
- 已发货（Shipped）：商家已发货，等待用户确认收货
- 已完成（Completed）：用户确认收货，订单完成
- 已取消（Canceled）：订单被取消
- 已退款（Refunded）：订单已退款
4.2 完整实现示例
java复制// 状态接口
public interface OrderState {
void pay(Order order);
void ship(Order order);
void receive(Order order);
void cancel(Order order);
void refund(Order order);
}
// 具体状态实现
public class PendingState implements OrderState {
@Override
public void pay(Order order) {
System.out.println("处理支付...");
order.setState(new PaidState());
}
@Override
public void cancel(Order order) {
System.out.println("取消待支付订单...");
order.setState(new CanceledState());
}
// 其他方法抛出UnsupportedOperationException
}
public class PaidState implements OrderState {
@Override
public void ship(Order order) {
System.out.println("处理发货...");
order.setState(new ShippedState());
}
@Override
public void refund(Order order) {
System.out.println("处理退款...");
order.setState(new RefundedState());
}
// ...
}
// 上下文类
public class Order {
private OrderState currentState;
public Order() {
this.currentState = new PendingState();
}
public void setState(OrderState state) {
this.currentState = state;
}
// 委托给当前状态
public void pay() { currentState.pay(this); }
public void ship() { currentState.ship(this); }
public void receive() { currentState.receive(this); }
public void cancel() { currentState.cancel(this); }
public void refund() { currentState.refund(this); }
}
4.3 状态转换规则管理
对于复杂的业务系统，建议将状态转换规则外部化，可以使用：
- 规则引擎：Drools等规则引擎管理状态转换规则
- 状态机配置：XML或注解定义状态转换
- 数据库存储：将状态转换规则存储在数据库，实现动态配置
例如使用Spring State Machine：
java复制@Configuration
@EnableStateMachine
public class OrderStateMachineConfig extends EnumStateMachineConfigurerAdapter<OrderState, OrderEvent> {
@Override
public void configure(StateMachineStateConfigurer<OrderState, OrderEvent> states) throws Exception {
states.withStates()
.initial(OrderState.PENDING)
.states(EnumSet.allOf(OrderState.class));
}
@Override
public void configure(StateMachineTransitionConfigurer<OrderState, OrderEvent> transitions) throws Exception {
transitions
.withExternal()
.source(OrderState.PENDING).target(OrderState.PAID)
.event(OrderEvent.PAY)
.and()
.withExternal()
.source(OrderState.PAID).target(OrderState.SHIPPED)
.event(OrderEvent.SHIP);
// 其他转换规则...
}
}
5. 状态模式的最佳实践与陷阱
5.1 最佳实践
- 将状态对象设计为不可变：一旦创建就不变，避免状态对象本身的状态问题
- 考虑使用享元模式：如果状态对象无实例变量，可以共享使用
- 明确状态转换约束：在代码或文档中清晰定义哪些状态可以转换到哪些状态
- 使用Null Object模式：为无效操作提供默认行为，而不是抛出异常
- 考虑异步状态转换：对于耗时状态转换，可以使用异步方式避免阻塞
5.2 常见陷阱与解决方案
-
状态爆炸问题：
- 问题：随着业务复杂，状态类数量急剧增加
- 解决方案：使用层次状态（父状态和子状态），或将部分状态用参数表示
-
循环依赖问题：
- 问题：状态类需要了解上下文，上下文又持有状态，导致循环依赖
- 解决方案：使用接口隔离，或通过事件解耦
-
线程安全问题：
- 问题：多线程环境下状态转换可能导致竞态条件
- 解决方案：使用原子引用或适当的同步控制
-
状态持久化问题：
- 问题：如何将对象及其状态保存到数据库
- 解决方案：使用状态编码（如字符串或数字）而非直接保存状态对象
-
测试复杂性：
- 问题：状态多导致测试用例组合爆炸
- 解决方案：使用状态机测试工具，或基于场景的测试方法
5.3 性能优化技巧
- 状态对象池化：对于频繁创建销毁的状态对象，可以使用对象池
- 延迟初始化：在状态第一次使用时才创建状态对象
- 缓存状态转换结果：对于计算密集型的状态转换，可以缓存结果
- 使用轻量级状态标识：在内存敏感场景，可以用枚举或标志位代替完整对象
状态模式是处理对象行为随状态变化的强大工具，正确使用可以使代码更清晰、更易维护。在Java生态中，从简单的枚举实现到复杂的Spring StateMachine，开发者可以根据项目需求选择适当的实现方式。关键是要深入理解业务的状态转换需求，设计出既灵活又可控的状态管理系统。