【第19节】C++设计模式(行为模式)-Command(命令)模式
一、问题描述
Command 模式是一种行为设计模式,它将请求封装为一个对象,从而使你可以用不同的请求对客户进行参数化,并支持请求的排队、记录日志以及撤销操作。Command 模式的核心思想是将请求的发送者(Invoker)与请求的接收者(Receiver)解耦,使得请求的发送者不需要知道具体的接收者是谁,甚至不需要知道请求是如何被处理的。
二、模式选择
Command 模式的典型结构图如下:
在 Command 模式的结构图中,请求的接收者(Receiver)被放到 `Command` 的具体子类 `ConcreteCommand` 中。当请求到来时(Invoker 发出 `Invoke` 消息激活 Command 对象),`ConcreteCommand` 将处理请求交给 `Receiver` 对象进行处理。
三、代码实现
下面我们将通过一个完整的 C++ 代码示例来展示如何实现 Command 模式。
代码片段 1:Receiver.h
// Receiver.h
#ifndef _RECEIVER_H_
#define _RECEIVER_H_
class Receiver {
public:
Receiver();
~Receiver();
void Action(); // 接收者执行的具体操作
protected:
private:
};
#endif //~_RECEIVER_H_
代码片段 2:Receiver.cpp
// Receiver.cpp
#include "Receiver.h"
#include <iostream>
Receiver::Receiver() {
// 构造函数
}
Receiver::~Receiver() {
// 析构函数
}
void Receiver::Action() {
std::cout << "Receiver action......." << std::endl;
}
代码片段 3:Command.h
// Command.h
#ifndef _COMMAND_H_
#define _COMMAND_H_
class Receiver;
class Command {
public:
virtual ~Command();
virtual void Execute() = 0; // 执行命令的接口
protected:
Command();
private:
};
class ConcreteCommand : public Command {
public:
ConcreteCommand(Receiver* rev);
~ConcreteCommand();
void Execute(); // 实现执行命令的具体逻辑
protected:
private:
Receiver* _rev; // 接收者对象
};
#endif //~_COMMAND_H_
代码片段 4:Command.cpp
// Command.cpp
#include "Command.h"
#include "Receiver.h"
Command::Command() {
// 构造函数
}
Command::~Command() {
// 析构函数
}
ConcreteCommand::ConcreteCommand(Receiver* rev) : _rev(rev) {
// 构造函数
}
ConcreteCommand::~ConcreteCommand() {
// 析构函数
}
void ConcreteCommand::Execute() {
_rev->Action(); // 调用接收者的具体操作
}
代码片段 5:Invoker.h
// Invoker.h
#ifndef _INVOKER_H_
#define _INVOKER_H_
class Command;
class Invoker {
public:
Invoker(Command* cmd);
~Invoker();
void Invoke(); // 调用命令的执行
protected:
private:
Command* _cmd; // 命令对象
};
#endif //~_INVOKER_H_
代码片段 6:Invoker.cpp
// Invoker.cpp
#include "Invoker.h"
#include "Command.h"
Invoker::Invoker(Command* cmd) : _cmd(cmd) {
// 构造函数
}
Invoker::~Invoker() {
// 析构函数
}
void Invoker::Invoke() {
_cmd->Execute(); // 执行命令
}
代码片段 7:main.cpp
// main.cpp
#include "Command.h"
#include "Invoker.h"
#include "Receiver.h"
#include <iostream>
int main(int argc, char* argv[]) {
Receiver* rev = new Receiver(); // 创建接收者对象
Command* cmd = new ConcreteCommand(rev); // 创建具体命令对象
Invoker* inv = new Invoker(cmd); // 创建调用者对象
inv->Invoke(); // 调用命令
return 0;
}
代码说明
Command 模式的实现和思想都很简单,其关键就是将一个请求封装到一个类中(Command),再提供处理对象(Receiver),最后 Command 命令由 Invoker 激活。另外,我们可以将请求接收者的处理抽象出来作为参数传给 Command 对象,实际也就是回调的机制(Callback)来实现这一点,也就是说将处理操作方法地址(在对象内部)通过参数传递给 Command 对象,Command 对象在适当的时候(Invoke 激活的时候)再调用该函数。这里就要用到 C++ 中的类成员函数指针的概念,为了方便学习,这里给出一个简单的实现源代码供参考:
代码片段 1:Receiver.h
// Receiver.h
#ifndef _RECEIVER_H_
#define _RECEIVER_H_
class Receiver {
public:
Receiver();
~Receiver();
void Action();
protected:
private:
};
#endif //~_RECEIVER_H_
代码片段 2:Receiver.cpp
// Receiver.cpp
#include "Receiver.h"
#include <iostream>
Receiver::Receiver() {
// 构造函数
}
Receiver::~Receiver() {
// 析构函数
}
void Receiver::Action() {
std::cout << "Receiver action......." << std::endl;
}
代码片段 3:Command.h
// Command.h
#ifndef _COMMAND_H_
#define _COMMAND_H_
template <class Receiver>
class SimpleCommand : public Command {
public:
typedef void (Receiver::* Action)();
SimpleCommand(Receiver* rev, Action act) : _rev(rev), _act(act) {
// 构造函数
}
virtual void Execute() {
(_rev->* _act)();
}
~SimpleCommand() {
delete _rev;
}
protected:
private:
Receiver* _rev;
Action _act;
};
#endif //~_COMMAND_H_
代码片段 4:main.cpp
// main.cpp
#include "Command.h"
#include "Receiver.h"
#include <iostream>
using namespace std;
int main(int argc, char* argv[]) {
Receiver* rev = new Receiver();
Command* cmd = new SimpleCommand<Receiver>(rev, &Receiver::Action);
cmd->Execute();
return 0;
}
四、总结讨论
Command 模式的思想非常简单,但是 Command 模式也十分常见,并且威力不小。实际上,Command 模式关键就是提供一个抽象的 Command 类,并将执行操作封装到 Command 类接口中,Command 类中一般就是只是一些接口的集合,并不包含任何的数据属性(当然在示例代码中,我们的 Command 类有一个处理操作的 Receiver 类的引用,但是其作用也仅仅就是为了实现这个 Command 的 Execute 接口)。这种方式在是纯正的面向对象设计者最为鄙视的设计方式,就像 OO 设计新手做系统设计的时候,仅仅将 Class 作为一个关键字,将 C 种的全局函数找一个类封装起来就以为是完成了面向对象的设计。
但是世界上的事情不是绝对的,上面提到的方式在 OO 设计种绝大部分的时候可能是一个不成熟的体现,但是在 Command 模式中却是起到了很好的效果。主要体现在:
(1)解耦:Command 模式将调用操作的对象和知道如何实现该操作的对象解耦。在上面 Command 的结构图中,Invoker 对象根本就不知道具体的是那个对象在处理 Execute 操作(当然要知道是 Command 类别的对象,也仅此而已)。
(2)扩展:在 Command 要增加新的处理操作对象很容易,我们可以通过创建新的继承自 Command 的子类来实现这一点。
(3)撤销操作:Command 模式可以和 Memento 模式结合起来,支持取消的操作。
通过以上讨论,我们可以看到 Command 模式在面向对象设计中的独特价值和广泛应用场景。