设计模式19--Command模式（命令模式）---行为型模式

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

 

 

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

#pragma once
//Reciever.h
class Reciever 
{ 
public: 
	Reciever();
	~Reciever(); 
	void Action(); 
protected: 
private:
};
//Reciever.cpp 
#include "stdafx.h"
#include "Reciever.h" 
#include <iostream>
Reciever::Reciever()
{ 
} 
Reciever::~Reciever() 
{ 
} 
void Reciever::Action() 
{ 
	std::cout<<"Reciever action......."<<std::endl; 
}

#pragma once
//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; 
};

//Command.cpp 
#include "stdafx.h"
#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; 
}

#pragma once
//Invoker.h
class Command; 
class Invoker 
{ 
public: 
	Invoker(Command* cmd); 
	~Invoker();
	void Invoke(); 
protected: 
private: 
	Command* _cmd; 
};

//Invoker.cpp 
#include "stdafx.h"
#include "Invoker.h" 
#include "Command.h" 
#include <iostream>
Invoker::Invoker(Command* cmd) 
{ 
	_cmd = cmd; 
} 
Invoker::~Invoker() 
{ 
	delete _cmd; 
} 
void Invoker::Invoke() 
{ 
	_cmd->Excute(); 
}

int main(int argc, _TCHAR* 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++中的类成员函数指针的概念，为了方便学习，这里给出一个简单的实现源代码供 参考：

#pragma once
//Reciever.h
class Reciever 
{ 
public: 
	Reciever();
	~Reciever(); 
	void Action(); 
protected: 
private:
};

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


#pragma once
//Command.h
class Reciever; 
class Command 
{ 
public: 
	virtual ~Command();
	virtual void Excute() = 0;
protected: 
	Command(); 
private:
}; 

2
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; 
};

int main(int argc, _TCHAR* argv[])
{
	Reciever* rev2 = new Reciever();
	Command* cmd2 = new SimpleCommand<Reciever>(rev2,&Reciever::Action); 
	cmd2->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 模式结合起来，支持取消的操作。