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

状态模式

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

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

1. 上下文（Context）：持有一个状态对象的引用，用于调用当前状态的行为。
2. 状态接口（State Interface）：定义一个接口，声明了状态对象的行为。
3. 具体状态类（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 {
    @Override
    public void handlePayment(OrderContext context) {
        System.out.println("Processing payment...");
        context.setState(new PaidState());
    }

    @Override
    public void handleCancellation(OrderContext context) {
        System.out.println("Order cancelled.");
        context.setState(new CancelledState());
    }

    @Override
    public void handleCompletion(OrderContext context) {
        System.out.println("Order cannot be completed before payment.");
    }
}

public class PaidState implements OrderState {
    @Override
    public void handlePayment(OrderContext context) {
        System.out.println("Order already paid.");
    }

    @Override
    public void handleCancellation(OrderContext context) {
        System.out.println("Order cancelled.");
        context.setState(new CancelledState());
    }

    @Override
    public void handleCompletion(OrderContext context) {
        System.out.println("Order completed.");
        context.setState(new CompletedState());
    }
}

public class CancelledState implements OrderState {
    @Override
    public void handlePayment(OrderContext context) {
        System.out.println("Cannot process payment. Order is cancelled.");
    }

    @Override
    public void handleCancellation(OrderContext context) {
        System.out.println("Order already cancelled.");
    }

    @Override
    public void handleCompletion(OrderContext context) {
        System.out.println("Order cannot be completed after cancellation.");
    }
}

public class CompletedState implements OrderState {
    @Override
    public void handlePayment(OrderContext context) {
        System.out.println("Order already completed.");
    }

    @Override
    public void handleCancellation(OrderContext context) {
        System.out.println("Order cannot be cancelled. It is already completed.");
    }

    @Override
    public 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(); // 处理支付，状态变为PaidState
        order.handleCompletion(); // 完成订单，状态变为CompletedState
        order.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 state
                break;

            case CANCELLED:
                // Cancelled orders cannot transition to another state
                break;
        }
        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 {
    @Autowired
    private 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）来简化实现。