当前位置：首页 > PHP教程 > php高级应用 > 列表

PHP设计模式之命令模式示例详解

发布:smiling　来源: PHP粉丝网 　添加日期：2022-04-06 12:52:25　浏览: 评论：0　

这篇文章主要给大家介绍了关于PHP设计模式之命令模式的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧。

前言

命令模式，也称为动作或者事务模式，很多教材会用饭馆来举例。作为顾客的我们是命令的下达者，服务员是这个命令的接收者，菜单是这个实际的命令，而厨师是这个命令的执行者。那么，这个模式解决了什么呢？当你要修改菜单的时候，只需要和服务员说就好了，她会转达给厨师，也就是说，我们实现了顾客和厨师的解耦。也就是调用者与实现者的解耦。当然，很多设计模式可以做到这一点，但是命令模式能够做到的是让一个命令接收者实现多个命令（服务员下单、拿酒水、上菜），或者把一条命令转达给多个实现者（热菜厨师、凉菜厨师、主食师傅）。这才是命令模式真正发挥的地方！！

Gof类图及解释

GoF定义：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作

GoF类图

PHP设计模式之命令模式示例详解

代码实现

  1. class Invoker 
  2. { 
  3.  public $command; 
  4.    
  5.  public function __construct($command) 
  6.  { 
  7.   $this->command = $command; 
  8.  } 
  9.  
  10.  public function exec() 
  11.  { 
  12.   $this->command->execute(); 
  13.  } 
  14. } 

首先我们定义一个命令的接收者，或者说是命令的请求者更恰当。类图中的英文定义这个单词是“祈求者”。也就是由它来发起和操作命令。

  1. abstract class Command 
  2. { 
  3.  protected $receiver; 
  4.  
  5.  public function __construct(Receiver $receiver) 
  6.  { 
  7.   $this->receiver = $receiver; 
  8.  } 
  9.  
  10.  abstract public function execute(); 
  11. } 
  12.  
  13. class ConcreteCommand extends Command 
  14. { 
  15.  public function execute() 
  16.  { 
  17.   $this->receiver->action(); 
  18.  } 
  19. } 

接下来是命令，也就是我们的“菜单”。这个命令的作用是为了定义真正的执行者是谁。

  1. class Receiver 
  2. { 
  3.  public $name; 
  4.  
  5.  public function __construct($name) 
  6.  { 
  7.   $this->name = $name; 
  8.  } 
  9.  
  10.  public function action() 
  11.  { 
  12.   echo $this->name . '命令执行了！', PHP_EOL; 
  13.  } 
  14. } 

接管者，也就是执行者，真正去执行命令的人。

  1. // 准备执行者 
  2. $receiverA = new Receiver('A'); 
  3.  
  4. // 准备命令 
  5. $command = new ConcreteCommand($receiverA); 
  6.  
  7. // 请求者 
  8. $invoker = new Invoker($command); 
  9. $invoker->exec(); 

客户端的调用，我们要联系好执行者也就是挑有好厨子的饭馆（Receiver），然后准备好命令也就是菜单（Command），最后交给服务员（Invoker）。

其实这个饭店的例子已经非常清晰了，对于命令模式真是完美的解析

那说好的可以下多份订单或者给多个厨师呢？别急，下面的代码帮助我们解决这个问题

完整代码： https://github.com/zhangyue0503/designpatterns-php/blob/master/09.command/source/command.php

  1. <?php 
  2.  
  3. class Invoker 
  4. { 
  5.  private $command = []; 
  6.  
  7.  public function setCommand(Command $command) 
  8.  { 
  9.   $this->command[] = $command; 
  10.  } 
  11.  
  12.  public function exec() 
  13.  { 
  14.   if(count($this->command) > 0){ 
  15.    foreach ($this->command as $command) { 
  16.     $command->execute(); 
  17.    } 
  18.   } 
  19.  } 
  20.  
  21.  public function undo() 
  22.  { 
  23.   if(count($this->command) > 0){ 
  24.    foreach ($this->command as $command) { 
  25.     $command->undo(); 
  26.    } 
  27.   } 
  28.  } 
  29. } 
  30.  
  31. abstract class Command 
  32. { 
  33.  protected $receiver; 
  34.  protected $state; 
  35.  protected $name; 
  36.  
  37.  public function __construct(Receiver $receiver, $name) 
  38.  { 
  39.   $this->receiver = $receiver; 
  40.   $this->name = $name; 
  41.  } 
  42.  
  43.  abstract public function execute(); 
  44. } 
  45.  
  46. class ConcreteCommand extends Command 
  47. { 
  48.  public function execute() 
  49.  { 
  50.   if (!$this->state || $this->state == 2) { 
  51.    $this->receiver->action(); 
  52.    $this->state = 1; 
  53.   } else { 
  54.    echo $this->name . '命令正在执行，无法再次执行了！', PHP_EOL; 
  55.   } 
  56.  
  57.  } 
  58.    
  59.  public function undo() 
  60.  { 
  61.   if ($this->state == 1) { 
  62.    $this->receiver->undo(); 
  63.    $this->state = 2; 
  64.   } else { 
  65.    echo $this->name . '命令未执行，无法撤销了！', PHP_EOL; 
  66.   } 
  67.  } 
  68. } 
  69.  
  70. class Receiver 
  71. { 
  72.  public $name; 
  73.  public function __construct($name) 
  74.  { 
  75.   $this->name = $name; 
  76.  } 
  77.  public function action() 
  78.  { 
  79.   echo $this->name . '命令执行了！', PHP_EOL; 
  80.  } 
  81.  public function undo() 
  82.  { 
  83.   echo $this->name . '命令撤销了！', PHP_EOL; 
  84.  } 
  85. } 
  86.  
  87. // 准备执行者 
  88. $receiverA = new Receiver('A'); 
  89. $receiverB = new Receiver('B'); 
  90. $receiverC = new Receiver('C'); 
  91.  
  92. // 准备命令 
  93. $commandOne = new ConcreteCommand($receiverA, 'A'); 
  94. $commandTwo = new ConcreteCommand($receiverA, 'B'); 
  95. $commandThree = new ConcreteCommand($receiverA, 'C'); 
  96.  
  97. // 请求者 
  98. $invoker = new Invoker(); 
  99. $invoker->setCommand($commandOne); 
  100. $invoker->setCommand($commandTwo); 
  101. $invoker->setCommand($commandThree); 
  102. $invoker->exec(); 
  103. $invoker->undo(); 
  104.  
  105. // 新加一个单独的执行者，只执行一个命令 
  106. $invokerA = new Invoker(); 
  107. $invokerA->setCommand($commandOne); 
  108. $invokerA->exec(); 
  109.  
  110. // 命令A已经执行了，再次执行全部的命令执行者，A命令的state判断无法生效 
  111. $invoker->exec(); 

这一次我们一次性解决了多个订单、多位厨师的问题，并且还顺便解决了如果下错命令了，进行撤销的问题。

可以看出来，命令模式将调用操作的对象与知道如何实现该操作的对象实现了解耦

这种多命令多执行者的实现，有点像 组合模式 的实现

在这种情况下，增加新的命令，即不会影响执行者，也不会影响客户。当有新的客户需要新的命令时，只需要增加命令和请求者即可。即使有修改的需求，也只是修改请求者。

Laravel框架的事件调度机制中，除了观察者模式外，也很明显的能看出命令模式的影子

我们的手机工厂和餐厅其实并没有什么两样，当我们需要代工厂来制作手机时，也是先下订单，这个订单就可以看做是命令。在这个订单中，我们会规定好需要用到的配件，什么型号的CPU，什么型号的内存，预装什么系统之类的。然后代工厂的工人们就会根据这个订单来进行生产。在这个过程中，我不用关心是某一个工人还是一群工人来执行这个订单，我只需要将这个订单交给和我们对接的人就可以了，然后只管等着手机生产出来进行验收咯！！

完整代码： https://github.com/zhangyue0503/designpatterns-php/blob/master/09.command/source/command-up.php

实例

短信功能又回来了，我们发现除了工厂模式外，命令模式貌似也是一种不错的实现方式哦。在这里，我们依然是使用那几个短信和推送的接口，话不多说，我们用命令模式再来实现一个吧。当然，有兴趣的朋友可以接着实现我们的短信撤回功能哈，想想上面的命令取消是怎么实现的。

短信发送类图

PHP设计模式之命令模式示例详解

完整源码： https://github.com/zhangyue0503/designpatterns-php/blob/master/09.command/source/command-message.php

  1. <?php 
  2.  
  3. class SendMsg 
  4. { 
  5.  private $command = []; 
  6.  
  7.  public function setCommand(Command $command) 
  8.  { 
  9.   $this->command[] = $command; 
  10.  } 
  11.    
  12.  public function send($msg) 
  13.  { 
  14.   foreach ($this->command as $command) { 
  15.    $command->execute($msg); 
  16.   } 
  17.  } 
  18. } 
  19.  
  20. abstract class Command 
  21. { 
  22.  protected $receiver = []; 
  23.  
  24.  public function setReceiver($receiver) 
  25.  { 
  26.   $this->receiver[] = $receiver; 
  27.  } 
  28.  
  29.  abstract public function execute($msg); 
  30. } 
  31.  
  32. class SendAliYun extends Command 
  33. { 
  34.  public function execute($msg) 
  35.  { 
  36.   foreach ($this->receiver as $receiver) { 
  37.    $receiver->action($msg); 
  38.   } 
  39.  } 
  40. } 
  41.  
  42. class SendJiGuang extends Command 
  43. { 
  44.  public function execute($msg) 
  45.  { 
  46.   foreach ($this->receiver as $receiver) { 
  47.    $receiver->action($msg); 
  48.   } 
  49.  } 
  50. } 
  51.  
  52. class SendAliYunMsg 
  53. { 
  54.  public function action($msg) 
  55.  { 
  56.   echo '【阿X云短信】发送：' . $msg, PHP_EOL; 
  57.  } 
  58. } 
  59.  
  60. class SendAliYunPush 
  61. { 
  62.  public function action($msg) 
  63.  { 
  64.   echo '【阿X云推送】发送：' . $msg, PHP_EOL; 
  65.  } 
  66. } 
  67.  
  68. class SendJiGuangMsg 
  69. { 
  70.  public function action($msg) 
  71.  { 
  72.   echo '【极X短信】发送：' . $msg, PHP_EOL; 
  73.  } 
  74. } 
  75.  
  76. class SendJiGuangPush 
  77. { 
  78.  public function action($msg) 
  79.  { 
  80.   echo '【极X推送】发送：' . $msg, PHP_EOL; 
  81.  } 
  82. } 
  83.  
  84. $aliMsg = new SendAliYunMsg(); 
  85. $aliPush = new SendAliYunPush(); 
  86. $jgMsg = new SendJiGuangMsg(); 
  87. $jgPush = new SendJiGuangPush(); 
  88.  
  89. $sendAliYun = new SendAliYun(); 
  90. $sendAliYun->setReceiver($aliMsg); 
  91. $sendAliYun->setReceiver($aliPush); 
  92.  
  93. $sendJiGuang = new SendJiGuang(); 
  94. $sendAliYun->setReceiver($jgMsg); 
  95. $sendAliYun->setReceiver($jgPush); 
  96.  
  97. $sendMsg = new SendMsg(); 
  98. $sendMsg->setCommand($sendAliYun); 
  99. $sendMsg->setCommand($sendJiGuang); 
  100.  
  101. $sendMsg->send('这次要搞个大活动，快来注册吧！！'); 

说明

在这个例子中，依然是多命令多执行者的模式

可以将这个例子与抽象工厂进行对比，同样的功能使用不同的设计模式来实现，但是要注意的是，抽象工厂更多的是为了生产对象返回对象，而命令模式则是一种行为的选择

我们可以看出命令模式非常适合形成命令队列，多命令让命令可以一条一条执行下去

它允许接收的一方决定是否要否决请求，Receiver做为实现者拥有更多的话语权

Tags: PHP设计模式 PHP命令模式

分享到：

相关文章

推荐文章

热门文章

最新评论文章