一.需求
小王开了一家奶茶店，店里只有小王和他老婆两个人，俩人既负责接单，又负责制作奶茶。
每当有顾客到来，小王或者他老婆都会热心的问：欢迎光临，请问喝点什么？这个时候，老顾客早已经想好了自己喜欢喝的，直接就说了需要哪款奶茶，大杯还是小杯，加不加冰等等；但是很多新顾客第一次来，并不太知道店里都有哪些奶茶，往往要犹豫比较一番，这样一来，经常就会出现顾客排队的情况，后面的老顾客等的很着急，前面的新顾客还在不停的询问和观望。
新店开了两天，聪明的小王已经发现了这个问题，经常排队既影响销量，又影响客户的体验，必须尽快解决才好。
二.初步尝试
小王想到的最简单，最直接的办法就是加人，服务员多了，自然能接待更多的顾客，卖出更多的奶茶，于是，小王又招了两名员工做奶茶。现在店里一共有4个人，四个人站成一排接待顾客，每个人都负责询问客户的需求，制作奶茶，以及收银。
果然人多还是力量大，4个人的确比2个人效率提高了不少。我们来看一下目前小王店里的经营模式：
可以看出，从原来的2个人到现在的4个人，店里的经营模式其实并没有发生本质的变化，只是扩容了而已，就好比运行一个服务的服务器原来有2台，上线后发现压力大，又增加了2台。当然这种方式确实能够快速解决问题。但缺点也是显而易见的：成本急剧增长。
果然，月底核算本月营收的时候，小王就发现了虽然卖出的奶茶不少，但是刨去房租、员工工资、原材料等成本，利润却少的可怜。
三.更好的方案
小王去了一些更大的奶茶店去参观，也去了麦当劳、肯德基这些更大的快餐连锁店学习他们的经营模式。
经过一番认真观察，小王发现了这些店都有一个共同的模式：少量的员工负责接受订单，其他更多的员工负责全力制作餐饮，接单员只需要把订单给后厨，并不需要跟他们交流，因为客户的所有需求都已经非常清楚的写在订单上了，这样一来，更多的员工可以集中精力制作奶茶，效率大大提高。
小王回去后立刻改进了经营模式：裁撤一名员工，只保留3人，自己负责处理客户订单以及收银，每当打好一张订单，就交给老婆以及另一名奶茶妹制作奶茶。
这样一来，就最大限度的利用了时间，充分的并行：订单处理通常很快，所以一个人就够了，制作奶茶更耗时，所以多个人同时进行。更重要的是，进行了职责分离，且无需沟通：小王只负责接单和收银，老婆和奶茶妹只负责做奶茶，减少沟通就意味着节约时间，提升效率。
再来看看改进后的经营模式：
代码实现如下：
// 奶茶订单
class MilkTeaOrder implements Runnable{
private String teaName; // 奶茶名称
private String describe; // 奶茶描述
private String no; // 订单编号，此处使用下单时间戳+4位随机数
private MilkTeaSister milkTeaSister; // 订单由哪一位奶茶妹处理
public MilkTeaOrder(String teaName, String describe, String no, MilkTeaSister milkTeaSister) {
this.teaName = teaName;
this.describe = describe;
this.no = no;
this.milkTeaSister = milkTeaSister;
}
@Override
public void run() {
milkTeaSister.makeMilkTea(no, teaName, describe);
}
public String getTeaName() {
return teaName;
}
public void setTeaName(String teaName) {
this.teaName = teaName;
}
public String getDescribe() {
return describe;
}
public void setDescribe(String describe) {
this.describe = describe;
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
public MilkTeaSister getMilkTeaSister() {
return milkTeaSister;
}
public void setMilkTeaSister(MilkTeaSister milkTeaSister) {
this.milkTeaSister = milkTeaSister;
}
}
// 服务员，负责接收订单，收银
class Waiter {
public MilkTeaOrder takeOrder(String name, String describe, MilkTeaSister milkTeaSister) {
MilkTeaOrder order = new MilkTeaOrder(name, describe, getOrderNo(), milkTeaSister);
System.out.println("收到订单" + order.getNo() + ":" + name + "," + describe);
return order;
}
public void charge(MilkTeaOrder order) {
System.out.println("订单" + order.getNo() + "收银");
}
private String getOrderNo() {
long time = System.currentTimeMillis();
int random = new Random().nextInt(9000) + 1000;
return time +"" + random;
}
}
// 奶茶妹，负责制作奶茶
class MilkTeaSister {
private int no; // 奶茶妹编号
public MilkTeaSister(int no) {
this.no = no;
}
public void makeMilkTea(String orderNo, String teaName, String describe) {
System.out.println(no + " 号奶茶妹完成订单" + orderNo + ":"
+ teaName + "," + describe);
}
}
public class MilkTeaShop {
public static void main(String[] args) {
Waiter waiter = new Waiter();
MilkTeaSister milkTeaSister1 = new MilkTeaSister(1);
MilkTeaSister milkTeaSister2 = new MilkTeaSister(2);
ExecutorService milkTeaProductLines = Executors.newFixedThreadPool(2);
MilkTeaOrder order1 = waiter.takeOrder("珍珠奶茶", "大杯，加冰", milkTeaSister1);
waiter.charge(order1);
milkTeaProductLines.execute(order1);
MilkTeaOrder order2 = waiter.takeOrder("布丁奶茶", "小杯，不加冰", milkTeaSister2);
waiter.charge(order2);
milkTeaProductLines.execute(order2);
MilkTeaOrder order3 = waiter.takeOrder("经典奶茶", "大杯，加冰", milkTeaSister1);
waiter.charge(order3);
milkTeaProductLines.execute(order3);
MilkTeaOrder order4 = waiter.takeOrder("芒果奶茶", "小杯，不加冰", milkTeaSister2);
waiter.charge(order4);
milkTeaProductLines.execute(order4);
}
}
运行程序：
收到订单15007930962538856:珍珠奶茶,大杯，加冰
订单15007930962538856收银
收到订单15007930962573813:布丁奶茶,小杯，不加冰
订单15007930962573813收银
收到订单15007930962586470:经典奶茶,大杯，加冰
订单15007930962586470收银
收到订单15007930962587787:芒果奶茶,小杯，不加冰
订单15007930962587787收银
1 号奶茶妹完成订单15007930962538856:珍珠奶茶,大杯，加冰
1 号奶茶妹完成订单15007930962586470:经典奶茶,大杯，加冰
2 号奶茶妹完成订单15007930962587787:芒果奶茶,小杯，不加冰
2 号奶茶妹完成订单15007930962573813:布丁奶茶,小杯，不加冰
在上面的代码中，我们运用了java的线程池，并固定为2个线程执行，每个订单放在一个线程中去执行，如果订单多于两个，则会排队等待，前面的订单处理完后就会自动处理后续排队的订单。
四.模式总结
下面该隆重介绍我们今天的主角了——命令模式！
定义
命令模式将“请求”封装成对象，从而实现请求调用者和请求执行者的解耦。调用者无需了解执行细节，只需执行请求对象，即可实现请求的最终执行。
在我们上面的例子中，请求调用者就是接单员，请求执行者就是奶茶妹，客户和奶茶妹之前并没有之间的沟通，而是通过订单，订单就相当于是被封装起来的具体操作（包含了需要的奶茶以及说明）。我们将具体的奶茶需求与奶茶妹封装成订单，这样每个订单就是可以被独立执行的：哪个奶茶杯负责制作哪款奶茶。
使用场景
系统中的请求者和执行者需要解耦，不直接交互。
典型的使用场景比如：
遥控器：我们只需按下命令按钮，就可以实现具体的操作，不必关心背后的具体行为。
工作队列：将任务以及任务执行者封装成一个一个的任务，排成队列，依次执行。这样，任务可以在方便的时候被执行，调用者则可以不必一直等待。任务也可以被多线程执行。我们上面的方案中就是一个工作队列。
类图
命令模式主要包含3种角色：
调用者：需求方，需要完成某种具体的任务。含有命令的引用。
命令：封装了“请求”的对象，含有接收者的引用。
接收者：负责具体的任务执行。
可以看出，调用者和接收者之间是解耦的，他们通过Command对象来作为沟通桥梁。
优点
（1）降低系统耦合度
（2）满足开闭原则，新增命令，只需实现Command接口即可
缺点
可能会生成大量的具体命令类，增加维护成本。
参考资料
- 《Head First设计模式》
- Graphic Design Patterns
本文已迁移至博客：http://ipenge.com/27821.html
