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

class Invoker
{
 public $command;
 
 public function __construct($command)
 {
  $this->command = $command;
 }
 public function exec()
 {
  $this->command->execute();
 }
}

abstract class Command
{
 protected $receiver;
 public function __construct(Receiver $receiver)
 {
  $this->receiver = $receiver;
 }
 abstract public function execute();
}
class ConcreteCommand extends Command
{
 public function execute()
 {
  $this->receiver->action();
 }
}

class Receiver
{
 public $name;
 public function __construct($name)
 {
  $this->name = $name;
 }
 public function action()
 {
  echo $this->name . '命令执行了！', PHP_EOL;
 }
}

// 准备执行者
$receiverA = new Receiver('A');
// 准备命令
$command = new ConcreteCommand($receiverA);
// 请求者
$invoker = new Invoker($command);
$invoker->exec();

<?php
class Invoker
{
 private $command = [];
 public function setCommand(Command $command)
 {
  $this->command[] = $command;
 }
 public function exec()
 {
  if(count($this->command) > 0){
   foreach ($this->command as $command) {
  $command->execute();
   }
  }
 }
 public function undo()
 {
  if(count($this->command) > 0){
   foreach ($this->command as $command) {
  $command->undo();
   }
  }
 }
}
abstract class Command
{
 protected $receiver;
 protected $state;
 protected $name;
 public function __construct(Receiver $receiver, $name)
 {
  $this->receiver = $receiver;
  $this->name = $name;
 }
 abstract public function execute();
}
class ConcreteCommand extends Command
{
 public function execute()
 {
  if (!$this->state || $this->state == 2) {
   $this->receiver->action();
   $this->state = 1;
  } else {
   echo $this->name . '命令正在执行，无法再次执行了！', PHP_EOL;
  }
 }
 
 public function undo()
 {
  if ($this->state == 1) {
   $this->receiver->undo();
   $this->state = 2;
  } else {
   echo $this->name . '命令未执行，无法撤销了！', PHP_EOL;
  }
 }
}
class Receiver
{
 public $name;
 public function __construct($name)
 {
  $this->name = $name;
 }
 public function action()
 {
  echo $this->name . '命令执行了！', PHP_EOL;
 }
 public function undo()
 {
  echo $this->name . '命令撤销了！', PHP_EOL;
 }
}
// 准备执行者
$receiverA = new Receiver('A');
$receiverB = new Receiver('B');
$receiverC = new Receiver('C');
// 准备命令
$commandOne = new ConcreteCommand($receiverA, 'A');
$commandTwo = new ConcreteCommand($receiverA, 'B');
$commandThree = new ConcreteCommand($receiverA, 'C');
// 请求者
$invoker = new Invoker();
$invoker->setCommand($commandOne);
$invoker->setCommand($commandTwo);
$invoker->setCommand($commandThree);
$invoker->exec();
$invoker->undo();
// 新加一个单独的执行者，只执行一个命令
$invokerA = new Invoker();
$invokerA->setCommand($commandOne);
$invokerA->exec();
// 命令A已经执行了，再次执行全部的命令执行者，A命令的state判断无法生效
$invoker->exec();

  

• 这一次我们一次性解决了多个订单、多位厨师的问题，并且还顺便解决了如果下错命令了，进行撤销的问题  
  
• 可以看出来，命令模式将调用操作的对象与知道如何实现该操作的对象实现了解耦  
  
• 这种多命令多执行者的实现，有点像 组合模式 的实现  
  
• 在这种情况下，增加新的命令，即不会影响执行者，也不会影响客户。当有新的客户需要新的命令时，只需要增加命令和请求者即可。即使有修改的需求，也只是修改请求者。  
  
• Laravel框架的事件调度机制中，除了观察者模式外，也很明显的能看出命令模式的影子
  

<?php
class SendMsg
{
 private $command = [];
 public function setCommand(Command $command)
 {
  $this->command[] = $command;
 }
 
 public function send($msg)
 {
  foreach ($this->command as $command) {
   $command->execute($msg);
  }
 }
}
abstract class Command
{
 protected $receiver = [];
 public function setReceiver($receiver)
 {
  $this->receiver[] = $receiver;
 }
 abstract public function execute($msg);
}
class SendAliYun extends Command
{
 public function execute($msg)
 {
  foreach ($this->receiver as $receiver) {
   $receiver->action($msg);
  }
 }
}
class SendJiGuang extends Command
{
 public function execute($msg)
 {
  foreach ($this->receiver as $receiver) {
   $receiver->action($msg);
  }
 }
}
class SendAliYunMsg
{
 public function action($msg)
 {
  echo '【阿X云短信】发送：' . $msg, PHP_EOL;
 }
}
class SendAliYunPush
{
 public function action($msg)
 {
  echo '【阿X云推送】发送：' . $msg, PHP_EOL;
 }
}
class SendJiGuangMsg
{
 public function action($msg)
 {
  echo '【极X短信】发送：' . $msg, PHP_EOL;
 }
}
class SendJiGuangPush
{
 public function action($msg)
 {
  echo '【极X推送】发送：' . $msg, PHP_EOL;
 }
}
$aliMsg = new SendAliYunMsg();
$aliPush = new SendAliYunPush();
$jgMsg = new SendJiGuangMsg();
$jgPush = new SendJiGuangPush();
$sendAliYun = new SendAliYun();
$sendAliYun->setReceiver($aliMsg);
$sendAliYun->setReceiver($aliPush);
$sendJiGuang = new SendJiGuang();
$sendAliYun->setReceiver($jgMsg);
$sendAliYun->setReceiver($jgPush);
$sendMsg = new SendMsg();
$sendMsg->setCommand($sendAliYun);
$sendMsg->setCommand($sendJiGuang);
$sendMsg->send('这次要搞个大活动，快来注册吧！！');

  

• 在这个例子中，依然是多命令多执行者的模式  
  
• 可以将这个例子与抽象工厂进行对比，同样的功能使用不同的设计模式来实现，但是要注意的是，抽象工厂更多的是为了生产对象返回对象，而命令模式则是一种行为的选择  
  
• 我们可以看出命令模式非常适合形成命令队列，多命令让命令可以一条一条执行下去  
  
• 它允许接收的一方决定是否要否决请求，Receiver做为实现者拥有更多的话语权