设计模式（五） 命令模式

命令模式

将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。命令模式通过这种封装的方式实现将客户端和接收端解耦。

类型：

行为型模式（类与类之间的行为型模式）

命令模式的几个角色：

    抽象命令接口Command：定义命令的接口，声明执行的方法。
    具体的命令对象ConcreteCommand：持有具体的接受者对象，完成具体的具体的命令。
    接受者对象Receiver：接受者对象，真正执行命令的对象。
    传递命令对象Invoker：持有命令对象，要求命令对象执行请求。
    客户端对象Client：创建具体命令的对象并且设置命令对象的接受者。

命令模式关系图：

命令模式示例：

本例子是呼叫小爱同学帮你开灯的例子，你对小爱同学说：小爱同学帮我打开灯，然后小爱同学让灯自己打开了。

抽象命令接口Command：

/**
 * Create by zhaihongwei on 2018/3/30
 * 抽象的命令接口，定义具体命名的接口
 */
public interface Command {

    /**
     * 执行命名的接口
     */
    void execute();
}

具体的命令对象ConcreteCommand：（开灯命令，关灯命令）

/**
 * Create by zhaihongwei on 2018/3/30
 * 开灯命令
 */
public class LightOnCommand implements Command{

    private Light light;

    /**
     * 创建开灯命令的时候，传入具体的灯对象，由灯对象操作自己
     * @param light
     */
    public LightOnCommand(Light light) {
        this.light = light;
    }

    @Override
    /**
     * 具体的灯对象调用自己的开灯方法
     */
    public void execute() {
        light.lightOn();
    }
}

/**
 * Create by zhaihongwei on 2018/3/30
 * 关灯命令
 */
public class LightOffCommand implements Command{

    private Light light;

    /**
     * 创建关灯命令的时候，传入具体的灯对象，由灯对象操作自己
     * @param light
     */
    public LightOffCommand(Light light) {
        this.light = light;
    }

    @Override
    /**
     * 具体的灯对象调用自己的关灯方法
     */
    public void execute() {
        light.lightOff();
    }
}

传递命令对象Invoker：

/**
 * Create by zhaihongwei on 2018/3/30
 * 小爱同学
 */
public class XiaoAi {

    private Command command;

    /**
     * 设置具体的命令
     * @param command
     */
    public void setCommand(Command command) {
        this.command = command;
    }

    /**
     * 执行命令
     */
    public void doCommand() {
        command.execute();
    }
}

接受者对象Receiver：

/**
 * Create by zhaihongwei on 2018/3/30
 * 具体的电灯类
 */
public class Light {

    /**
     * 开灯方法
     */
    public void lightOn() {
        System.out.println("灯打开了！！");
    }

    /**
     * 关灯方法
     */
    public void lightOff() {
        System.out.println("灯关上了！！");
    }
}

客户端对象：

/**
 * Create by zhaihongwei on 2018/3/30
 * 客户端对象
 */
public class Client {

    public static void main(String[] args) {
        // 创建小爱同学
        XiaoAi xiaoAi = new XiaoAi();
        // 创建具体的等对象，相当于具体的命令接受者
        Light light = new Light();
        // 创建了开灯的命令，你就是命令的发起者
        System.out.println("小爱同学帮我把灯开一下！");
        LightOnCommand lightOnCommand = new LightOnCommand(light);
        // 小爱同学接受到了你发出的命令,并执行命令
        xiaoAi.setCommand(lightOnCommand);
        xiaoAi.doCommand();

        System.out.println("-------------------------------------------------");
        System.out.println("小爱同学帮我关一下灯！");
        LightOffCommand lightOffCommand = new LightOffCommand(light);
        xiaoAi.setCommand(lightOffCommand);
        xiaoAi.doCommand();

    }
}

测试结果：

小爱同学帮我把灯开一下！
灯打开了！！
-------------------------------------------------
小爱同学帮我关一下灯！
灯关上了！！

     通过代码我们可以看到，当我们调用时，执行的时序首先是调用者类，然后是命令类，最后是接收者类。也就是说一条命令的执行被分成了三步，它的耦合度要比把所有的操作都封装到一个类中要低的多，而这也正是命令模式的精髓所在：把命令的调用者与执行者分开，使双方不必关心对方是如何操作的。

命令模式的优缺点：

优点：

• 实现客户端和接受者之间的解耦。
• 可以动态的添加新的命令。
• 只需要调用同一个方法（doCommand方法）便可以实现不同的功能。

缺点：

• 实现一个具体的命令系统，可能要创建很多的具体命令对象。

命令模式的适用场景

       对于大多数请求-响应模式的功能，比较适合使用命令模式，正如命令模式定义说的那样，命令模式对实现记录日志、撤销操作等功能比较方便。

总结

       对于一个场合到底用不用模式，这对所有的开发人员来说都是一个很纠结的问题。有时候，因为预见到需求上会发生的某些变化，为了系统的灵活性和可扩展性而使用了某种设计模式，但这个预见的需求偏偏没有，相反，没预见到的需求倒是来了不少，导致在修改代码的时候，使用的设计模式反而起了相反的作用，以至于整个项目组怨声载道。这样的例子，我相信每个程序设计者都遇到过。所以，基于敏捷开发的原则，我们在设计程序的时候，如果按照目前的需求，不使用某种模式也能很好地解决，那么我们就不要引入它，因为要引入一种设计模式并不困难，我们大可以在真正需要用到的时候再对系统进行一下，引入这个设计模式。

       拿命令模式来说吧，我们开发中，请求-响应模式的功能非常常见，一般来说，我们会把对请求的响应操作封装到一个方法中，这个封装的方法可以称之为命令，但不是命令模式。到底要不要把这种设计上升到模式的高度就要另行考虑了，因为，如果使用命令模式，就要引入调用者、接收者两个角色，原本放在一处的逻辑分散到了三个类中，设计时，必须考虑这样的代价是否值得。
 

参考于：

https://blog.csdn.net/zhwyj1019/article/details/79758057

https://blog.csdn.net/zhengzhb/article/details/7550895

https://www.runoob.com/design-pattern/command-pattern.html