设计模式（状态模式）

概述

在实际的软件开发中，状态模式并不是很常用，但是在能够用到的场景里，它可以发挥很大的作用。从这一点上来看，它有点像我们之前讲到的组合模式。
状态模式一般用来实现状态机，而状态机常用在游戏、工作流引擎等系统开发中。不过，状态机的实现方式有多种，除了状态模式，比较常用的还有分支逻辑法和查表法。今天，我们就详细讲讲这几种实现方式，并且对比一下它们的优劣和应用场景。

什么是有限状态机？

有限状态机，英文翻译是Finite State Machine，缩写为FSM，简称为状态机。状态机有3个组成部分：状态（State）、事件（Event）、动作（Action）。其中，事件也称为转移条件（Transition Condition）。事件触发状态的转移及动作的执行。不过，动作不是必须的，也可能只转移状态，不执行任何动作。

• 状态（State）：系统在某一时刻的条件或配置。在订单系统中，状态可能包括"新订单"、"已付款"、"已发货"等。
• 事件（Event）：触发状态变化的因素，例如用户行为、系统内部进程或时间触发器。在订单管理中，事件包括"付款完成"、"订单发货"等。
• 动作（Action）：发生状态转移时执行的操作，比如通知用户、记录日志等。

为了更好地理解这些概念，可以想象下订单之后，系统开始跟踪订单从"新订单"到"已完成"或者"已取消"的全过程。每个状态都有可能由某些事件触发向下一个状态转移。

实战

下面，我会用一个订单状态流转的例子，带大家深入了解有限状态机，让我们先画出来订单的状态流转图。

这是订单状态的流转图，我们如何来编程实现上面的状态机呢？下面有三种方法来实现这个状态机，每个方法各有优缺点。

1. 分支逻辑法

分支逻辑法是最直接的实现方法，通过条件判断语句来实现状态转移。

其优势在于简单直观，适用于状态较少且逻辑简单的订单处理场景。但随着状态数量增加，会导致代码繁琐、冗长，维护难度增加。

以下是订单状态机的分支逻辑法示例代码：

public enum State {
    NEW_ORDER, PAID, SHIPPED, COMPLETED, CANCELLED
}

public class OrderStateMachine {
    private State currentState;

    public OrderStateMachine() {
        this.currentState = State.NEW_ORDER; // 设置初始状态为新订单
    }

    // 确认支付状态过渡
    public void confirmPayment() {
        if (currentState.equals(State.NEW_ORDER)) {
            this.currentState = State.PAID; // 转移到已付款状态
            System.out.println("Payment confirmed. New order state: PAID");
        } else {
            System.out.println("Invalid state transition from " + currentState + " to PAID.");
        }
    }

    // 发货状态过渡
    public void shipOrder() {
        if (currentState.equals(State.PAID)) {
            this.currentState = State.SHIPPED; // 转移到已发货状态
            System.out.println("Order shipped. New order state: SHIPPED");
        } else {
            System.out.println("Invalid state transition from " + currentState + " to SHIPPED.");
        }
    }

    // 确认交货状态过渡
    public void confirmDelivery() {
        if (currentState.equals(State.SHIPPED)) {
            this.currentState = State.COMPLETED; // 交货确认后订单完成
            System.out.println("Delivery confirmed. New order state: COMPLETED");
        } else {
            System.out.println("Invalid state transition from " + currentState + " to COMPLETED.");
        }
    }

    // 取消订单状态过渡
    public void cancelOrder() {
        if (currentState.equals(State.NEW_ORDER)) {
            this.currentState = State.CANCELLED; // 未支付订单可取消
            System.out.println("Order cancelled. New order state: CANCELLED");
        } else {
            System.out.println("Order cannot be cancelled in its current state " + currentState + ".");
        }
    }
}

对于简单的状态机来说，分支逻辑这种实现方式是可以接受的。但是，对于复杂的状态机来说，这种实现方式极易漏写或者错写某个状态转移。除此之外，代码中充斥着大量的if-else或者switch-case分支判断逻辑，可读性和可维护性都很差。如果哪天修改了状态机中的某个状态转移，我们要在冗长的分支逻辑中找到对应的代码进行修改，很容易改错，引入bug。

2. 查表法

查表法通过用二维数组来映射状态和事件之间的转换关系，使代码结构更加清晰易维护。查表法适合处理复杂状态机，因为表格可以方便地更新状态和事件逻辑。以下是实现代码：

public enum Event {
    CONFIRM_PAYMENT, SHIP_ORDER, CONFIRM_DELIVERY, CANCEL_ORDER
}

public class OrderStateMachineTable {
    private State currentState;

    // 状态转移表：行是当前状态，列是事件
    private static final State[][] stateTransitionTable = {
        {State.CANCELLED, State.PAID, State.NEW_ORDER}, // NEW_ORDER
        {State.PAID, State.SHIPPED, State.PAID}, // PAID
        {State.CANCELLED, State.COMPLETED, State.RETURNED} // SHIPPED
    };

    // 动作表：对应状态变化时执行的动作描述
    private static final String[][] actionTable = {
        {"Notify cancel", "Update payment status", ""}, // NEW_ORDER
        {"", "Notify shipment", ""}, // PAID
        {"", "Update delivery status", "Initiate return"} // SHIPPED
    };

    public OrderStateMachineTable() {
        this.currentState = State.NEW_ORDER; // 初始化状态为新订单
    }

    // 执行事件并根据表更新状态
    public void executeEvent(Event event) {
        int stateIndex = currentState.ordinal(); // 当前状态索引
        int eventIndex = event.ordinal(); // 事件索引
        this.currentState = stateTransitionTable[stateIndex][eventIndex]; // 获取新状态
        String action = actionTable[stateIndex][eventIndex]; // 获取动作描述
        System.out.println("Executing action: " + action + ", New State: " + currentState);
    }
}

在这个代码示例中，状态和事件通过表格映射，实现逻辑分离和清晰的状态管理。表格能够方便地更新和维护，适于项目中状态复杂的场景。

3. 状态模式

状态模式通过面向对象的方式，将每种状态的行为封装在独立的类中。这种方法使得每个状态的处理逻辑更为独立和清晰，特别适用于具有复杂业务逻辑的订单系统。下面是完整的代码实现：

interface OrderState {
    void confirmPayment(OrderStateMachineContext context);
    void shipOrder(OrderStateMachineContext context);
    void confirmDelivery(OrderStateMachineContext context);
    void cancelOrder(OrderStateMachineContext context);
}

class NewOrderState implements OrderState {
    private static final NewOrderState instance = new NewOrderState();
    private NewOrderState() {}

    public static NewOrderState getInstance() {
        return instance;
    }

    @Override
    public void confirmPayment(OrderStateMachineContext context) {
        context.setCurrentState(PaidState.getInstance()); // 切换到已付款状态
        System.out.println("Payment confirmed. State: PAID");
    }

    @Override
    public void shipOrder(OrderStateMachineContext context) {
        System.out.println("Order must be paid before shipping.");
    }

    @Override
    public void confirmDelivery(OrderStateMachineContext context) {
        System.out.println("Cannot confirm delivery for a new order.");
    }

    @Override
    public void cancelOrder(OrderStateMachineContext context) {
        context.setCurrentState(CancelledState.getInstance()); // 切换到已取消状态
        System.out.println("Order cancelled. State: CANCELLED");
    }
}

// 类似地，实现 PaidState, ShippedState, CompletedState, CancelledState

class OrderStateMachineContext {
    private OrderState currentState;

    public OrderStateMachineContext() {
        this.currentState = NewOrderState.getInstance(); // 初始状态为新订单
    }

    public void setCurrentState(OrderState state) {
        this.currentState = state; // 更新当前状态
    }

    public void confirmPayment() {
        currentState.confirmPayment(this); // 调用当前状态的支付确认处理
    }

    public void shipOrder() {
        currentState.shipOrder(this); // 调用当前状态的订单发货处理
    }

    public void confirmDelivery() {
        currentState.confirmDelivery(this); // 调用当前状态的交货确认处理
    }

    public void cancelOrder() {
        currentState.cancelOrder(this); // 调用当前状态的订单取消处理
    }
}

在状态模式中，每个状态的行为都被封装在独立的类中，令业务处理更为清晰和可扩展。通过面向对象设计原则，状态模式确保了系统的灵活性和可维护性。

总结

今天我们讲解了状态模式。虽然网上有各种状态模式的定义，但是你只要记住状态模式是状态机的一种实现方式即可。状态机又叫有限状态机，它有3个部分组成：状态、事件、动作。其中，事件也称为转移条件。事件触发状态的转移及动作的执行。不过，动作不是必须的，也可能只转移状态，不执行任何动作。

针对状态机，今天我们总结了三种实现方式。

第一种实现方式叫分支逻辑法。利用if-else或者switch-case分支逻辑，参照状态转移图，将每一个状态转移原模原样地直译成代码。对于简单的状态机来说，这种实现方式最简单、最直接，是首选。

第二种实现方式叫查表法。对于状态很多、状态转移比较复杂的状态机来说，查表法比较合适。通过二维数组来表示状态转移图，能极大地提高代码的可读性和可维护性。

第三种实现方式叫状态模式。对于状态并不多、状态转移也比较简单，但事件触发执行的动作包含的业务逻辑可能比较复杂的状态机来说，我们首选这种实现方式