PHP 状态模式 (`State Pattern`)：对象行为随内部状态改变

各位观众老爷，大家好！今天咱们来聊聊一个挺有意思的设计模式：状态模式。这玩意儿，说白了，就是让对象能像个变色龙一样，根据自己内在的状态，做出不同的行为。是不是听起来有点玄乎？别怕，咱慢慢来，保证让您听得明白，用得溜。

一、什么是状态模式？

想象一下，你正在玩一个游戏，游戏角色有几种状态：正常、受伤、死亡。在不同的状态下，角色能做的事情是不一样的：

正常状态： 可以跑、跳、攻击。
受伤状态： 可以缓慢移动，勉强攻击。
死亡状态： 什么都不能做，只能躺尸。

如果用传统的 if...else 或者 switch 语句来判断角色的状态，代码会变得非常臃肿，难以维护。每次增加新的状态，或者修改状态的行为，都需要修改大量的代码，一不小心就会出错。

状态模式就是为了解决这个问题而生的。它允许一个对象在其内部状态改变时改变它的行为。对象看起来好像修改了它的类。

简单来说：

核心思想： 将状态相关的行为封装到独立的状态类中。
目的： 使对象在不同状态下表现出不同的行为，避免大量的条件判断。
优势： 代码更加清晰、易于维护、易于扩展。

二、状态模式的结构

状态模式主要包含以下几个角色：

Context（上下文）： 定义客户端感兴趣的接口，维护一个 ConcreteState 子类的实例，这个实例定义当前状态。
State（抽象状态）： 定义一个接口以封装与 Context 的一个特定状态相关的行为。
ConcreteState（具体状态）： 实现 State 接口，实现与 Context 的一个特定状态相关的行为。

用一张表格来总结一下：

角色	描述
Context	上下文对象，持有State对象的引用，负责切换状态，并将客户端的请求委托给当前状态对象处理。
State	抽象状态接口，定义了所有具体状态类需要实现的方法。
ConcreteState	具体状态类，实现了State接口定义的方法，每个具体状态类都负责处理特定状态下的行为。

三、状态模式的 PHP 实现

咱们还是用游戏角色的例子来演示。首先，定义一个抽象状态接口 State：

<?php

interface State {
    public function handle(); // 处理行为
}

然后，创建三个具体状态类：NormalState、InjuredState、DeadState，分别实现 State 接口：

<?php

// 正常状态
class NormalState implements State {
    public function handle() {
        echo "正常状态：可以跑、跳、攻击。n";
    }
}

// 受伤状态
class InjuredState implements State {
    public function handle() {
        echo "受伤状态：可以缓慢移动，勉强攻击。n";
    }
}

// 死亡状态
class DeadState implements State {
    public function handle() {
        echo "死亡状态：什么都不能做，只能躺尸。n";
    }
}

最后，定义上下文类 Character，维护一个 State 对象的引用，并提供一个方法来切换状态：

<?php

class Character {
    private $state;

    public function __construct(State $state) {
        $this->state = $state;
    }

    public function setState(State $state) {
        $this->state = $state;
    }

    public function doAction() {
        $this->state->handle();
    }
}

现在，咱们来测试一下：

<?php

// 创建一个角色，初始状态为正常状态
$character = new Character(new NormalState());

// 角色执行动作
$character->doAction(); // 输出：正常状态：可以跑、跳、攻击。

// 角色受伤了，切换到受伤状态
$character->setState(new InjuredState());

// 角色再次执行动作
$character->doAction(); // 输出：受伤状态：可以缓慢移动，勉强攻击。

// 角色死亡了，切换到死亡状态
$character->setState(new DeadState());

// 角色最后一次执行动作
$character->doAction(); // 输出：死亡状态：什么都不能做，只能躺尸。

可以看到，通过状态模式，我们成功地让角色在不同的状态下表现出不同的行为，而且代码非常清晰易懂。

四、状态模式的优点和缺点

优点：

结构清晰： 将状态相关的行为封装到独立的状态类中，使代码结构更加清晰。
易于维护： 修改状态的行为时，只需要修改对应的状态类，不会影响其他代码。
易于扩展： 增加新的状态时，只需要创建新的状态类，并修改上下文类的状态切换逻辑即可。
符合单一职责原则： 每个状态类只负责处理特定状态下的行为。
避免了大量的条件判断： 将条件判断分散到各个状态类中，使代码更加简洁。

缺点：

类的数量增加： 每个状态都需要一个类，可能会导致类的数量增加。
状态切换逻辑可能复杂： 上下文类需要负责状态的切换，如果状态切换逻辑比较复杂，可能会增加上下文类的复杂度。
状态转换不容易控制： 状态的转换可能过于自由，如果需要严格控制状态的转换，需要额外的机制来保证。

五、状态模式的应用场景

状态模式适用于以下场景：

一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为。 例如，TCP 连接的不同状态（连接中、已连接、已关闭）。
一个操作中含有庞大的多分支条件语句，且这些分支依赖于该对象的状态。 例如，一个文档编辑器，根据当前模式（只读、编辑）提供不同的功能。
需要对状态进行转换控制。 例如，一个订单系统，需要根据订单的状态（待付款、已付款、已发货、已完成）进行不同的处理。

六、状态模式与其他模式的比较

状态模式 vs. 策略模式： 状态模式和策略模式都封装了算法，但它们的意图不同。状态模式关注的是对象的状态变化，而策略模式关注的是算法的选择。状态模式中，状态的改变通常是由对象自身触发的，而策略模式中，策略的选择通常是由客户端决定的。
状态模式 vs. 状态机： 状态模式可以看作是状态机的一种实现方式。状态机是一种描述系统状态和状态转换的数学模型，而状态模式是一种设计模式，用于在代码中实现状态机。

七、实战案例：订单状态管理

咱们来一个更实际的例子：订单状态管理。一个订单可能有以下状态：

待付款 (PendingPayment): 用户尚未支付订单。
已付款 (Paid): 用户已支付订单。
已发货 (Shipped): 订单已发货。
已完成 (Completed): 订单已完成。
已取消 (Cancelled): 订单已取消。

根据订单的状态，我们可以执行不同的操作：

待付款： 可以付款、取消订单。
已付款： 可以发货、退款。
已发货： 可以确认收货。
已完成： 什么都不能做。
已取消： 什么都不能做。

咱们用状态模式来实现这个订单状态管理系统：

<?php

// 订单状态接口
interface OrderState {
    public function handle(Order $order);
}

// 待付款状态
class PendingPayment implements OrderState {
    public function handle(Order $order) {
        echo "订单待付款，可以付款、取消订单。n";
    }

    public function pay(Order $order) {
        echo "订单已付款。n";
        $order->setState(new Paid());
    }

    public function cancel(Order $order) {
        echo "订单已取消。n";
        $order->setState(new Cancelled());
    }
}

// 已付款状态
class Paid implements OrderState {
    public function handle(Order $order) {
        echo "订单已付款，可以发货、退款。n";
    }

    public function ship(Order $order) {
        echo "订单已发货。n";
        $order->setState(new Shipped());
    }

    public function refund(Order $order) {
        echo "订单已退款。n";
        $order->setState(new Cancelled()); // 退款后通常会取消订单
    }
}

// 已发货状态
class Shipped implements OrderState {
    public function handle(Order $order) {
        echo "订单已发货，可以确认收货。n";
    }

    public function confirmReceive(Order $order) {
        echo "订单已确认收货。n";
        $order->setState(new Completed());
    }
}

// 已完成状态
class Completed implements OrderState {
    public function handle(Order $order) {
        echo "订单已完成，什么都不能做。n";
    }
}

// 已取消状态
class Cancelled implements OrderState {
    public function handle(Order $order) {
        echo "订单已取消，什么都不能做。n";
    }
}

// 订单上下文类
class Order {
    private $state;

    public function __construct() {
        $this->state = new PendingPayment(); // 初始状态为待付款
    }

    public function setState(OrderState $state) {
        $this->state = $state;
    }

    public function getState() {
        return $this->state;
    }

    public function process() {
        $this->state->handle($this);
    }

    // 委托给状态对象处理具体操作
    public function pay() {
        if ($this->state instanceof PendingPayment) {
            $this->state->pay($this);
        } else {
            echo "订单状态不允许付款。n";
        }
    }

    public function cancel() {
        if ($this->state instanceof PendingPayment) {
            $this->state->cancel($this);
        } else {
            echo "订单状态不允许取消。n";
        }
    }

    public function ship() {
        if ($this->state instanceof Paid) {
            $this->state->ship($this);
        } else {
            echo "订单状态不允许发货。n";
        }
    }

    public function refund() {
        if ($this->state instanceof Paid) {
            $this->state->refund($this);
        } else {
            echo "订单状态不允许退款。n";
        }
    }

    public function confirmReceive() {
        if ($this->state instanceof Shipped) {
            $this->state->confirmReceive($this);
        } else {
            echo "订单状态不允许确认收货。n";
        }
    }
}

// 测试
$order = new Order();
$order->process(); // 输出：订单待付款，可以付款、取消订单。

$order->pay(); // 输出：订单已付款。
$order->process(); // 输出：订单已付款，可以发货、退款。

$order->ship(); // 输出：订单已发货。
$order->process(); // 输出：订单已发货，可以确认收货。

$order->confirmReceive(); // 输出：订单已确认收货。
$order->process(); // 输出：订单已完成，什么都不能做。

$order->cancel(); // 输出：订单状态不允许取消。

在这个例子中，Order 类是上下文，OrderState 是抽象状态接口，PendingPayment、Paid、Shipped、Completed、Cancelled 是具体状态类。通过状态模式，我们清晰地管理了订单的各种状态，并且可以方便地添加新的状态或者修改状态的行为。

八、总结

状态模式是一种非常有用的设计模式，它可以帮助我们更好地管理对象的状态，使代码更加清晰、易于维护、易于扩展。虽然它可能会增加类的数量，但在很多情况下，这种付出是值得的。希望通过今天的讲解，大家能够对状态模式有一个更深入的了解，并在实际项目中灵活运用。

好了，今天的讲座就到这里，感谢大家的收听！如果有什么问题，欢迎随时提问。下次再见！

发表回复 取消回复

发表回复取消回复