元素
- 抽象命令/具体命令
- 抽象接受者/具体接受者
- 调用者
- 客户端
command_url.png
应用场景举例
这里我们用一个场景来描述：去川湘阁饭店点一份剁椒鱼头和宫保鸡丁。
这里我们把整个关键流程写出来
- 点菜下单
- 收银台出单
- 厨房收到抄菜单，分给具体厨师
- 厨师炒菜
接下来我们就可以抽象出具体的角色。客户端当然就是我们的用户，调用者就是收银台出单的妹纸，命令就是抄菜单，接受者就是厨师。这样就很清晰了，客户端（用户）不需要知道功能（炒菜）怎么实现或者谁实现，他只需要找调用者（服务员/前台）描述清楚，然后调用者发命令给接受者（厨师），然后接受者执行命令（炒菜）。 这个流程非常的清晰也不会出错。什么样的命令给什么样的接受者执行，比如：剁椒鱼头，就打剁椒鱼头的票，然后指定给会做剁椒鱼头的师傅做。宫保鸡丁就给会做宫保鸡丁的师傅做。这个过程中，命令（小票）包含接受者（师傅）的信息。不同的命令对应不同的接受者。所以这里建立命令和接受者的抽象。
优点
- 将请求的发起者和执行者接口，通过命令来实现，将客户端的调用参数化。只需要将每个动作封装正命令，由发起者命令执行者来执行
- 请求排队、记录每个请求。拿上面的场景来说，当很多客人点了剁椒鱼头时，厨师可能做不过来，这时候就得排队，先来的先做。
示例（C++版）：
接受者（厨师）抽象类
#include<iostream>
using namespace std;
class Chef
{
public:
virtual int cooking(int id)=0;
virtual void printTicketIds()const = 0;
virtual ~Chef() {}
};
具体接受者（川湘阁做剁椒鱼头的厨师）类
#include "Chef.h"
class FishChef :
public Chef
{
int id;
string name;
deque<int> ticketIds;
public:
FishChef(int id, string name);
int cooking(int id);
void printTicketIds()const;
~FishChef();
};
#include "FishChef.h"
FishChef::FishChef(int id, string name)
{
this->id = id;
this->name = name;
}
FishChef::~FishChef()
{
}
void FishChef::printTicketIds()const {
cout << "id为" << this->id << " 姓名为：" << this->name.c_str() << "的厨师需要做的菜";
for (deque<int>::const_iterator it = ticketIds.begin(); it != ticketIds.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int FishChef::cooking(int id) {
if (ticketIds.size() > 3) {
return 1;
}
ticketIds.push_back(id);
return 0;
}
抽象命令（炒菜单）
#include<iostream>
#include "Chef.h"
using namespace std;
class Order
{
protected :
Chef* chef;
public:
Order(Chef* chef) {
this->chef = chef;
}
virtual void make()=0;
~Order() {
if (chef != NULL)
delete chef;
}
};
具体命令（川湘阁的抄菜单）
#include "stdafx.h"
#include "ChuangXiangGeOrder.h"
ChuangXiangGeOrder::ChuangXiangGeOrder(Chef * chef, int id):Order(chef)
{
this->id = id;
}
void ChuangXiangGeOrder::make()
{
if (chef == NULL) {
cout << "请先设置厨师" << endl;
}
int res = chef->cooking(id);
}
ChuangXiangGeOrder::~ChuangXiangGeOrder()
{
}
抽象调用者（下单服务员）
#include<iostream>
#include<vector>
#include<string>
#include"Order.h"
using namespace std;
using namespace std;
class Waiter
{
protected:
Order* order;
public:
Waiter() {}
virtual pair<int,string> setOrder(Order* order)=0;
virtual void execute()=0;
~Waiter() {}
};
具体调用者（川湘阁的下单服务员）
#include "stdafx.h"
#include "ChuanXiangGeWaiter.h"
ChuanXiangGeWaiter::ChuanXiangGeWaiter()
{
}
pair<int, string> ChuanXiangGeWaiter::setOrder(Order* order)
{
Waiter::order = order;
return pair<int, string>();
}
void ChuanXiangGeWaiter::execute()
{
if (order == NULL) {
cout << "请先下单" << endl;
}
order->make();
}
ChuanXiangGeWaiter::~ChuanXiangGeWaiter()
{
}
测试代码
int main()
{
Chef *chef = new FishChef(1, "张厨师");
Order *order = new ChuangXiangGeOrder(chef,1001);
Waiter *waiter = new ChuanXiangGeWaiter();
waiter->setOrder(order);
waiter->execute();
chef->printTicketIds();
Order *order1 = new ChuangXiangGeOrder(chef, 1002);
waiter->setOrder(order1);
waiter->execute();
chef->printTicketIds();
Order *order2 = new ChuangXiangGeOrder(chef, 1003);
waiter->setOrder(order2);
waiter->execute();
chef->printTicketIds();
return 0;
}
结果：
command.png
java版
线程池
Executor就是抽象调用者
public interface Executor {
/**
* Executes the given command at some time in the future. The command
* may execute in a new thread, in a pooled thread, or in the calling
* thread, at the discretion of the {@code Executor} implementation.
*
* @param command the runnable task
* @throws RejectedExecutionException if this task cannot be
* accepted for execution
* @throws NullPointerException if command is null
*/
void execute(Runnable command);
}
我们看到其中一个实现类ThreadPoolExecutor
图片来自官方api文档
看到Executor的源码，我们看到参数的起名都是command。这里Runable就是抽象的命令。那接受者呢。其实这里的接受者也是Runable。同时ThreadPoolExecutor除了能够发起命令外，还可以对Runable进行排队。这里我们用一个例子说明
测试
public class TestMain {
public static void main(String[] args) {
new Thread(new TaskA(1)).start();
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(new TaskA(2));
executor.execute(new TaskA(3));
executor.execute(new TaskA(4));
}
static class TaskA implements Runnable {
private int id;
public TaskA(int id) {
this.id = id;
}
public void run() {
log(id+" TaskA begin");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log(id+" TaskA end");
}
}
public static void log(String content) {
System.out.println(content);
}
}
结果
1 TaskA begin
2 TaskA begin
3 TaskA begin
1 TaskA end
3 TaskA end
2 TaskA end
4 TaskA begin
4 TaskA end
