设计模式(状态模式)

概述

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

什么是有限状态机?

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

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

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

实战

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

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

1. 分支逻辑法

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

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

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

cpp 复制代码
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. 查表法

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

cpp 复制代码
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. 状态模式

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

cpp 复制代码
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分支逻辑,参照状态转移图,将每一个状态转移原模原样地直译成代码。对于简单的状态机来说,这种实现方式最简单、最直接,是首选。

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

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

相关推荐
小陈094 小时前
Java后端图形验证码的使用
java·开发语言·状态模式
碎梦归途6 小时前
23种设计模式-行为型模式之中介者模式(Java版本)
java·jvm·设计模式·中介者模式·软件设计师
不当菜虚困9 小时前
JAVA设计模式——(九)工厂模式
java·开发语言·设计模式
柴郡猫乐园9 小时前
智能指针之设计模式5
开发语言·设计模式·智能指针
mooridy13 小时前
设计模式 | 详解常用设计模式(六大设计原则,单例模式,工厂模式,建造者模式,代理模式)
c++·设计模式
程序员JerrySUN13 小时前
设计模式每日硬核训练 Day 17:中介者模式(Mediator Pattern)完整讲解与实战应用
microsoft·设计模式·中介者模式
Auroral15616 小时前
结构型模式:装饰器模式
设计模式
智想天开16 小时前
14.外观模式:思考与解读
windows·microsoft·设计模式·外观模式
摘星编程18 小时前
并发设计模式实战系列(9):消息传递(Message Passing)
设计模式·并发编程