1. 命令模式(Command Pattern)的定义
(1)定义
将一个请求封装为一个对象,从而使你可用不同的请求对客户进行参数化;对请求排队或记录请求日志,以及支持可撤销的操作。
①封装请求:抽象出需要执行的动作,封装成对象(有统一的接口)。
②参数化:可以用不同的命令对象,去参数化配置客户的请求。(即,将命令对象作为参数去供Invoker调用)。
(2)命令模式的结构和说明
①Command:定义命令的接口,声明执行的方法
②ConcreteCommand:命令接口实现对象,是“虚”的实现,通常会持有接收者并调用接收者的功能来完成命令要执行的操作
③Receiver:接收者,真正执行命令的对象。任何类都可能成为一个接收者,只要它能够实现命令要求实现的相应功能。
④Invoker:要求命令对象执行请求,通常会持有命令对象,可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方,也就是说相当于使用命令对象的入口。
⑤Client:创建具体的命令对象,并且设置命令对象的接收者。注意,这个不是我们常规意义上的客户端,而是在组装命令对象和接收者。或许,把这个Client称为装配者会更好,因为真正使用命令的客户端是从Invoker来触发执行。
【编程实验】打飞机游戏
//行为型模式:命令模式
//场景:打飞机游戏
//角色控制器(如玩家)的主要操作:用导弹攻击、炸弹攻击来打飞机以及4个方向移动
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//***********************************************抽象命令接口***********************************
//Command
class FighterCommand
{
public:
virtual void execute() = 0;
};
//*************************************************接收者**************************************
//Receiver
class Fighter
{
public:
void missile()
{
cout << "用导弹攻击!" << endl;
}
void bomb()
{
cout << "用炸弹攻击!" << endl;
}
void move (int direction)
{
switch(direction)
{
case 1:
cout << "向上移动!" << endl;
break;
case 2:
cout << "向下移动!" <<endl;
break;
case 3:
cout << "向左移动!" << endl;
break;
case 4:
cout << "向右移动!" <<endl;
break;
default:
cout << "不移动!" << endl;
}
}
};
//*************************************ConcreteCommand***************************************
//导弹攻击命令
class MissileCommand : public FighterCommand
{
private:
Fighter* fighter;
public:
MissileCommand(Fighter* fighter)
{
this->fighter = fighter;
}
void execute()
{
fighter->missile();
}
};
//炸弹攻击命令
class BombCommand : public FighterCommand
{
private:
Fighter* fighter;
public:
BombCommand(Fighter* fighter)
{
this->fighter = fighter;
}
void execute()
{
fighter->bomb();
}
};
//移动命令
class MoveCommand : public FighterCommand
{
private:
Fighter* fighter;
int direction;
public:
MoveCommand(Fighter* fighter, int direction)
{
this->fighter = fighter;
this->direction = direction;
}
void execute()
{
fighter->move(direction);
}
};
//***********************************************Invoker***********************************
//请求者
class Controller
{
private:
FighterCommand* cmdMissible;
FighterCommand* cmdBomb;
FighterCommand* cmdMoveLeft;
FighterCommand* cmdMoveRight;
public:
Controller(FighterCommand* missible, FighterCommand* bomb,
FighterCommand* left, FighterCommand* right)
{
cmdMissible = missible;
cmdBomb = bomb;
cmdMoveLeft = left;
cmdMoveRight = right;
}
void missible()
{
cmdMissible->execute();
}
void bomb()
{
cmdBomb->execute();
}
void moveLeft()
{
cmdMoveLeft->execute();
}
void moveRight()
{
cmdMoveRight->execute();
}
};
int main()
{
Fighter fighter; //战士(命令接收者)
//命令对象
FighterCommand* cmdMissible = new MissileCommand(&fighter);
FighterCommand* cmdBomb = new BombCommand(&fighter);
FighterCommand* cmdMoveLeft = new MoveCommand(&fighter, 3);
FighterCommand* cmdMoveRight = new MoveCommand(&fighter, 4);
//玩家(命令发出者)
//参数化:将命令对象作为参数传入Invoker
Controller player(cmdMissible, cmdBomb, cmdMoveLeft, cmdMoveRight);
player.bomb();
player.missible();
player.moveLeft();
player.moveRight();
//为什么不直接fighter.bomb()之类的呢?
//有时当发出命令后,我们只关心任务是否完成?但任务具体由哪个Fighter执行
//并不是我们关心的.如果直接调用,意味着命令的发出者直接叫某个具体的Fighter去做
//这样两者的耦合太紧.利用命令模式可以将两者解耦。
return 0;
}
(3)思考命令模式
①命令模式的本质:封装请求。这是也命令模式的关键。把请求封装成对象,也就是命令对象,并定义了统一的执行操作的接口。这个命令对象可以被存储、转发、记录、处理、撤销等。整个命令模式都是围绕这个对象进行的。
②命令模式的动机:在软件构建过程中,“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。但在某些场合——比如需要对行为进行“记录、撤销/重做”、事务”等处理,这种无法抵御变化的紧耦合是不合适的,命令模式的动机就是将一组行为抽象为对象,可以实现二者之间的构耦合。
③命令模式的组装和调用
命令的组装者:用它维护命令的“虚”实现和真实实现之间的关系。(即下图中的Client,但将之定义成组装者更合适。真正的Client是通过Invoker来触发命令的)
④命令的接收者:可以是任意的类,对它没有特殊要求。一个接收者可以处理多个命令,接收者提供的方法个数、名称、功能和命令对象中的可以不一样,只要能够通过调用接收者的方法来实现命令对应的功能就可以了。
⑤智能命令:在标准的命令模式中,命令的实现类是没有真正实现命令要求的功能的,真正执行命令的功能的是接收者。如果命令对象自己实现了命令要求的功能,而不再需要调用接收者,那这种情况称为智能命令。也有半智能的命令,即命令对象实现一部分,其他的还是需要调用接收者来完成,也就是说命令的功能由命令对象和接收者共同来完成。
【编程实验】菜单项命令
//行为型模式:命令模式
//场景:菜单项命令
/*
要求:某软件公司欲开发一个基于Windows平台的公告板系统。系统提供一个主菜单(Menu),
在主菜单中包含了一些菜单项(MenuItem),可以通过Menu类的addMenuItem()方法增加
菜单项。菜单项的主要方法是click(),每一个菜单项包含一个抽象命令类,具体命令
类包括OpenCommand(打开命令),CreateCommand(新建命令),EditCommand(编辑命令)
等,命令类具有一个execute()方法,用于调用公告板系统界面类(Board)的open()、
create()、edit()等方法。试使用命令模式设计该系统,使得MenuItem类与Board类
的耦合度降低,绘制类图并编程模拟实现。
*/
#include <iostream>
#include <string>
#include <map>
using namespace std;
//******************************Receiver********************
//Board(公告板)
class Board
{
public:
void open()
{
cout <<"Board opened!" << endl;
}
void create()
{
cout << "Board create!" << endl;
}
void edit()
{
cout << "Board edit!" << endl;
}
};
//****************************Command************************
//Command命令接口
class Command
{
public:
virtual void execute() = 0;
};
//CreateCommand(“新建”)
class CreateCommand : public Command
{
private:
Board* board;
public:
CreateCommand(Board* board)
{
this->board = board;
}
void execute()
{
board->create();
}
};
//OpenCommand(“打开”)
class OpenCommand : public Command
{
private:
Board* board;
public:
OpenCommand(Board* board)
{
this->board = board;
}
void execute()
{
board->open();
}
};
//EditCommand(“编辑”)
class EditCommand : public Command
{
private:
Board* board;
public:
EditCommand(Board* board)
{
this->board = board;
}
void execute()
{
board->edit();
}
};
//*****************************Invoker****************************
//MenuItem(菜单项)
class MenuItem
{
private:
string itemName;
Command* command;
public:
MenuItem(string name,Command* command)
{
this->command = command;
this->itemName = name;
}
//单击事件
void click()
{
//因菜单项(命令发送者)与具体的消息接收者(如board)的解耦
//因此,对于不同的菜单项,这里都可以像如下那样处理。(简洁、灵活!)
command->execute();
}
string& getItemName()
{
return itemName;
}
void setItemName(string name)
{
this->itemName = name;
}
Command* getCommand()
{
return command;
}
void setCommand(Command* newCommand)
{
this->command = newCommand;
}
};
//Menu(菜单)
class Menu
{
private:
map<string,MenuItem*> items;
public:
void addMenuItem(MenuItem* item)
{
items[item->getItemName()] = item;
}
MenuItem* getMenuItemByName(string name)
{
return items[name];
}
};
int main()
{
//创建公告板(命令接收者)
Board board;
//创建3个命令对象并与board组装起来
CreateCommand createCmd(&board);
OpenCommand openCmd(&board);
EditCommand editCmd(&board);
//创建主菜单及菜单项
Menu menu;
MenuItem* open = new MenuItem("open",&openCmd);
MenuItem* create = new MenuItem("create", &createCmd);
MenuItem* edit = new MenuItem("edit", &editCmd);
menu.addMenuItem(open);
menu.addMenuItem(create);
menu.addMenuItem(edit);
//测试
//单击“创建公告板”菜单项
menu.getMenuItemByName("create")->click();
//单击“打开公告板”菜单项
menu.getMenuItemByName("open")->click();
//单击“编辑公告板”菜单项
menu.getMenuItemByName("edit")->click();
delete open;
delete create;
delete edit;
return 0;
}
2. 深度理解命令模式
(1)参数化配置:用不同的命令对象,去参数化配置客户的请求。
(2)可撤销的操作:
①补偿式(反操作式):如被撤销的操作是加的功能,那么反操作就是减的功能。
②存储恢复式:把操作前的状态记录下来,然后要撤销操作时就直接恢复回去就可以了。(该种方式会放到备忘录模式中进行讲解)
【编程实验】可撤销/恢复操作的计算器
//行为型模式:命令模式
//场景:计算器(可撤销的计算)
#include <iostream>
#include <string>
#include <list>
using namespace std;
//***************************************Receiver*******************
//操作运算的接口
class OperationApi
{
public:
//获取计算完成后的结果
virtual int getResult() = 0;
//设计开始计算的初始值
virtual void setResult(int result) = 0;
//加法
virtual void add(int num)=0;
//减法
virtual void substract(int num) = 0;
};
//运算类,真正实现加减法运算(具体的接收者)
class Operation : public OperationApi
{
private:
int result;
public:
int getResult()
{
return result;
}
void setResult(int result)
{
this->result = result;
}
void add(int num)
{
result +=num;
}
void substract(int num)
{
result -= num;
}
};
//*************************Command***********************
//命令接口,支持可撤销操作
class Command
{
public:
//执行命令的操作
virtual void execute() = 0;
//执行撤销的操作
virtual void undo() = 0;
};
//具体的加法命令
class AddCommand : public Command
{
private:
//持有具体执行计算的对象(命令的接收者)
OperationApi* operation;
//要加上的数据
int opeNum;
public:
AddCommand(OperationApi* operation, int opeNum)
{
this->opeNum = opeNum;
this->operation = operation;
}
void execute()
{
operation->add(opeNum);
}
void undo()
{
operation->substract(opeNum);
}
};
//具体的减法命令
class SubstractCommand : public Command
{
private:
//持有具体执行计算的对象(命令的接收者)
OperationApi* operation;
//要减去的数据
int opeNum;
public:
SubstractCommand(OperationApi* operation, int opeNum)
{
this->opeNum = opeNum;
this->operation = operation;
}
void execute()
{
operation->substract(opeNum);
}
void undo()
{
operation->add(opeNum);
}
};
//*****************************Invoker************************************
//计算器类,计算器上有加法按钮和减法按钮
class Calculator
{
private:
Command* addCmd; //加法命令对象
Command* substractCmd; //减法命令对象
//命令的操作历史记录,在撤销的时候用
list<Command*> undoCmds;
//命令被撤销的历史记录,在恢复时使用
list<Command*> redoCmds;
public:
void setAddCmd(Command* addCmd)
{
this->addCmd = addCmd;
}
void setSubstractCmd(Command* subCmd)
{
this ->substractCmd = subCmd;
}
//提供给客户使用,执行加法功能
void addPressed()
{
addCmd->execute();
//把操作记录到历史记录里面
undoCmds.push_back(addCmd);
}
//提供给客户使用,执行减法功能
void substractPressed()
{
substractCmd->execute();
//把操作记录到历史记录里面
undoCmds.push_back(substractCmd);
}
void undoPressed()
{
if(undoCmds.size() > 0)
{
//取出最后一个命令来撤销
Command* cmd = undoCmds.back();
cmd->undo();
//如果还有恢复功能,那就把这个命令记录到恢复历史列表中
redoCmds.push_back(cmd);
//然后把最后一个命令删除掉
undoCmds.pop_back();
}
else
{
cout << "Sorry, nothing to undo()" << endl;
}
}
void redoPressed()
{
if(redoCmds.size() > 0)
{
//取出最后一个命令来重做
Command* cmd = redoCmds.back();
cmd->execute();
//把这个命令记录到可撤销的历史记录里面
undoCmds.push_back(cmd);
//然后把最后一个命令删除掉
redoCmds.pop_back();
}
else
{
cout << "Sorry, nothing to redo()" << endl;
}
}
};
int main()
{
//客户端
//1.组装命令和接收者
//创建接收者
OperationApi* operation = new Operation();
//创建命令对象,并组装命令和接收者
AddCommand addCmd(operation, 5);
SubstractCommand subCmd(operation, 3);
//2.把命令设置到持有者,也就是计算器里面
Calculator calculator;
calculator.setAddCmd(&addCmd);
calculator.setSubstractCmd(&subCmd);
//3. 模拟按下按钮,测试一下
calculator.addPressed();
cout << "一次加法运算后的结果为:" << operation->getResult() << endl;
calculator.substractPressed();
cout << "一次减法运算后的结果为:" << operation->getResult() << endl;
//测试撤销
calculator.undoPressed();
cout << "撤销一次后的结果为:" << operation->getResult() << endl;
calculator.undoPressed();
cout << "再次撤销一次后的结果为:" << operation->getResult() << endl;
//测试恢复
calculator.redoPressed();
cout << "恢复操作一次后的结果为:" << operation->getResult() << endl;
calculator.redoPressed();
cout << "再次恢复操作一次后的结果为:" << operation->getResult() << endl;
return 0;
}
(3)宏命令
①宏命令(Macro Command)又称为组合命令,它是组合模式和命令模式联用的产物。宏命令是一个具体命令类,它拥有一个集合属性,在该集合中包含了对其他命令对象的引用。
②通常宏命令不直接与请求接收者交互,而是通过它的成员来调用接收者的方法。当调用宏命令的execute()方法时,将递归调用它所包含的每个成员命令的execute()方法,一个宏命令的成员可以是简单命令,还可以继续是宏命令。
③执行一个宏命令将触发多个具体命令的执行,从而实现对命令的批处理
【编程实验】餐馆点菜
//行为型模式:命令模式
//场景:餐馆点菜
//角色:
//1.接收者:厨师,是命令的真正执行者。本例分为两种:做热菜的厨师和做凉菜的厨师
//2.服务员:负责命令和接收者的组装,并持有命令对象(菜单)
// 最后启动命令的也是服务员
//3.命令对象:A、每一道菜是个命令对象;B、菜单(组合对象,由多道菜组成)
#include <iostream>
#include <string>
#include <list>
#include <typeinfo>
using namespace std;
//***************************************Receiver*******************
//接收者:两种:做热菜的厨师和做凉菜的厨师
//厨师的接口
class CookApi
{
public:
//做菜的方法
//参数:菜名
virtual void cook(string name) = 0;
};
//做热菜的厨师
class HotCook : public CookApi
{
public:
void cook(string name)
{
cout << "本厨师正在做: " << name <<"(热菜)" << endl;
}
};
//做凉菜的厨师
class CoolCook : public CookApi
{
public:
void cook(string name)
{
cout << "凉菜" << name << "己经做好了,本厨师正在装盘。" << endl;
}
};
//************************************Command**************************
//命令接口,声明执行的操作
class Command
{
public:
virtual void execute() = 0;
};
//具体的命令对象(三道菜):
//两道热菜:北京烤鸭、绿豆排骨煲
//一道凉菜:蒜泥白肉
//1.命令对象:北京烤鸭
class DuckCommand: public Command
{
private:
//持有具体做菜的厨师的对象
CookApi* cookApi;
public:
void setCookApi(CookApi* cookApi)
{
this->cookApi = cookApi;
}
void execute()
{
cookApi->cook("北京烤鸭");
}
};
//2. 命令对象:绿豆排骨煲
class ChopCommand: public Command
{
private:
//持有具体做菜的厨师的对象
CookApi* cookApi;
public:
void setCookApi(CookApi* cookApi)
{
this->cookApi = cookApi;
}
void execute()
{
cookApi->cook("绿豆排骨煲");
}
};
//3.命令对象:蒜泥白肉
class PorkCommand: public Command
{
private:
//持有具体做菜的厨师的对象
CookApi* cookApi;
public:
void setCookApi(CookApi* cookApi)
{
this->cookApi = cookApi;
}
void execute()
{
cookApi->cook("蒜泥白肉");
}
};
//4. 菜单对象,是个宏命令对象
//A、本质上还是一个命令,要继承自Command
//B、与普通命令不同,宏命令是多个命令的组合
//C、执行宏命令相当于依次执行宏命令中包含的多个命令对象
class MenuCommand : public Command
{
private:
//用来记录组合本菜单的多道菜品,也就是多个命令对象
list<Command*> lstCmds;
public:
//点菜,把菜品加入到菜单中
//参数为客户点的菜
void addCommand(Command* cmd)
{
lstCmds.push_back(cmd);
}
//执行菜单,其实就是循环执行菜单里面的每个菜
void execute()
{
list<Command*>::iterator iter = lstCmds.begin();
while( iter != lstCmds.end())
{
(*iter)->execute();
++iter;
}
}
};
//**************************************Invoker + Client*******************
//服务员
class Waiter
{
private:
//持有一个宏命令对象(菜单)
MenuCommand menuCmd;
//
HotCook hotCook;
CoolCook coolCook;
public:
//客户点菜
//参数客户点的菜,每道菜是一个命令对象
void orderDish(Command* cmd)
{
//客户传过来的命令对象
//在这里进行组装
//判断到底是热菜还是凉菜
if(typeid(*cmd) == typeid(DuckCommand))
{
//交给热菜师傅
((DuckCommand*)cmd)->setCookApi(&hotCook);
}
else if(typeid(*cmd) == typeid(ChopCommand))
{
//交给热菜师傅
((ChopCommand*)cmd)->setCookApi(&hotCook);
}
else if(typeid(*cmd) == typeid(PorkCommand))
{
//交给凉菜师傅
((PorkCommand*)cmd)->setCookApi(&coolCook);
}
menuCmd.addCommand(cmd);
}
//客户点菜完毕,表示要执行命令了,这里就是执行菜单
//这个组合命令了
void orderOver()
{
menuCmd.execute();
}
};
int main()
{
//客户端
//客户只负责向服务员点菜就好了
//创建服务员
Waiter waiter;
//创建命令对象,就是要点的菜
Command* chop = new ChopCommand();
Command* duck = new DuckCommand();
Command* pork = new PorkCommand();
//点菜,就是服务员记录下来
waiter.orderDish(chop);
waiter.orderDish(duck);
waiter.orderDish(pork);
//点菜完毕
waiter.orderOver();
delete chop;
delete duck;
delete pork;
return 0;
}
/*输出结果:
本厨师正在做: 绿豆排骨煲(热菜)
本厨师正在做: 北京烤鸭(热菜)
凉菜蒜泥白肉己经做好了,本厨师正在装盘。
*/
(4)队列请求
//行为型模式:命令模式
//场景:餐馆点菜(队列)
//角色:
//1.接收者:厨师,是命令的真正执行者。
//2.服务员:负责命令和接收者的组装,并持有命令对象(菜单)
// 最后启动命令的也是服务员
//3.命令对象:A、每一道菜是个命令对象;B、菜单(组合对象,由多道菜组成)
// * 编译命令:
//* g++ main.cpp -std=c++11
#include <iostream>
#include <string>
#include <list>
#include <thread> //C++ 11
#include <mutex>
using namespace std;
//同步对象
static mutex g_mutex; //对队列进行同步
static mutex g_PrintMutex;//对控制台输出同步
class CookApi; //前向声明
//************************************Command**************************
//命令接口,声明执行的操作
class Command
{
public:
//执行命令对应的操作
virtual void execute() = 0;
//设置命令的接收者
virtual void setCookApi(CookApi* cooker) = 0;
//获取点菜的桌号
virtual int getTableNum() = 0;
};
//命令队列类
class CommandQueue
{
public:
//用来存储命令对象的队列
static list<Command*> cmds;
public:
//服务员传过来一个新的菜单,需要同步
//同时,会有很多服务员传入菜单,而同时又有很多厨师从这个
//队列中取值
static void addMenu(list<Command*>& menu)
{
g_mutex.lock();
list<Command*>::iterator iter = menu.begin();
while (iter != menu.end())
{
cmds.push_back((*iter));
++iter;
}
g_mutex.unlock();
}
//厨师从命令队列里面获取命令对象进行处理(需要同步)
static Command* getOneCommand()
{
Command* ret = NULL;
g_mutex.lock();
if (cmds.size() > 0)
{
//取出队列的第一个,因为是约定的按照加入的先后来处理
ret = cmds.front();
//同时从队列里面取掉这个命令对象
cmds.pop_front();
}
g_mutex.unlock();
return ret;
}
};
list<Command*> CommandQueue::cmds;
//***************************************Receiver*******************
//接收者:两种:做热菜的厨师和做凉菜的厨师
//厨师的接口
class CookApi
{
public:
//做菜的方法
//参数:tableName-点菜的桌名,name-菜名
virtual void cook(int tableNum, string name) = 0;
};
//做热菜的厨师
class HotCook : public CookApi
{
private:
string name; //厨师的名字
public:
HotCook(string name)
{
this->name = name;
}
void cook(int tableNum, string name)
{
g_PrintMutex.lock();
cout << this->name << "厨师正在为" <<tableNum
<<"号桌做:"<< name << endl;
int cookTime = rand() % 5;
this_thread::sleep_for(chrono::seconds(cookTime));
cout << this->name << "厨师为"<< tableNum << "号桌做好了:"
<< name << ",共计耗时=" << cookTime << "秒" <<endl;
g_PrintMutex.unlock();
}
void startWork()
{
while (true)
{
//不断从命令队列里面获取命令对象
Command* cmd = CommandQueue::getOneCommand();
if (cmd != NULL)
{
//说明取到命令对象了,这个命令对象还没有设置接收者
//因为前面都还不知道到底哪一个厨师来真正执行这个命令
//现在知道了,就是当前厨师实例,设置到命令对象里面
cmd->setCookApi(this);
//然后真正执行这个命令
cmd->execute();
}
//体息一下
this_thread::sleep_for(chrono::milliseconds(1000));
}
}
};
//****************************************具体命令对象*******************************************************
//具体的命令对象(三道菜):北京烤鸭、绿豆排骨煲、蒜泥白肉
//1.命令对象:北京烤鸭
class DuckCommand: public Command
{
private:
//持有具体做菜的厨师的对象
CookApi* cookApi;
//点菜的桌号
int tableNum;
public:
DuckCommand(int tableNum)
{
this -> tableNum = tableNum;
}
void setCookApi(CookApi* cookApi)
{
this->cookApi = cookApi;
}
int getTableNum(){return tableNum;}
void execute()
{
cookApi->cook(tableNum, "北京烤鸭");
}
};
//2. 命令对象:绿豆排骨煲
class ChopCommand: public Command
{
private:
//持有具体做菜的厨师的对象
CookApi* cookApi;
//点菜的桌号
int tableNum;
public:
ChopCommand(int tableNum)
{
this -> tableNum = tableNum;
}
void setCookApi(CookApi* cookApi)
{
this->cookApi = cookApi;
}
int getTableNum(){return tableNum;}
void execute()
{
cookApi->cook(tableNum, "绿豆排骨煲");
}
};
//3.命令对象:蒜泥白肉
class PorkCommand: public Command
{
private:
//持有具体做菜的厨师的对象
CookApi* cookApi;
//点菜的桌号
int tableNum;
public:
PorkCommand(int tableNum)
{
this -> tableNum = tableNum;
}
void setCookApi(CookApi* cookApi)
{
this->cookApi = cookApi;
}
int getTableNum(){return tableNum;}
void execute()
{
cookApi->cook(tableNum, "蒜泥白肉");
}
};
//4. 菜单对象,是个宏命令对象
//A、本质上还是一个命令,要继承自Command
//B、与普通命令不同,宏命令是多个命令的组合
//C、执行宏命令相当于依次执行宏命令中包含的多个命令对象
class MenuCommand : public Command
{
private:
//用来记录组合本菜单的多道菜品,也就是多个命令对象
list<Command*> lstCmds;
public:
//点菜,把菜品加入到菜单中
//参数为客户点的菜
void addCommand(Command* cmd)
{
lstCmds.push_back(cmd);
}
void setCookApi(CookApi* cooker)
{
//什么都不做,这个方法对组合命令对象的菜单没有意义
}
int getTableNum()
{
//什么都不做,这个方法对组合命令对象的菜单没有意义
return 0;
}
//执行菜单
void execute()
{
//这里与之前的例子不同,把菜单传给队列
CommandQueue::addMenu(lstCmds);
}
list<Command*>& getCommands()
{
return lstCmds;
}
};
//**************************************Invoker + Client*******************
//服务员
class Waiter
{
private:
//持有一个宏命令对象(菜单)
MenuCommand menuCmd;
public:
//客户点菜
//参数客户点的菜,每道菜是一个命令对象
void orderDish(Command* cmd)
{
menuCmd.addCommand(cmd);
}
//客户点菜完毕,表示要执行命令了,这里就是执行菜单
//这个组合命令了
void orderOver()
{
menuCmd.execute();
}
};
//线程函数
void thread_entry(HotCook* cooker)
{
cooker->startWork();
}
//客户端
int main()
{
srand( time(NULL) );
//创建三位厨师
HotCook cook1("张三");
HotCook cook2("李四");
HotCook cook3("王五");
//启动3个工作线程
thread t1(thread_entry,&cook1);
thread t2(thread_entry,&cook2);
thread t3(thread_entry,&cook3);
//为了简单,直接用循环模拟多个桌号点菜
//创建服务员
for(int i = 0; i < 5; i++)
{
Waiter* waiter = new Waiter();
//创建命令对象,就是要点的菜
Command* chop = new ChopCommand(i);
Command* duck = new DuckCommand(i);
Command* pork = new PorkCommand(i);
//点菜,就是服务员记录下来
waiter->orderDish(chop);
waiter->orderDish(duck);
waiter->orderDish(pork);
//点菜完毕
waiter->orderOver();
}
//为简化,这里省略了对Waiter、Commands对象的释放。。。
t1.join();
t2.join();
t3.join();
return 0;
}
(5)日志请求
①概念:把请求的历史记录保存下来,一般采用永久存储方式。如果在运行请求中,系统崩溃了,那么当再次运行时,就可以从保存的历史记录中获取日志请求,并重新执行命令。
②实现方法:在命令对象中添加上存储和装载的方法,其实就是让命令对象自己实现类似序列化的功能。
3. 命令模式的优缺点
(1)优点:
①更松散的耦合:命令的发起者和具体实现命令的对象(接收者完全解耦)。也就是说发送者完全不知道具体实现对象是谁。
②更动态的控制:把请求封装起来,可以动态地对它进行参数化、队列化和日志化。
③很自然的复合命令:命令模式能够很容易地组合成复合命令,也就是宏命令,从而使系统操作更简单,功能更强大。
④更好的扩展性:扩展命令很容易,只需要实现新的命令对象,然后装配就可以使用,己有的实现完全不用变化。
(2)缺点: 如果有N个命令,则Command的子类就需要N个,这会造成子类的膨胀。
4. 应用场景
(1)需要抽象出执行的动作,并参数化这些对象时可选用命令模式
(2)需要不同的时刻指定、排列和执行请求,可将请求封装成为命令对象,然后实现将请求队列化。
(3)需要支持取消操作,可通过管理命令对象,能很容易实现命令的恢复和重做功能。
(4)在需要事务的系统中,可选用命令模式,它提供了对事务进行建模的方法。
5. 相关模式
(1)命令模式和组合模式
命令模式中,宏命令可使用组合模式.(但注意,之前的例子没有使用组合模式)
(2)命令模式与备忘录模式
①命令模式中,实现可撤销功能时,有两种实现方法,其中一种是保存命令执行前的状态,撤销时把状态恢复。也可以考虑使用备忘录模式
②如果状态存储在命令对象中,也可以使用原型模式,把命令对象当作原型来克隆一个新的对象,然后将克隆出来的对象通过备忘录模式存放。