设计模式（16）命令模式

命令模式简介

老样子，为了便于理解这个模式，先举个生活中类似的例子。比如，在使用手机买东西的时候，点了一下付款，然后输入密码就可以完成购物，在点击付款的时候，用户是不会在意手机后台调用了哪些函数，与后台发送了什么数据，进行了哪些安全的校验，同样，手机与后台也同样不知道，具体是谁在使用这个手机和软件，命令的发送方和接收方没有任何实际关联。

在设计模式中，命令模式就是解耦了命令的发送者和接受者，发送者和接受者之间没有直接引用关系，发送者只要知道如何发送请求，不必知道请求是如何完成的。

命令模式：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化，对请求排队或者记录请求日志，以及支持可撤销的操作。

命令模式结构

命令模式的结构如上图，命令模式一共有以下几种角色：

• Command（抽象命令类）：是一个抽象类，声明了用于执行命令的接口execute()。
• ConcreteCommand（具体命令类）：具体的命令类，实现了执行命令的接口execute()，它对应具体的接收者对象，将接收者（Receiver）的动作action()绑定其中。在execu()方法中将调用接收者的动作action()。（这就是定义中的“将请求封装成一个对象”的体现）
• Invoker（调用者）：请求的发送者，通过命令对象来执行请求。一个调用者不需要在设计时确定其接收者，所以调用者通过聚合，与命令类产生关联。具体实现中，可以将一个具体命令对象注入到调用者中，再通过调用具体命令对象的execute()方法，实现简介请求命令执行者（接收者）的操作。
• Receiver（接收者）： 实现处理请求的具体操作（action）。

命令模式代码实例

CommandPattern.h

#include <mutex>
#include <time.h>

using namespace std;

//  命令队列类
#define COMMAND_QUEUE

// 抽象命令类 Command
class Command
{
public:
  Command() {}
  // 声明抽象接口：发送命令
  virtual void execute() = 0;

private:
  Command *command;
};

// 接收者：电灯类
class Lamp
{
public:
  Lamp()
  {
    this->lampState = false;
  }

  void on()
  {
    lampState = true;
    cout << "Lamp is on\n";
  }

  void off()
  {
    lampState = false;
    cout << "Lamp is off\n";
  }

  bool getLampState()
  {
    return lampState;
  }

private:
  bool lampState;
};

// 接收者：风扇类
class Fan
{
public:
  Fan()
  {
    this->fanState = false;
  }

  void on()
  {
    fanState = true;
    cout << "Fan is on\n";
  }

  void off()
  {
    fanState = false;
    cout << "Fan is off\n";
  }

  bool getFanState()
  {
    return fanState;
  }

private:
  bool fanState;
};

// 具体命令类 LampCommand
class LampCommand : public Command
{
public:
  LampCommand()
  {
    cout << "开关控制电灯\n";
    lamp = new Lamp();
  }

  // 实现execute()
  void execute()
  {
    if (lamp->getLampState())
    {
      lamp->off();
    }
    else
    {
      lamp->on();
    }
  }

private:
  Lamp *lamp;
};

// 具体命令类 FanCommand
class FanCommand : public Command
{
public:
  FanCommand()
  {
    cout << "开关控制风扇\n";
    fan = new Fan();
  }

  // 实现execute()
  void execute()
  {
    if (fan->getFanState())
    {
      fan->off();
    }
    else
    {
      fan->on();
    }
  }

private:
  Fan *fan;
};

// 调用者 Button
class Button
{
public:
  Button() {}

  // 注入具体命令类对象
  void setCommand(Command *cmd)
  {
    this->command = cmd;
  }

  // 发送命令：触摸按钮
  void touch()
  {
    cout << "触摸开关:";
    command->execute();
  }

private:
  Command *command;
};

#ifdef COMMAND_QUEUE
/*************************************/
/*             命令队列              */
#include <vector>

// 命令队列类
class CommandQueue
{
public:
  CommandQueue() {}

  void addCommand(Command *cmd)
  {
    commandQueue.push_back(cmd);
  }

  void execute()
  {
    for (int i = 0; i < commandQueue.size(); i++)
    {
      commandQueue[i]->execute();
    }
  }

private:
  vector<Command *> commandQueue;
};

// 调用者
class Button2
{
public:
  Button2() {}

  // 注入具体命令队列类对象
  void setCommandQueue(CommandQueue *cmdQueue)
  {
    this->cmdQueue = cmdQueue;
  }
  
  // 发送命令：触摸按钮
  void touch()
  {
    cout << "触摸开关:";
    cmdQueue->execute();
  }

private:
  CommandQueue *cmdQueue;
};

#endif

CommandPattern.cpp

#include <iostream>
#include "CommandPattern.h"

int main()
{
	// 实例化调用者：按钮
	Button *button = new Button();
	Command *lampCmd, *fanCmd;

	// 按钮控制电灯
	lampCmd = new LampCommand();
	button->setCommand(lampCmd);
	button->touch();
	button->touch();
	button->touch();
	cout << "\n";

	// 按钮控制风扇
	fanCmd = new FanCommand();
	button->setCommand(fanCmd);
	button->touch();
	button->touch();
	button->touch();

#ifdef COMMAND_QUEUE

	cout << "\n***********************************\n";

	Button2 *button2 = new Button2();
	Command *lampCmd2, *fanCmd2;
	CommandQueue *cmdQueue = new CommandQueue();

	// 按钮控制电灯
	lampCmd2 = new LampCommand();
	cmdQueue->addCommand(lampCmd2);

	// 按钮控制风扇
	fanCmd2 = new FanCommand();
	cmdQueue->addCommand(fanCmd2);

	button2->setCommandQueue(cmdQueue);
	button2->touch();

#endif

	cout << "\n";

	delete button;
	delete lampCmd;
	delete fanCmd;
	delete button2;
	delete lampCmd2;
	delete fanCmd2;

	return 0;
}

命令模式总结

优点：

• 降低系统耦合度，将命令的请求者与接收者分离解耦，请求者和发送者不存在直接关联，各自独立互不影响。
• 便于扩展：新的命令很容易加入到系统中，且符合开闭原则。
• 较容易实现命令队列或宏命令。
• 为请求的撤销和回复操作提供了一种设计实现方案。

缺点：

• 命令模式可能导致系统中有过多的具体命令类，增加了系统中对象的数量。

适用环境：

• 系统需要将请求发送者和接收者解耦，使得发送者和接收者互不影响。
• 系统需要在不同时间指定请求、将请求排队和执行请求。
• 系统需要支持命令的撤销和恢复操作。
• 系统需要将一组操作组合在一起形成宏命令。