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

状态模式与订单状态机的实现

news 2026/2/8 17:17:10

状态模式

状态模式（State Design Pattern）是一种行为设计模式，用于在对象的内部状态改变时改变其行为。这种模式可以将状态的变化封装在状态对象中，使得对象在状态变化时不会影响到其他代码，提升了代码的灵活性和可维护性。

状态设计模式的主要组成部分

上下文（Context）：持有一个状态对象的引用，用于调用当前状态的行为。
状态接口（State Interface）：定义一个接口，声明了状态对象的行为。
具体状态类（Concrete State Classes）：实现状态接口，定义在特定状态下的具体行为。

实现步骤

1. 定义状态接口

定义一个状态接口或抽象类，声明所有具体状态类需要实现的方法。

public interface OrderState {void handlePayment(OrderContext context);void handleCancellation(OrderContext context);void handleCompletion(OrderContext context);
}

2. 实现具体状态类

每个具体状态类实现状态接口，定义在该状态下的具体行为。

public class PendingPaymentState implements OrderState {@Overridepublic void handlePayment(OrderContext context) {System.out.println("Processing payment...");context.setState(new PaidState());}@Overridepublic void handleCancellation(OrderContext context) {System.out.println("Order cancelled.");context.setState(new CancelledState());}@Overridepublic void handleCompletion(OrderContext context) {System.out.println("Order cannot be completed before payment.");}
}public class PaidState implements OrderState {@Overridepublic void handlePayment(OrderContext context) {System.out.println("Order already paid.");}@Overridepublic void handleCancellation(OrderContext context) {System.out.println("Order cancelled.");context.setState(new CancelledState());}@Overridepublic void handleCompletion(OrderContext context) {System.out.println("Order completed.");context.setState(new CompletedState());}
}public class CancelledState implements OrderState {@Overridepublic void handlePayment(OrderContext context) {System.out.println("Cannot process payment. Order is cancelled.");}@Overridepublic void handleCancellation(OrderContext context) {System.out.println("Order already cancelled.");}@Overridepublic void handleCompletion(OrderContext context) {System.out.println("Order cannot be completed after cancellation.");}
}public class CompletedState implements OrderState {@Overridepublic void handlePayment(OrderContext context) {System.out.println("Order already completed.");}@Overridepublic void handleCancellation(OrderContext context) {System.out.println("Order cannot be cancelled. It is already completed.");}@Overridepublic void handleCompletion(OrderContext context) {System.out.println("Order already completed.");}
}

3. 定义上下文类

上下文类持有一个当前状态的引用，并允许状态对象修改它的状态。

public class OrderContext {private OrderState currentState;public OrderContext() {// 默认初始状态currentState = new PendingPaymentState();}public void setState(OrderState state) {this.currentState = state;}public void handlePayment() {currentState.handlePayment(this);}public void handleCancellation() {currentState.handleCancellation(this);}public void handleCompletion() {currentState.handleCompletion(this);}
}

使用示例

你可以创建一个OrderContext实例，并通过调用状态处理方法来改变订单的状态。

public class Main {public static void main(String[] args) {OrderContext order = new OrderContext();order.handlePayment(); // 处理支付，状态变为PaidStateorder.handleCompletion(); // 完成订单，状态变为CompletedStateorder.handleCancellation(); // 无法取消，订单已完成}
}

总结

状态模式通过将状态行为分离到不同的状态类中，允许对象在其状态改变时改变其行为。这种模式提供了一种优雅的方式来处理状态变化，避免了在上下文类中使用大量的条件判断，提高了代码的可维护性和扩展性。在实际应用中，可以使用状态设计模式来管理各种状态驱动的行为，比如订单状态、工作流状态等。

订单状态机的实现

订单状态机的实现通常包括设计状态的枚举类型、定义状态转换规则和编写状态转换逻辑。下面是一个实现订单状态机的详细步骤和示例代码：

1. 定义订单状态枚举

首先定义一个枚举类型来表示订单的各种状态：

public enum OrderStatus {PENDING_PAYMENT, // 待支付PAID,            // 已支付CANCELLED,       // 已取消COMPLETED        // 已完成
}

2. 定义订单状态转换规则

通过状态机的方式定义各个状态之间的转换规则。可以使用第三方状态机库（如Spring State Machine）或者自定义状态机逻辑。下面是使用自定义状态机逻辑的示例：

public class OrderStateMachine {private OrderStatus currentState;public OrderStateMachine(OrderStatus initialState) {this.currentState = initialState;}public OrderStatus getCurrentState() {return currentState;}public boolean transition(OrderEvent event) {switch (currentState) {case PENDING_PAYMENT:if (event == OrderEvent.PAY) {currentState = OrderStatus.PAID;return true;} else if (event == OrderEvent.CANCEL) {currentState = OrderStatus.CANCELLED;return true;}break;case PAID:if (event == OrderEvent.COMPLETE) {currentState = OrderStatus.COMPLETED;return true;} else if (event == OrderEvent.CANCEL) {currentState = OrderStatus.CANCELLED;return true;}break;case COMPLETED:// Completed orders cannot transition to another statebreak;case CANCELLED:// Cancelled orders cannot transition to another statebreak;}return false; // Invalid transition}
}

3. 定义订单事件枚举

定义可以触发状态转换的事件：

public enum OrderEvent {PAY,       // 支付CANCEL,    // 取消COMPLETE   // 完成
}

4. 使用状态机处理订单状态转换

在订单服务中使用状态机来处理订单状态转换：

public class OrderService {public boolean processOrderEvent(Order order, OrderEvent event) {OrderStateMachine stateMachine = new OrderStateMachine(order.getStatus());boolean success = stateMachine.transition(event);if (success) {order.setStatus(stateMachine.getCurrentState());// 持久化订单状态到数据库orderRepository.save(order);}return success;}
}

5. 订单服务中的状态机集成示例

假设我们有一个订单服务类，在其中集成状态机逻辑：

@Service
public class OrderService {@Autowiredprivate OrderRepository orderRepository;public boolean createOrder(Order order) {order.setStatus(OrderStatus.PENDING_PAYMENT);orderRepository.save(order);return true;}public boolean payOrder(Long orderId) {Order order = orderRepository.findById(orderId).orElseThrow(() -> new OrderNotFoundException(orderId));return processOrderEvent(order, OrderEvent.PAY);}public boolean completeOrder(Long orderId) {Order order = orderRepository.findById(orderId).orElseThrow(() -> new OrderNotFoundException(orderId));return processOrderEvent(order, OrderEvent.COMPLETE);}public boolean cancelOrder(Long orderId) {Order order = orderRepository.findById(orderId).orElseThrow(() -> new OrderNotFoundException(orderId));return processOrderEvent(order, OrderEvent.CANCEL);}private boolean processOrderEvent(Order order, OrderEvent event) {OrderStateMachine stateMachine = new OrderStateMachine(order.getStatus());boolean success = stateMachine.transition(event);if (success) {order.setStatus(stateMachine.getCurrentState());orderRepository.save(order);}return success;}
}

总结

通过上述步骤，我们实现了一个简单的订单状态机，涵盖订单从创建到完成或取消的状态转换。使用状态机不仅使订单状态的管理更加清晰和可维护，还能够有效防止状态的不一致性，提高系统的可靠性。在实际项目中，可以根据具体需求选择使用状态机库（如Spring State Machine）来简化实现。