17. 命令模式
一、命令模式
命令模式（Command Pattern）是一种行为设计模式，它将请求封装为对象，从而让你使用不同的请求把客户端与请求的处理逻辑分开。这种类型的设计模式属于行为模式。在命令模式中，一个命令对象封装了与一个特定的接收者对象相关的请求，并可以在任何时候被执行。命令模式可以将请求发送者和接收者完全解耦。发送者与接收者之间没有直接引用关系，发送请求的对象只需要知道如何发送请求，而不必知道如何完成请求。
命令模式的主要角色如下：
- 抽象命令角色（Command）：抽象命令类一般是一个抽象类或接口，在其中声明了用于执行请求的 execute() 等方法，通过这些方法可以调用请求接收者的相关操作。
- 具体命令角色（Concrete Command）：具体命令类是抽象命令类的子类，实现了在抽象命令类中声明的方法。它对应具体的接收者对象，将接收者对象的动作绑定其中。在实现 execute() 方法时，将调用接收者对象的相关操作（Action）。
- 实现者/接收者角色（Recveiver）：接收者执行与请求相关的操作，它具体实现对请求的业务处理。
- 调用者/请求者（Invoker）：调用者即请求发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联关系。在程序运行时可以将一个具体命令对象注入其中，再调用具体命令对象的 execute() 方法，从而实现间接调用请求接收者的相关操作。
命令模式的核心在于引入了命令类。通过命令类来降低发送者和接收者的耦合度，请求发送者只需指定一个命令对象，再通过命令对象来调用请求接收者的处理方法。
命令模式的本质是 对请求进行封装。一个请求对应于一个命令，将发出命令的责任和执行命令的责任分割开。每个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行相应的操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求如何被接收、操作是否被执行、何时被执行，以及是怎么被执行的。
总的来说，命令模式通过封装请求为对象，使得请求的发送者与接收者解耦，提高了系统的灵活性和可扩展性。
二、C++实现命令模式
请求接收者 Receiver 类具体实现对请求的业务处理，它提供了 action() 方法，用于执行与请求相关的操作。
// 请求接收者
class LightReceiver
{
public:
void on(void);
void off(void);
};
void LightReceiver::on(void)
{
std::cout << "开灯" << std::endl;
}
void LightReceiver::off(void)
{
std::cout << "关灯" << std::endl;
}
命令模式的关键在于引入了 抽象命令类。请求发送者针对抽象命令类编程，只有实现了抽象命令类的具体命令才与请求接收者相关联。在最简单的抽象命令类中只包含了一个抽象的 execute() 方法，每个具体命令类将一个 Receiver 类型的对象作为一个实例变量进行存储，从而具体指定一个请求的接收者。不同的具体命令类提供了 execute() 方法的不同实现，并调用不同接收者的请求处理方法。
// 抽象命令角色
class Command
{
public:
virtual void execute(void) = 0;
};
具体命令类 继承了抽象命令类，它与请求接收者相关联，实现了在抽象命令类中声明的 execute() 方法，并在实现时调用接收者的请求响应方法 action()。
// 具体命令角色
class LightOnCommand : public Command
{
private:
LightReceiver * light; // 请求接收者的引用
public:
LightOnCommand(void);
~LightOnCommand(void);
void execute(void) override;
};
LightOnCommand::LightOnCommand(void)
{
light = new LightReceiver();
}
LightOnCommand::~LightOnCommand(void)
{
if (light != nullptr)
{
delete light;
}
}
void LightOnCommand::execute(void)
{
light->on();
}
// 具体命令角色
class LightOffCommand : public Command
{
private:
LightReceiver * light; // 请求接收者的引用
public:
LightOffCommand(void);
~LightOffCommand(void);
void execute(void) override;
};
LightOffCommand::LightOffCommand(void)
{
light = new LightReceiver();
}
LightOffCommand::~LightOffCommand(void)
{
if (light != nullptr)
{
delete light;
}
}
void LightOffCommand::execute(void)
{
light->off();
}
对于 请求发送者 即调用者而言，将针对抽象命令类进行编程，可以通过构造注入或者设值注入的方式在运行时传入具体命令类对象，并在业务方法中调用命令对象的 execute() 方法。
// 请求发送者
class RemoteControl
{
private:
Command * command; // 抽象命令对象的引用
public:
void SendRequest(void);
Command * getCommand(void);
void setCommand(Command * command);
};
void RemoteControl::SendRequest(void)
{
command->execute();
}
Command * RemoteControl::getCommand(void)
{
return command;
}
void RemoteControl::setCommand(Command * command)
{
this->command = command;
}
main() 函数：
#include <iostream>
int main(void)
{
LightOnCommand lightOnCommand;
LightOffCommand lightOffCommand;
RemoteControl remoteControl;
remoteControl.setCommand(&lightOnCommand);
remoteControl.SendRequest();
remoteControl.setCommand(&lightOffCommand);
remoteControl.SendRequest();
return 0;
}
如果需要修改功能键的功能，只需要对应增加一个新的具体命令类。在该命令类与处理者之间创建一个关联关系，然后将该具体命令类的对象通过配置文件注入某个功能键即可，原有代码无须修改，符合开闭原则。在此过程中，每一个具体命令类对应一个请求的处理者（接收者）。通过向请求发送者注入不同的具体命令对象可以使得相同的发送者对应不同的接收者，从而实现 “将一个请求封装为一个对象，用不同的请求对客户进行参数化”。客户端只需要将具体命令对象作为参数注入请求发送者，无须直接操作请求的接收者。
三、命令队列的实现
有时需要将多个请求排队。当一个请求发送者发送一个请求时，不止一个请求接收者产生响应，这些请求接收者将逐个执行业务方法，完成对请求的处理。此时，可以通过命令队列来实现。
命令队列的实现方法有多种形式，其中最常用、灵活性最好的一种方式是增加一个 CommandQueue 类。CommandQueue 类负责存储多个命令对象，而不同的命令对象可以对应不同的请求接收者。
// 命令队列
class CommandQueue
{
private:
std::vector<Command *> commands;
public:
void addCommand(Command * command);
void removeCommand(Command * command);
void execute(void);
};
void CommandQueue::addCommand(Command * command)
{
commands.push_back(command);
}
void CommandQueue::removeCommand(Command * command)
{
for (auto it = commands.begin(); it != commands.end(); it++)
{
if (*it == command)
{
commands.erase(it);
}
}
}
void CommandQueue::execute(void)
{
for (auto it = commands.begin(); it != commands.end(); it++)
{
(*it)->execute();
}
}
在增加了命令队列类 CommandQueue 以后，请求发送者类 Invoker 将针对 CommandQueue 编程。
// 命令队列
class CommandQueue
{
private:
std::vector<Command *> commands;
public:
void addCommand(Command * command);
void removeCommand(Command * command);
void execute(void);
};
void CommandQueue::addCommand(Command * command)
{
commands.push_back(command);
}
void CommandQueue::removeCommand(Command * command)
{
for (auto it = commands.begin(); it != commands.end(); it++)
{
if (*it == command)
{
commands.erase(it);
}
}
}
void CommandQueue::execute(void)
{
for (auto it = commands.begin(); it != commands.end(); it++)
{
(*it)->execute();
}
}
main() 函数：
#include <iostream>
#include <vector>
int main(void)
{
CommandQueue commands;
LightOnCommand lightOnCommand;
LightOffCommand lightOffCommand;
commands.addCommand(&lightOnCommand);
commands.addCommand(&lightOffCommand);
RemoteControl remoteControl;
remoteControl.setCommands(&commands);
remoteControl.SendRequest();
return 0;
}
命令队列与批处理有点类似。批处理，顾名思义，可以对一组对象（命令）进行批量处理，当一个发送者发送请求后，将有一系列接收者对请求做出响应。命令队列可以用于设计批处理应用程序，如果请求接收者的接收次序没有严格的先后次序，还可以使用多线程技术来并发调用命令对象的 execute() 方法，从而提高程序的执行效率。
四、命令模式的总结
命令模式用于将请求发送者与接收者解耦。请求发送者通过命令对象来间接引用请求接收者，使得系统具有更好的灵活性和可扩展性。
4.1、命令模式的优点
- 降低系统的耦合度。由于请求者与接收者之间不存在直接引用，因此请求者与接收者之间实现完全解耦，相同的请求者可以对应不同的接收者。同样，相同的接收者也可以供不同的请求者使用，两者之间具有良好的独立性。
- 新的命令可以很容易地加入系统中。由于增加新的具体命令类不会影响到其他类，因此增加新的具体命令类很容易，无须修改原有系统源代码甚至客户类代码，满足开闭原则的要求。
- 可以比较容易地设计一个命令队列或宏命令（组合命令）。
- 为请求的撤销（Undo）和恢复（Redo）操作提供了一种设计和实现方案。
4.2、命令模式的缺点
使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个对请求接收者的调用操作都需要设计一个具体命令类，因此在某些系统中可能需要提供大量的具体命令类，这将影响命令模式的使用。
4.3、命令模式的适用场景
- 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。请求调用者无须知道接收者的存在，也无须知道接收者是谁，接收者也无须关心何时被调用。
- 系统需要在不同的时间指定请求、将请求排队和执行请求。一个命令对象和请求的初始调用者可以有不同的生命期。换言之，最初的请求发出者可能已经不在了，而命令对象本身仍然是活动的，可以通过该命令对象去调用请求接收者，而无须关心请求调用者的存在性，可以通过请求日志文件等机制来具体实现。
- 系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作。
- 系统需要将一组操作组合在一起形成宏命令。
