设计模式解析之——Command模式（k_eckel转自微软高校博客K_eckel's mindview）

0 引言

0.1 目的

       本文档给出设计模式之——Command模式的简化诠释，并给出其C++实现。

0.2 说明

Project	Design Pattern Explanation（By K_Eckel）
Authorization	Free Distributed but Ownership Reserved
Date	2005-04-05（Cherry blossom is Beautiful）
Test Bed	MS Visual C++ 6.0

0.3 参考

       在本文档的写作中，参考了以下的资源，在此列出表示感谢：

u       书籍

[GoF 2000]：GoF,Design Patterns-Elements of Reusable Object-Oriented Software

Addison-Wesley 2000/9.

        [Martine 2003]：Robert C.Martine, Agile Software Development Principles, Patterns, and Practices, Pearson Education, 2003.

0.4 联系作者

Author	K_Eckel
State	Candidate for Master’s Degree School of Computer Wuhan University
E_mail	frwei@whu.edu.cn

2 Command模式

2.1 问题

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

2.2 模式选择

Command模式的典型结构图为：

图2-1：Command Pattern结构图

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

2.3 实现

2.3.1 完整代码示例（code）

       Command模式的实现很简单，这里为了方便初学者的学习和参考，将给出完整的实现代码（所有代码采用C++实现，并在VC 6.0下测试运行）。

代码片断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;
}

2.3.2 代码说明

       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的子类以支持更复杂的处理。

2.4 讨论

       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模式结合起来，支持取消的操作。