命令模式

转自：
https://www.runoob.com/design-pattern/command-pattern.html
https://blog.csdn.net/luoyayun361/article/details/88163530
https://www.cnblogs.com/lizhanwu/p/4435359.html

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

意图：将一个请求封装成一个对象，从而使您可以用不同的请求对客户进行参数化。

主要解决：在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。

何时使用：在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如何将"行为请求者"与"行为实现者"解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。

如何解决：通过调用者调用接受者执行命令，顺序：调用者→接受者→命令。

关键代码：定义三个角色：1、received 真正的命令执行对象 2、Command 3、invoker 使用命令对象的入口

应用实例：struts 1 中的 action 核心控制器 ActionServlet 只有一个，相当于 Invoker，而模型层的类会随着不同的应用有不同的模型类，相当于具体的 Command。

优点： 1、降低了系统耦合度。 2、新的命令可以很容易添加到系统中去。

缺点：使用命令模式可能会导致某些系统有过多的具体命令类。

使用场景：认为是命令的地方都可以使用命令模式，比如： 1、GUI 中每一个按钮都是一条命令。 2、模拟 CMD。

注意事项：系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作，也可以考虑使用命令模式，见命令模式的扩展。

示例 1：

/**
  * 命令模式，消除代码间的耦合
  */
#include <iostream>
#include <vector>

using namespace std;

class Command
{
public:
   virtual void excute() = 0;
};

class Hello : public Command
{
public:
    void excute(){cout << "Hello " << endl;}
};

class World : public Command
{
public:
    void excute(){cout << "World! " << endl;}
};

class IAm : public Command
{
public:
    void excute(){cout << "I'm the command pattern " << endl;}
};

class Macro
{
public:
    void add(Command* c){
        commands.push_back(c);
    }

    void run(){
        vector<Command*>::iterator it = commands.begin();
        while(it != commands.end()){
            (*it++)->excute();
        }
    }
private:
    vector<Command*> commands;
};

int main()
{
    Macro macro;
    macro.add(new Hello);
    macro.add(new World);
    macro.add(new IAm);
    macro.run();
    return 0;
}

示例 2：

#include <iostream>  
#include <string>
#include <vector>
using namespace std;

#define SAFE_DELETE(p) if (p) { delete p; p = NULL; }

/*烤肉师傅类，只负责烤串工作*/
class Barbecuer
{
public:
    void BakeMutton(){cout<<"Bake mutton"<<endl;}
    void BakeChickenWing(){cout<<"Bake ChickenWing"<<endl;}
};

/*抽象命令类：是执行具体操作的接口*/
class Command
{
public:
    Command(){}
    Command(Barbecuer *receiver):p_receiver(receiver){}
    virtual void ExecuteCommand() = 0; //执行命令
protected:
    Barbecuer *p_receiver;
};

/*具体命令类:烤羊肉串命令*/
class BakeMuttonCommand:public Command
{
public:
    BakeMuttonCommand(Barbecuer *receiver){p_receiver = receiver;}
    void ExecuteCommand() {p_receiver->BakeMutton();}
};

/*具体命令类:烤鸡翅串命令*/
class BakeChickenWingCommand:public Command
{
public:
    BakeChickenWingCommand(Barbecuer *receiver){p_receiver = receiver;}
    void ExecuteCommand() {p_receiver->BakeChickenWing();}
};

/*服务员类*/
class Waiter
{
public:
    void SetOrder(Command *command);
    void Notify();
private:
    vector<Command *>p_commandList; //这里相当于一个命令对象队列
};

void Waiter::SetOrder(Command *command)
{
    p_commandList.push_back(command);
    cout << "增加烤肉命令" << endl;
}

void Waiter::Notify()
{
    vector<Command*>::iterator i;
    for(i = p_commandList.begin(); i != p_commandList.end(); ++ i)
        (*i)->ExecuteCommand();
}

int main(int argc, char *argv[])  
{  
    //生成烤肉师傅、服务员、订单对象
    Barbecuer *p_cook = new Barbecuer();
    Command *p_mutton = new BakeMuttonCommand(p_cook);
    Command *p_chickenwing = new BakeChickenWingCommand(p_cook);
    Waiter *p_waiter = new Waiter();

    //将订单对象推送到命令队列
    p_waiter->SetOrder(p_mutton);
    p_waiter->SetOrder(p_chickenwing);

    //服务员通知烤肉师傅具体订单
    p_waiter->Notify();

    SAFE_DELETE(p_cook);
    SAFE_DELETE(p_mutton);
    SAFE_DELETE(p_chickenwing);
    SAFE_DELETE(p_waiter);

    return 0;  
}