命令模式

命令模式

问题

Command 模式通过将请求封装到一个对象（Command） 中， 并将请求的接受者存放到
具体的 ConcreteCommand 类中（Receiver） 中， 从而实现调用操作的对象和操作的具体实现
者之间的解耦。

模式选择

Command 模式的典型结构图为：

Command 模式结构图中，将请求的接收者（处理者）放到 Command 的具体子类
ConcreteCommand 中，当请求到来时（Invoker 发出 Invoke 消息激Command 对象），ConcreteCommand 将处理请求交给 Receiver 对象进行处理。

实现

Command模式的实现很简单，这里为了方便初学者的学习和参考，将给出完整实现代码。

代码片断 1： Reciever.h

//Reciever.h
#ifndef _RECIEVER_H_
#define _RECIEVER_H_
class Reciever
{
public:
    Reciever();
    ~Reciever();
    void Action();
protected:
private:
};
#endif //~_RECIEVER_H_

代码片断 2： Reciever.cpp

//Reciever.cpp
#include "Reciever.h"
#include <iostream>
Reciever::Reciever()
{
}
Reciever::~Reciever()
{
}
void Reciever::Action()
{
    std::cout<<"Reciever action......."<<std::endl;
}

代码片断 3： Command.h

//Command.h
ifndef COMMAND_H
define COMMAND_H
class Reciever;
class Command
{
public:
    virtual ~Command();
    virtual void Excute() = 0;
protected:
    Command();
private: 
};
class ConcreteCommand:public Command
{
public:
    ConcreteCommand(Reciever* rev);
    ~ConcreteCommand();
    void Excute();
protected:
private:
    Reciever* _rev;
};
#endif //~_COMMAND_H_

代码片断 4： Command.cpp

//Command.cpp
#include "Command.h"
#include "Reciever.h"
#include <iostream>
Command::Command()
{
}
Command::~Command()
{
}
void Command::Excute()
{
}
ConcreteCommand::ConcreteCommand(Reciever* rev)
{
    this->_rev = rev;
}
ConcreteCommand::~ConcreteCommand()
{
    delete this->_rev;
}
void ConcreteCommand::Excute()
{
    _rev->Action();
    std::cout<<"ConcreteCommand..."<<std::endl;
}

代码片断 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"
#include <iostream>
Invoker::Invoker(Command* cmd)
{
    _cmd = cmd;
}
Invoker::~Invoker()
{
    delete _cmd;
}
void Invoker::Invoke()
{
    _cmd->Excute();
}

代码片断 7： main.cpp

//main.cpp
#include "Command.h"
#include "Invoker.h"
#include "Reciever.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[])
{
    Reciever* rev = new Reciever();
    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： Reciever.h

//Reciever.h
#ifndef _RECIEVER_H_
#define _RECIEVER_H_
class Reciever
{
public:
    Reciever();
    ~Reciever();
    void Action();
protected:
private:
};
#endif //~_RECIEVER_H_

代码片断 2： Reciever.cpp

//Reciever.cpp
#include "Reciever.h"
#include <iostream>
Reciever::Reciever()
{
}
Reciever::~Reciever()
{
}
void Reciever::Action()
{
    std::cout<<"Reciever action......."<<std::endl;
}

代码片断 3： Command.h

//Command.h
#ifndef _COMMAND_H_
#define _COMMAND_H_
template <class Reciever>
class SimpleCommand:public Command
{
public:
typedef void (Reciever::* Action)();
SimpleCommand(Reciever* rev,Action act)
{
_rev = rev;
_act = act;
}
virtual void Excute()
{
(_rev->* _act)();
}
~SimpleCommand()
{
delete _rev;
}
protected:
private:
Reciever* _rev;
Action _act;
};
#endif //~_COMMAND_H_

代码片断 4： main.cpp

//main.cpp
#include "Command.h"
#include "Reciever.h"
#include <iostream>
using namespace std;
int main(int arc,char* argv[])
{
Reciever* rev = new Reciever();
Command* cmd = new
SimpleCommand<Reciever>(rev,&Reciever::Action);
cmd->Excute();
return 0;
}

注意到上面通过模板的方式来参数化请求的接收者， 当然是为了简单演示。 在复杂的情况下我们会提供一个抽象 Command 对象， 然后创建 Command 的子类以支持更复杂的处理。

讨论
Command 模式的思想非常简单，但是 Command 模式也十分常见，并且威力不小。实际上， Command 模式关键就是提供一个抽象的 Command 类， 并将执行操作封装到 Command类接口中， Command 类中一般就是只是一些接口的集合，并不包含任何的数据属性（当然在示例代码中， 我们的 Command 类有一个处理操作的 Receiver 类的引用， 但是其作用也仅仅就是为了实现这个 Command 的 Excute 接口）。 这种方式在是纯正的面向对象设计者最为鄙视的设计方式， 就像 OO 设计新手做系统设计的时候， 仅仅将 Class 作为一个关键字， 将C 种的全局函数找一个类封装起来就以为是完成了面向对象的设计。
但是世界上的事情不是绝对的， 上面提到的方式在 OO 设计种绝大部分的时候可能是一个不成熟的体现，但是在 Command 模式中却是起到了很好的效果。主要体现在：
1） Command 模式将调用操作的对象和知道如何实现该操作的对象解耦。在上面Command 的结构图中， Invoker 对象根本就不知道具体的是那个对象在处理 Excute操作（当然要知道是 Command 类别的对象，也仅此而已）。
2） 在 Command 要增加新的处理操作对象很容易，我们可以通过创建新的继承自Command 的子类来实现这一点。
3） Command 模式可以和 Memento 模式结合起来，支持取消的操作。