Java 订单状态机设计模式实现详解

订单状态机是一种行为型设计模式，它可以帮助我们实现对订单状态的管理和控制。下面是一个简单的Java实现：

首先，我们需要定义订单状态的枚举类型：

public enum OrderStatus {
    CREATED, 
    PAID, 
    SHIPPED, 
    DELIVERED, 
    CANCELLED
}

然后，我们可以定义一个订单类，其中包含订单状态和一些其他属性：

public class Order {
    private OrderStatus status;
    private String customerName;
    private String address;
    private Date date;

    // getters and setters
}

现在我们可以开始实现订单状态机。我们可以使用状态模式来实现它。首先，我们需要定义一个状态接口：

public interface OrderState {
    void pay(Order order);
    void ship(Order order);
    void deliver(Order order);
    void cancel(Order order);
}

然后，我们可以实现每个状态的具体逻辑：

public class CreatedState implements OrderState {
    public void pay(Order order) {
        order.setStatus(OrderStatus.PAID);
    }

    public void ship(Order order) {
        throw new IllegalStateException('Cannot ship an unpaid order');
    }

    public void deliver(Order order) {
        throw new IllegalStateException('Cannot deliver an unpaid order');
    }

    public void cancel(Order order) {
        order.setStatus(OrderStatus.CANCELLED);
    }
}

public class PaidState implements OrderState {
    public void pay(Order order) {
        throw new IllegalStateException('Cannot pay an already paid order');
    }

    public void ship(Order order) {
        order.setStatus(OrderStatus.SHIPPED);
    }

    public void deliver(Order order) {
        throw new IllegalStateException('Cannot deliver an unshipped order');
    }

    public void cancel(Order order) {
        order.setStatus(OrderStatus.CANCELLED);
    }
}

public class ShippedState implements OrderState {
    public void pay(Order order) {
        throw new IllegalStateException('Cannot pay an already shipped order');
    }

    public void ship(Order order) {
        throw new IllegalStateException('Cannot ship an already shipped order');
    }

    public void deliver(Order order) {
        order.setStatus(OrderStatus.DELIVERED);
    }

    public void cancel(Order order) {
        throw new IllegalStateException('Cannot cancel a shipped order');
    }
}

public class DeliveredState implements OrderState {
    public void pay(Order order) {
        throw new IllegalStateException('Cannot pay an already delivered order');
    }

    public void ship(Order order) {
        throw new IllegalStateException('Cannot ship an already delivered order');
    }

    public void deliver(Order order) {
        throw new IllegalStateException('Cannot deliver an already delivered order');
    }

    public void cancel(Order order) {
        throw new IllegalStateException('Cannot cancel a delivered order');
    }
}

public class CancelledState implements OrderState {
    public void pay(Order order) {
        throw new IllegalStateException('Cannot pay a cancelled order');
    }

    public void ship(Order order) {
        throw new IllegalStateException('Cannot ship a cancelled order');
    }

    public void deliver(Order order) {
        throw new IllegalStateException('Cannot deliver a cancelled order');
    }

    public void cancel(Order order) {
        throw new IllegalStateException('Cannot cancel an already cancelled order');
    }
}

最后，我们需要在订单类中实现状态转换逻辑：

public class Order {
    private OrderStatus status;
    private String customerName;
    private String address;
    private Date date;

    private CreatedState createdState;
    private PaidState paidState;
    private ShippedState shippedState;
    private DeliveredState deliveredState;
    private CancelledState cancelledState;

    private OrderState currentState;

    public Order(String customerName, String address, Date date) {
        this.customerName = customerName;
        this.address = address;
        this.date = date;

        createdState = new CreatedState();
        paidState = new PaidState();
        shippedState = new ShippedState();
        deliveredState = new DeliveredState();
        cancelledState = new CancelledState();

        currentState = createdState;
        status = OrderStatus.CREATED;
    }

    public void pay() {
        currentState.pay(this);
    }

    public void ship() {
        currentState.ship(this);
    }

    public void deliver() {
        currentState.deliver(this);
    }

    public void cancel() {
        currentState.cancel(this);
    }

    public OrderStatus getStatus() {
        return status;
    }

    public void setStatus(OrderStatus status) {
        this.status = status;

        switch (status) {
            case CREATED:
                currentState = createdState;
                break;
            case PAID:
                currentState = paidState;
                break;
            case SHIPPED:
                currentState = shippedState;
                break;
            case DELIVERED:
                currentState = deliveredState;
                break;
            case CANCELLED:
                currentState = cancelledState;
                break;
        }
    }

    // getters and setters
}

现在我们可以使用这个订单状态机来管理和控制订单的状态了。例如：

Order order = new Order('John', '123 Main St', new Date());
System.out.println(order.getStatus()); // CREATED

order.pay();
System.out.println(order.getStatus()); // PAID

order.ship();
System.out.println(order.getStatus()); // SHIPPED

order.deliver();
System.out.println(order.getStatus()); // DELIVERED

order.cancel();
System.out.println(order.getStatus()); // CANCELLED

注意，这个订单状态机只是一个简单的示例，实际应用中可能需要更复杂的状态转换逻辑，例如根据库存情况自动取消订单等。