行为型 - 命令模式(Command)

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

​[[toc]]

概念

Command 模式典型的结构图为：

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

备注：这里的Invoke 消息就是下面Notify()来处理的。

代码实现

模型代码实现

#ifndef _RECIEVER_H_
#define _RECIEVER_H_
class Reciever
{
public:
	Reciever();
	~Reciever();
	void Action();

protected:
private:
};
#endif //~_RECIEVER_H_

#include "Reciever.h"
#include <iostream>

Reciever::Reciever()
{
}

Reciever::~Reciever()
{
}

void Reciever::Action()
{
    std::cout << "Reciever action......." << std::endl;
}

#ifndef _COMMAND_H_
#define _COMMAND_H_
#include <iostream>

using namespace std;
class Reciever;

class Command
{
public:
    virtual ~Command();
    virtual void Excute() = 0;

protected:
    Command();

private:
};

class ConcreteCommandA : public Command
{
public:
    ConcreteCommandA(Reciever *rev);
    ~ConcreteCommandA();
    void Excute();

protected:
private:
    Reciever *_rev;
};

class ConcreteCommandB : public Command
{
public:
    ConcreteCommandB(Reciever *rev);
    ~ConcreteCommandB();
    void Excute();

protected:
private:
    Reciever *_rev;
};

#endif //~_COMMAND_H_

#include "Command.h"
#include "Reciever.h"

Command::Command()
{
}

Command::~Command()
{
}

void Command::Excute()
{
}

ConcreteCommandA::ConcreteCommandA(Reciever *rev)
{
    this->_rev = rev;
}

ConcreteCommandA::~ConcreteCommandA()
{
}

void ConcreteCommandA::Excute()
{
    cout << "ConcreteCommandA Excute" << endl;
    _rev->Action();
}

ConcreteCommandB::ConcreteCommandB(Reciever *rev)
{
    this->_rev = rev;
}

ConcreteCommandB::~ConcreteCommandB()
{
}

void ConcreteCommandB::Excute()
{
    cout << "ConcreteCommandB Excute" << endl;
    _rev->Action();
}

#ifndef _INVOKER_H_
#define _INVOKER_H_
#include <vector>
#include <iostream>

using namespace std;

class Command;
class Invoker
{
public:
    Invoker(Command *cmd);
    Invoker();
    ~Invoker();

    void Add(Command *cmd);
    void Remove(Command *cmd);
    void RemoveAll();
    void Notify();

protected:
private:
    Command *_cmd;
    vector<Command *> _commands;
};
#endif //~_INVOKER_H_

#include "Invoke.h"
#include "Command.h"

Invoker::Invoker(Command *cmd) : _cmd(cmd)
{
}

Invoker::Invoker()
{
}

Invoker::~Invoker()
{
    delete _cmd;
}

void Invoker::Add(Command *cmd)
{
    _commands.push_back(cmd);
}

void Invoker::Remove(Command *cmd)
{
    for (std::vector<Command *>::iterator iter = _commands.begin(); iter != _commands.end(); )
    {
        if (*iter == cmd)
        {
            iter =_commands.erase(iter);
        }
        else
        {
            iter++;
        }
    }
}

void Invoker::RemoveAll()
{
    _commands.clear();
}

void Invoker::Notify()
{
    std::vector<Command *>::iterator it = _commands.begin();
    for (; it != _commands.end(); ++it)
    {
        _cmd = *it;
        _cmd->Excute();
    }
}

#include "Reciever.h"
#include "Invoke.h"
#include "Command.h"

int main(int argc, char *argv[])
{
	Reciever *pstReceiver = new Reciever();
	Command *pstConcreteCommandA = new ConcreteCommandA(pstReceiver);
	Command *pstConcreteCommandB = new ConcreteCommandB(pstReceiver);
	Invoker *pstInvoke = new Invoker();

	pstInvoke->Add(pstConcreteCommandA);
	pstInvoke->Add(pstConcreteCommandA);
	pstInvoke->Add(pstConcreteCommandB);
	pstInvoke->Notify();
	cout << "------------------" << endl;

	pstInvoke->Remove(pstConcreteCommandA); //撤销操作
	// pstInvoke->Remove(pstConcreteCommandB);
	pstInvoke->Notify();
	cout << "------------------" << endl;

	return 0;
}

上述例子中

void Add(Command *cmd);//添加命令
void Remove(Command *cmd);//删除命令
void RemoveAll();//删除全部命令
void Notify();//通知执行所有命令

[root@VM-16-6-centos Command]# ./CommandTest
ConcreteCommandA Excute
Reciever action.......
ConcreteCommandA Excute
Reciever action.......
ConcreteCommandB Excute
Reciever action.......
------------------
ConcreteCommandB Excute
Reciever action.......
------------------