23种设计模式之命令模式2

3.4  宏命令

        什么是宏命令呢？简单点说就是包含多个命令的命令，是一个命令的组合。举个例子来说吧，设想一下你去饭店吃饭的过程：
        （1）你走进一家饭店，找到座位坐下
        （2）服务员走过来，递给你菜谱
        （3）你开始点菜，服务员开始记录菜单，菜单是三联的，点菜完毕，服务员就会把菜单分成三份，一份给后厨，一份给收银台，一份保留备查。
        （4）点完菜，你坐在座位上等候，后厨会按照菜单做菜
        （5）每做好一份菜，就会由服务员送到你桌子上
        （6）然后你就可以大快朵颐了
        事实上，到饭店点餐是一个很典型的命令模式应用，作为客户的你，只需要发出命令，就是要吃什么菜，每道菜就相当于一个命令对象，服务员会在菜单上记录你点的菜，然后把菜单传递给后厨，后厨拿到菜单，会按照菜单进行饭菜制作，后厨就相当于接收者，是命令的真正执行者，厨师才知道每道菜具体怎么实现。
        在这个过程中，地位比较特殊的是服务员，在不考虑更复杂的管理，比如后厨管理的时候，负责命令和接收者的组装的就是服务员。比如你点了凉菜、热菜，你其实是不知道到底凉菜由谁来完成，热菜由谁来完成的，因此你只管发命令，而组装的工作就由服务员完成了，服务员知道凉菜送到凉菜部，那是已经做好的了，热菜才送到后厨，需要厨师现做，看起来服务员是一个组装者。
        同时呢，服务员还持有命令对象，也就是菜单，最后启动命令执行的也是服务员。因此，服务员就相当于标准命令模式中的Client和Invoker的融合。
        画个图来描述上述对应关系，如图6所示：

                                                   图6  点菜行为与命令模式对应示意图
1：宏命令在哪里？
        仔细观察上面的过程，再想想前面的命令模式的实现，看出点什么没有？
        前面实现的命令模式，都是客户端发出一个命令，然后马上就执行了这个命令，但是在上面的描述里面呢？是点一个菜，服务员就告诉厨师，然后厨师就开始做吗？很明显不是的，服务员会一直等，等到你点完菜，当你说“点完了”的时候，服务员才会启动命令的执行，请注意，这个时候执行的就不是一个命令了，而是执行一堆命令。
        描述这一堆命令的就是菜单，如果把菜单也抽象成为一个命令，就相当于一个大的命令，当客户说“点完了”的时候，就相当于触发这个大的命令，意思就是执行菜单这个命令就可以了，这个菜单命令包含多个命令对象，一个命令对象就相当于一道菜。
        那么这个菜单就相当于我们说的宏命令。
2：如何实现宏命令
        宏命令从本质上讲类似于一个命令，基本上把它当命令对象进行处理。但是它跟普通的命令对象又有些不一样，就是宏命令包含有多个普通的命令对象，执行一个宏命令，简单点说，就是执行宏命令里面所包含的所有命令对象，有点打包执行的意味。
（1）先来定义接收者，就是厨师的接口和实现，先看接口，示例代码如下：

/**
 * 厨师的接口
 */
public interface CookApi {
    /**
     * 示意，做菜的方法
     * @param name 菜名
     */
    public void cook(String name);
}

 

厨师又分成两类，一类是做热菜的师傅，一类是做凉菜的师傅，先看看做热菜的厨师的实现示意，示例代码如下：

/**
 * 厨师对象，做热菜
 */
public class HotCook implements CookApi{
    public void cook(String name) {
        System.out.println("本厨师正在做："+name);
    }
}

 

做凉菜的师傅，示例代码如下：

/**
 * 厨师对象，做凉菜
 */
public class CoolCook implements CookApi {
    public void cook(String name) {
        System.out.println("凉菜"+name+"已经做好，本厨师正在装盘。" );
    }
}

 

（2）接下来，来定义命令接口，跟以前一样，示例代码如下：

/**
 * 命令接口，声明执行的操作
 */
public interface Command {
    /**
     * 执行命令对应的操作
     */
    public void execute();
}

 

（3）定义好了命令的接口，该来具体实现命令了。
        实现方式跟以前一样，持有接收者，当执行命令的时候，转调接收者，让接收者去真正实现功能，这里的接收者就是厨师。 
        这里实现命令的时候，跟标准的命令模式的命令实现有一点不同，标准的命令模式的命令实现的时候，是通过构造方法传入接收者对象，这里改成了使用setter的方式来设置接收者对象，也就是说可以动态的切换接收者对象，而无须重新构建对象。
        示例中定义了三道菜，分别是两道热菜：北京烤鸭、绿豆排骨煲，一道凉菜：蒜泥白肉，三个具体的实现类非常类似，只是菜名不同，为了节省篇幅，这里就只看一个命令对象的具体实现。代码示例如下：

/**
 * 命令对象，绿豆排骨煲
 */
public class ChopCommand implements Command{
    /**
     * 持有具体做菜的厨师的对象
     */
    private CookApi cookApi = null;
    /**
     * 设置具体做菜的厨师的对象
     * @param cookApi 具体做菜的厨师的对象
     */
    public void setCookApi(CookApi cookApi) {
        this.cookApi = cookApi;
    }

    public void execute() {
        this.cookApi.cook("绿豆排骨煲");
    }
}

 

（4）该来组合菜单对象了，也就是宏命令对象。

• 首先宏命令就其本质还是一个命令，所以一样要实现Command接口
• 其次宏命令跟普通命令的不同在于：宏命令是多个命令组合起来的，因此在宏命令对象里面会记录多个组成它的命令对象
• 第三，既然是包含多个命令对象，得有方法让这多个命令对象能被组合进来
• 第四，既然宏命令包含了多个命令对象，执行宏命令对象就相当于依次执行这些命令对象，也就是循环执行这些命令对象

     看看代码示例会更清晰些，代码示例如下：

/**
 * 菜单对象，是个宏命令对象
 */
public class MenuCommand implements Command {
    /**
     * 用来记录组合本菜单的多道菜品，也就是多个命令对象
     */
    private Collection<Command> col = new ArrayList<Command>();
    /**
     * 点菜，把菜品加入到菜单中
     * @param cmd 客户点的菜
     */
    public void addCommand(Command cmd){
        col.add(cmd);
    }
    public void execute() {
        //执行菜单其实就是循环执行菜单里面的每个菜
        for(Command cmd : col){
            cmd.execute();
        }
    }
}

（5）该服务员类重磅登场了，它实现的功能，相当于标准命令模式实现中的Client加上Invoker，前面都是文字讲述，看看代码如何实现，示例代码如下：

/**
 * 服务员，负责组合菜单，负责组装每个菜和具体的实现者，
 * 还负责执行调用，相当于标准Command模式的Client+Invoker
 */
public class Waiter {
    /**
     * 持有一个宏命令对象——菜单
     */
    private MenuCommand menuCommand = new MenuCommand();
    /**
     * 客户点菜
     * @param cmd 客户点的菜，每道菜是一个命令对象
     */
    public void orderDish(Command cmd){
        //客户传过来的命令对象是没有和接收者组装的
        //在这里组装吧
        CookApi hotCook = new HotCook();
        CookApi coolCook = new CoolCook();
        //判读到底是组合凉菜师傅还是热菜师傅
        //简单点根据命令的原始对象的类型来判断
        if(cmd instanceof DuckCommand){
            ((DuckCommand)cmd).setCookApi(hotCook);
        }else if(cmd instanceof ChopCommand){
            ((ChopCommand)cmd).setCookApi(hotCook);
        }else if(cmd instanceof PorkCommand){
            //这是个凉菜，所以要组合凉菜的师傅
            ((PorkCommand)cmd).setCookApi(coolCook);
        }
        //添加到菜单中
        menuCommand.addCommand(cmd);
    }
    /**
     * 客户点菜完毕，表示要执行命令了，这里就是执行菜单这个组合命令
     */
    public void orderOver(){
        this.menuCommand.execute();
    }
}

（6）费了这么大力气，终于可以坐下来歇息一下，点菜吃饭吧，一起来看看客户端怎么使用这个宏命令，其实在客户端非常简单，根本看不出宏命令来，代码示例如下：

public class Client {
    public static void main(String[] args) {
        //客户只是负责向服务员点菜就好了
        //创建服务员
        Waiter waiter = new Waiter();

        //创建命令对象，就是要点的菜
        Command chop = new ChopCommand();
        Command duck = new DuckCommand();
        Command pork = new PorkCommand();

        //点菜，就是把这些菜让服务员记录下来
        waiter.orderDish(chop);
        waiter.orderDish(duck);
        waiter.orderDish(pork);

        //点菜完毕
        waiter.orderOver();
    }
}

运行一下，享受一下成果，结果如下：

本厨师正在做：绿豆排骨煲
本厨师正在做：北京烤鸭
凉菜蒜泥白肉已经做好，本厨师正在装盘。