IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

PHP状态模式重构条件

wen PHP项目 162

本文目录导读：

PHP状态模式重构条件

  1. 什么是状态模式
  2. 问题场景示例
  3. 状态模式重构
  4. 状态模式的核心优点
  5. 状态模式的缺点和注意事项
  6. 进阶：结合工厂模式

我来详细解释如何使用状态模式重构复杂条件逻辑,并提供实际示例。

什么是状态模式

状态模式允许对象在内部状态改变时改变其行为,看起来就像修改了对象的类一样，主要解决复杂条件判断（if-else / switch）导致的代码臃肿问题。

问题场景示例

原始代码（使用大量条件判断）

<?php
class Order
{
    const STATUS_NEW = 'new';
    const STATUS_PAID = 'paid';
    const STATUS_SHIPPED = 'shipped';
    const STATUS_COMPLETED = 'completed';
    const STATUS_CANCELLED = 'cancelled';
    private string $status;
    public function __construct()
    {
        $this->status = self::STATUS_NEW;
    }
    // 支付操作
    public function pay(): void
    {
        if ($this->status === self::STATUS_NEW) {
            echo "订单支付成功\n";
            $this->status = self::STATUS_PAID;
        } elseif ($this->status === self::STATUS_PAID) {
            echo "订单已支付，不能重复支付\n";
        } elseif ($this->status === self::STATUS_SHIPPED) {
            echo "订单已发货，不能支付\n";
        } elseif ($this->status === self::STATUS_COMPLETED) {
            echo "订单已完成，不能支付\n";
        } elseif ($this->status === self::STATUS_CANCELLED) {
            echo "订单已取消，不能支付\n";
        } else {
            throw new \Exception("未知状态");
        }
    }
    // 发货操作（继续膨胀...）
    public function ship(): void
    {
        if ($this->status === self::STATUS_PAID) {
            echo "订单发货成功\n";
            $this->status = self::STATUS_SHIPPED;
        } elseif ($this->status === self::STATUS_NEW) {
            echo "订单未支付，不能发货\n";
        } elseif ($this->status === self::STATUS_SHIPPED) {
            echo "订单已发货，不能重复发货\n";
        } elseif ($this->status === self::STATUS_COMPLETED) {
            echo "订单已完成，不能发货\n";
        } elseif ($this->status === self::STATUS_CANCELLED) {
            echo "订单已取消，不能发货\n";
        } else {
            throw new \Exception("未知状态");
        }
    }
    // 完成操作（继续膨胀...）
    public function complete(): void
    {
        if ($this->status === self::STATUS_SHIPPED) {
            echo "订单完成\n";
            $this->status = self::STATUS_COMPLETED;
        } elseif ($this->status === self::STATUS_NEW) {
            echo "订单未发货，不能完成\n";
        } elseif ($this->status === self::STATUS_PAID) {
            echo "订单未发货，不能完成\n";
        } elseif ($this->status === self::STATUS_COMPLETED) {
            echo "订单已完成，不能重复完成\n";
        } elseif ($this->status === self::STATUS_CANCELLED) {
            echo "订单已取消，不能完成\n";
        } else {
            throw new \Exception("未知状态");
        }
    }
}

问题：

  • 每个方法都有大量if-else嵌套
  • 添加新状态需要修改所有方法
  • 代码可读性差,维护困难

状态模式重构

定义状态接口

<?php
// 订单状态接口
interface OrderStateInterface
{
    // 执行支付操作
    public function pay(OrderContext $order): void;
    // 执行发货操作
    public function ship(OrderContext $order): void;
    // 执行完成操作
    public function complete(OrderContext $order): void;
    // 执行取消操作
    public function cancel(OrderContext $order): void;
    // 获取当前状态名
    public function getStatusName(): string;
}

实现具体状态类

<?php
// 新订单状态
class NewOrderState implements OrderStateInterface
{
    public function pay(OrderContext $order): void
    {
        echo "订单支付成功\n";
        $order->setState(new PaidOrderState());
    }
    public function ship(OrderContext $order): void
    {
        echo "订单未支付，不能发货\n";
    }
    public function complete(OrderContext $order): void
    {
        echo "订单未发货，不能完成\n";
    }
    public function cancel(OrderContext $order): void
    {
        echo "订单取消成功\n";
        $order->setState(new CancelledOrderState());
    }
    public function getStatusName(): string
    {
        return "新订单";
    }
}
// 已支付状态
class PaidOrderState implements OrderStateInterface
{
    public function pay(OrderContext $order): void
    {
        echo "订单已支付，不能重复支付\n";
    }
    public function ship(OrderContext $order): void
    {
        echo "订单发货成功\n";
        $order->setState(new ShippedOrderState());
    }
    public function complete(OrderContext $order): void
    {
        echo "订单未发货，不能完成\n";
    }
    public function cancel(OrderContext $order): void
    {
        echo "订单已支付，不能取消\n";
    }
    public function getStatusName(): string
    {
        return "已支付";
    }
}
// 已发货状态
class ShippedOrderState implements OrderStateInterface
{
    public function pay(OrderContext $order): void
    {
        echo "订单已发货，不能支付\n";
    }
    public function ship(OrderContext $order): void
    {
        echo "订单已发货，不能重复发货\n";
    }
    public function complete(OrderContext $order): void
    {
        echo "订单完成成功\n";
        $order->setState(new CompletedOrderState());
    }
    public function cancel(OrderContext $order): void
    {
        echo "订单已发货，不能取消\n";
    }
    public function getStatusName(): string
    {
        return "已发货";
    }
}
// 已完成状态
class CompletedOrderState implements OrderStateInterface
{
    public function pay(OrderContext $order): void
    {
        echo "订单已完成，不能支付\n";
    }
    public function ship(OrderContext $order): void
    {
        echo "订单已完成，不能发货\n";
    }
    public function complete(OrderContext $order): void
    {
        echo "订单已完成，不能重复完成\n";
    }
    public function cancel(OrderContext $order): void
    {
        echo "订单已完成，不能取消\n";
    }
    public function getStatusName(): string
    {
        return "已完成";
    }
}
// 已取消状态
class CancelledOrderState implements OrderStateInterface
{
    public function pay(OrderContext $order): void
    {
        echo "订单已取消，不能支付\n";
    }
    public function ship(OrderContext $order): void
    {
        echo "订单已取消，不能发货\n";
    }
    public function complete(OrderContext $order): void
    {
        echo "订单已取消，不能完成\n";
    }
    public function cancel(OrderContext $order): void
    {
        echo "订单已取消，不能重复取消\n";
    }
    public function getStatusName(): string
    {
        return "已取消";
    }
}

创建上下文类

<?php
class OrderContext
{
    private OrderStateInterface $state;
    // 订单数据
    private array $orderData = [];
    public function __construct()
    {
        $this->state = new NewOrderState();
    }
    public function setState(OrderStateInterface $state): void
    {
        $this->state = $state;
    }
    // 委托操作给当前状态
    public function pay(): void
    {
        $this->state->pay($this);
    }
    public function ship(): void
    {
        $this->state->ship($this);
    }
    public function complete(): void
    {
        $this->state->complete($this);
    }
    public function cancel(): void
    {
        $this->state->cancel($this);
    }
    // 获取当前状态
    public function getStatusName(): string
    {
        return $this->state->getStatusName();
    }
    // 设置订单数据
    public function setData(string $key, $value): void
    {
        $this->orderData[$key] = $value;
    }
    public function getData(string $key)
    {
        return $this->orderData[$key] ?? null;
    }
}

使用示例

<?php
// 使用重构后的代码
$order = new OrderContext();
$order->setData('order_no', '2024001');
echo "初始状态：" . $order->getStatusName() . "\n";
// 模拟订单流程
$order->pay();      // 输出：订单支付成功
echo "当前状态：" . $order->getStatusName() . "\n";
$order->pay();      // 输出：订单已支付，不能重复支付
$order->ship();     // 输出：订单发货成功
echo "当前状态：" . $order->getStatusName() . "\n";
$order->complete(); // 输出：订单完成成功
echo "当前状态：" . $order->getStatusName() . "\n";
// 测试取消场景
$order2 = new OrderContext();
$order2->pay();
echo "当前状态：" . $order2->getStatusName() . "\n";
$order2->cancel();  // 输出：订单已支付，不能取消
$order2->ship();
echo "当前状态：" . $order2->getStatusName() . "\n";
$order2->cancel();  // 输出：订单已发货，不能取消

状态模式的核心优点

开闭原则

  • 新增状态时只需添加新状态类,无需修改现有代码
  • 完全符合"对扩展开放，对修改关闭"

消除条件判断

  • 移除大量的if-else/switch语句
  • 状态行为被分散到各自的状态类中

代码组织清晰

  • 每个状态的行为集中在一个类中
  • 状态转换逻辑单一明确

状态一致性

  • 状态转换被封装在状态类中
  • 避免了非法状态转换

状态模式的缺点和注意事项

缺点

  1. 类数量增多：每个状态都需要一个类
  2. 状态转换分散：转换逻辑分布在各个状态类中

使用建议

// 1. 如果状态不多且简单，直接使用enum + switch即可
enum OrderStatus {
    case NEW;
    case PAID;
    case SHIPPED;
}
// 简单场景不需要状态模式
function checkOrderStatus(OrderStatus $status) {
    switch ($status) {
        case OrderStatus::NEW:
            // do something
            break;
        case OrderStatus::PAID:
            // do something
            break;
    }
}
// 2. 当状态转换逻辑复杂、每个状态有大量行为时，使用状态模式
// 3. 状态数量较多且经常变化时，考虑状态模式

进阶：结合工厂模式

<?php
// 状态工厂（可选，用于从数据库恢复状态）
class OrderStateFactory
{
    public static function createState(string $status): OrderStateInterface
    {
        return match ($status) {
            'new' => new NewOrderState(),
            'paid' => new PaidOrderState(),
            'shipped' => new ShippedOrderState(),
            'completed' => new CompletedOrderState(),
            'cancelled' => new CancelledOrderState(),
            default => throw new \InvalidArgumentException("未知状态: {$status}"),
        };
    }
}
// 增强的OrderContext
class AdvancedOrderContext
{
    private OrderStateInterface $state;
    public function restoreState(string $status): void
    {
        $this->state = OrderStateFactory::createState($status);
    }
    // 保存状态（用于持久化）
    public function getCurrentState(): string
    {
        return $this->state->getStatusName();
    }
}

状态模式最适合：

  • 操作包含庞大的多分支条件语句
  • 对象的行为依赖于它的状态,并随着状态改变而改变
  • 状态转换规则复杂且需要统一管理

通过这个重构示例,可以看到状态模式如何显著提升代码的可维护性和可扩展性，关键在于将状态和对应行为封装为独立对象，使状态转换变得显式且安全。

版权声明：NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 CBA直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 足球直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播 英超直播

上一篇PHP访问者模式适合场景

下一篇PHP策略模式消除if

相关文章

抱歉，评论功能暂时关闭!

友情链接攻略窝 · 礼包窝 · 配置窝 · 换算窝 · 算法窝 · 查文窝 · 手册窝 · 问答窝 · 全文搜 · 手册库
相关站点礼包窝 · 查文窝