23.3紧耦合设计

代码结构图 第二十三章 烤羊肉串引来的思考——命令模式 - 图1客户端程序与‘烤肉串者’紧耦合，尽管简单，但却极为僵化，有许许多多的隐患。
如果用户多了，请求多了，就容易乱了。

23.4松耦合设计

代码结构图 第二十三章 烤羊肉串引来的思考——命令模式 - 图2代码实现
抽象命令类

  1. //抽象命令
  2. abstract class Command
  3. {
  4.     protected $receiver = null;
  5.     //抽象命令类，只需要确定‘烤肉串者是谁’
  6.     public function __construct($receiver)
  7.     {
  8.         $this->receiver = $receiver;
  9.     }
  11.     abstract function ExecuteCommand();
  12. }

具体命令类

  1. //烤羊肉串命令
  2. class BakeMuttonCommand extends Command
  3. {
  4.     public function __construct($receiver)
  5.     {
  6.         parent::__construct($receiver);
  7.     }
  8.     //具体命令类，执行命令时，执行具体的行为
  9.     public function ExecuteCommand()
  10.     {
  11.         $this->receiver->BakeMutton();
  12.     }
  13. }
  14. //烤鸡翅命令
  15. class BakeChickenWingCommand extends Command
  16. {
  17.     public function __construct($receiver)
  18.     {
  19.         parent::__construct($receiver);
  20.     }
  22.     public function ExecuteCommand()
  23.     {
  24.         $this->receiver->BakeChickenWing();
  25.     }
  26. }

服务员类

  1. //服务员
  2. class Waiter
  3. {
  4.     private $command = null;
  5.     //设置订单
  6.     public function SetOrder($command)
  7.     {
  8.         $this->command = $command;
  9.     }
  10.     //通知执行
  11.     public function Notify()
  12.     {
  13.         $this->command->ExecuteCommand();
  14.     }
  15. }

烤肉串者类

  1. //烤肉串者
  2. class Barbecue
  3. {
  4.     //烤羊肉
  5.     public function BakeMutton()
  6.     {
  7.         echo '烤羊肉串！' . PHP_EOL;
  8.     }
  9.     //烤鸡翅
  10.     public function BakeChickenWing()
  11.     {
  12.         echo '烤鸡翅' . PHP_EOL;
  13.     }
  14. }

客户端实现

  1. public function commandImpFirstED()
  2. {
  3.     //开店前的准备
  4.     $boy = new Barbecue();
  5.     $bakeMuttonCommand1 = new BakeMuttonCommand($boy);
  6.     $bakeMuttonCommand2 = new BakeMuttonCommand($boy);
  7.     $bakeChickenWingCommand1 = new BakeChickenWingCommand($boy);
  8.     $girl = new Waiter();
  9.     //开门营业
  10.     $girl->SetOrder($bakeMuttonCommand1);
  11.     $girl->Notify();
  12.     $girl->SetOrder($bakeMuttonCommand2);
  13.     $girl->Notify();
  14.     $girl->SetOrder($bakeChickenWingCommand1);
  15.     $girl->Notify();
  16. }

23.5松耦合后

代码实现
服务员类

  1. //服务员
  2. class Waiter
  3. {
  4.     private $orders = array();
  5.     //设置订单
  6.     public function SetOrder($command)
  7.     {
  8.         if ($command instanceof BakeChickenWingCommand) {
  9.             echo '服务员：鸡翅没有了，请点别的烧烤' . PHP_EOL;
  10.         } else {
  11.             $this->orders[] = $command;
  12.             echo '增加订单：' . basename(str_replace('\\', '/', get_class($command))) . ' 时间：' . date('Y-m-d H:i:s') . PHP_EOL;
  13.         }
  14.     }
  15.     //取消订单
  16.     public function CancelOrder($command)
  17.     {
  18.         foreach ($this->orders as $key => $value) {
  19.             if ($value == $command) {
  20.                 unset($this->orders[$key]);
  21.             }
  22.         }
  23.         echo '取消订单：' . basename(str_replace('\\', '/', get_class($command))) . ' 时间：' . date('Y-m-d H:i:s') . PHP_EOL;
  24.     }
  25.     //通知全部执行
  26.     public function Notify()
  27.     {
  28.         foreach ($this->orders as $value) {
  29.             $value->ExecuteCommand();
  30.         }
  31.     }
  32. }

客户端代码实现

  1. public function commandImp()
  2. {
  3.     //开店前的准备
  4.     $boy = new BarbecueImp();
  5.     $backMuttonCommand1 = new BakeMuttonCommandImp($boy);
  6.     $backMuttonCommand2 = new BakeMuttonCommandImp($boy);
  7.     $bakeChickenWingCommand1 = new BakeChickenWingCommandImp($boy);
  8.     $girl = new WaiterImp();
  9.     //开门营业顾客点菜
  10.     $girl->SetOrder($backMuttonCommand1);
  11.     $girl->SetOrder($backMuttonCommand2);
  12.     $girl->SetOrder($bakeChickenWingCommand1);
  13.     //点菜完毕，通知厨房
  14.     $girl->Notify();
  15. }

执行结果

  1. 增加订单：BakeMuttonCommand 时间：2020-11-25 20:50:50
  2. 增加订单：BakeMuttonCommand 时间：2020-11-25 20:50:50
  3. 服务员：鸡翅没有了，请点别的烧烤
  4. 烤羊肉串！
  5. 烤羊肉串！

23.6命令模式

命令模式（Command），将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
命令模式（Command）结构图 第二十三章 烤羊肉串引来的思考——命令模式 - 图3代码示例
Command类，用来声明执行操作的接口。

  1. abstract class Command
  2. {
  3.     protected $receiver = null;
  5.     public function __construct($receiver)
  6.     {
  7.         $this->receiver = $receiver;
  8.     }
  10.     abstract function Execute();
  11. }

ConcreteCommand类，将一个接收者对象绑定于一个动作，调用接收者相应的操作，以实现Execute。

  1. class ConcreteCommand extends Command
  2. {
  3.     public function __construct($receiver)
  4.     {
  5.         parent::__construct($receiver);
  6.     }
  8.     public function Execute()
  9.     {
  10.         $this->receiver->Action();
  11.     }
  12. }

Invoker类，要求该命令执行这个请求。

  1. class Invoker
  2. {
  3.     private $command = null;
  5.     public function SetCommand($command)
  6.     {
  7.         $this->command = $command;
  8.     }
  10.     public function ExecuteCommand()
  11.     {
  12.         $this->command->Execute();
  13.     }
  14. }

Receiver类，知道如何实施与执行一个与请求相关的操作，任何类都可能作为一个接收者。

  1. class Receiver
  2. {
  3.     public function Action()
  4.     {
  5.         echo '执行请求！' . PHP_EOL;
  6.     }
  7. }

客户端代码，创建一个具体命令对象并设定它的接收者。

  1. public function commandDemo()
  2. {
  3.     $r = new Receiver();
  4.     $c = new ConcreteCommand($r);
  5.     $i = new Invoker();
  7.     $i->SetCommand($c);
  8.     $i->ExecuteCommand();
  9. }

23.7命令模式作用

命令模式的优点：

  • 第一，它能较容易地设计一个命令队列；
  • 第二，在需要的情况下，可以较容易地将命令记入日志；
  • 第三，允许接收请求的一方决定是否要否决请求；
  • 第四，可以容易地实现对请求的撤销和重做；
  • 第五，由于加进新的具体命令类不影响其他的类，因此增加新的具体命令类很容易；
  • 最关键的优点，命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开。

敏捷开发原则告诉我们，不要为代码添加基于猜测的、实际不需要的功能。如果不清楚一个系统是否需要命令模式，一般就不要着急去实现它，事实上，在需要的时候通过重构实现这个模式并不困难，只有在真正需要如撤销/恢复操作等功能时，把原来的代码重构为命令模式才有意义。