《Android源码设计模式》之命令模式

命令模式介绍

命令模式（Command Pattern）是行为型设计模式之一，命令模式相对于其他的设计模式更为灵活多变。我们接触比较多的命令模式个例无非就是程序菜单命令，如在操作系统中，我们点击“关机”命令，系统就会执行一系列的操作，如先是暂停处理事件，保存系统的一些配置，然后结束程序进程，最后调用内核命令关闭计算机等，对于这一系列的命令，用户不用去管，用户只需点击系统的关机按钮即可完成如上一系列的命令。而我们的命令模式于此类似，将一系列的方法调用封装，用户只需要调用一个方法执行，那么所有这些被封装的方法就会被挨个执行调用。

命令模式的定义

将一个请求封装成一个对象，从而让用户使用不同的请求把客户端参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。

命令模式的使用场景

需要抽象处待执行的动作，然后以参数的形式提供出来----类似于过程设计中的回调机制，而命令模式正是回调机制的一个面向对象的替代品。
　　在不同的时刻制定、排列和执行请求。一个命令对象可以有与初始请求无关的生存期。
　　需要支持取消操作。
　　支持修改日志功能，这样当系统崩溃时，这些修改可以被重做一遍。
　　需要支持事务操作。

命令模式的UML类图

根据类图可以得出如下一个命令模式的通用代码。

接收者类

package com.guifa.commanddemo;

public class Receiver {
    public void action() {
        /**
         * 真正执行具体命令逻辑的方法
         */
        System.out.println("执行具体操作");
    }
}

抽象命令接口

package com.guifa.commanddemo;

public interface Command {
    /**
     * 执行具体操作的命令
     */
    void execute();
}

具体命令类

package com.guifa.commanddemo;

public class ConcreteCommand implements Command {

    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void execute() {
        /**
         * 调用接收者的相关方法来执行具体的逻辑
         */
        receiver.action();
    }
}

请求者类

package com.guifa.commanddemo;

public class Invoker {
    /**
     * 持有一个对相应对象的引用
     */
    private Command command;

    public Invoker(Command command) {
        this.command = command;
    }

    public void action() {
        // 调用具体命令对象的相关方法，执行具体命令
        command.execute();
    }
}

客户类

package com.guifa.commanddemo;

public class Client {
    public static void main(String[] args) {
        // 构造一个接收者
        Receiver receiver = new Receiver();
        // 根据接收者对象构造一个命令对象
        Command command = new ConcreteCommand(receiver);
        // 根据具体的对象构造请求者对象
        Invoker invoker = new Invoker(command);
        // 执行请求方法
        invoker.action();
    }
}

角色介绍：
　　Receiver：接收者角色。
　　该类负责具体实施或执行一个请求，执行具体逻辑的角色。任何一个类都可以成为一个接收者，而在接收者类中封装具体操作逻辑的方法我们则称为行动方法。
　　Command：命令角色。
　　定义所有具体命令类的抽象接口。
　　ConcreteCommand：具体命令角色。
　　该类实现了Command接口，在execute方法中调用接收者角色的相关方法，在接收者和命令执行的具体行为之间加以弱耦合。
　　Invoker：请求者角色。
　　该类的职责就是调用命令对象执行具体的请求，相关的方法我们称为行动方法。
　　Client：客户端角色。

命令模式的简单实现

以俄罗斯方块为例，该游戏中有4个按钮，两个左右移动的按钮，一个快速落下的按钮，还有一个变化方块形状的按钮。一个玩游戏的人就相当于我们的客户端，而游戏上的4个按钮就相当于请求者，执行具体按钮命令的逻辑方法可以看作是命令角色，最后真正执行处理具体逻辑则是游戏本身。

接收者角色 俄罗斯方块游戏

package com.guifa.commanddemo.game;

public class TetrisMachine {
    /**
     * 真正处理“向左”操作的逻辑代码
     */
    public void toLeft() {
        System.out.println("向左");
    }

    /**
     * 真正处理“向右”操作的逻辑代码
     */
    public void toRight() {
        System.out.println("向右");
    }

    /**
     * 真正处理“快速落下”操作的逻辑代码
     */
    public void fastToBottom() {
        System.out.println("快速落下");
    }

    /**
     * 真正处理“改变形状”操作的逻辑代码
     */
    public void transform() {
        System.out.println("改变形状");
    }
}

TetrisMachine类是整个命令模式中唯一处理具体代码逻辑的地方，其他地方都是直接或间接地调用到该类的方法，这就是接收者角色，处理具体的逻辑。

命令者抽象 定义执行方法

package com.guifa.commanddemo.game;

public interface Command {
    /**
     * 命令执行方法
     */
    void execute();
}

然后就是4个具体命令：向左移动、向右移动、快速落下和变换形状。

具体命令者 向左移动的命令类

package com.guifa.commanddemo.game;

public class LeftCommand implements Command {

    /**
     * 持有一个接收者俄罗斯方块游戏对象的引用
     */
    private TetrisMachine tetrisMachine;

    public LeftCommand(TetrisMachine tetrisMachine) {
        this.tetrisMachine = tetrisMachine;
    }

    @Override
    public void execute() {
        // 调用游戏机里的具体方法执行操作
        tetrisMachine.toLeft();
    }
}

具体命令者 向右移动的命令类

package com.guifa.commanddemo.game;

public class RightCommand implements Command {

    /**
     * 持有一个接收者俄罗斯方块游戏对象的引用
     */
    private TetrisMachine tetrisMachine;

    public RightCommand(TetrisMachine tetrisMachine) {
        this.tetrisMachine = tetrisMachine;
    }

    @Override
    public void execute() {
        // 调用游戏机里的具体方法执行操作
        tetrisMachine.toRight();
    }
}

具体命令者 快速落下的命令类

ppackage com.guifa.commanddemo.game;

public class FallCommand implements Command {

    /**
     * 持有一个接收者俄罗斯方块游戏对象的引用
     */
    private TetrisMachine tetrisMachine;

    public FallCommand(TetrisMachine tetrisMachine) {
        this.tetrisMachine = tetrisMachine;
    }

    @Override
    public void execute() {
        // 调用游戏机里的具体方法执行操作
        tetrisMachine.fastToBottom();
    }
}

具体命令者 改变形状的命令类

package com.guifa.commanddemo.game;

public class TransformCommand implements Command {

    /**
     * 持有一个接收者俄罗斯方块游戏对象的引用
     */
    private TetrisMachine tetrisMachine;

    public TransformCommand(TetrisMachine tetrisMachine) {
        this.tetrisMachine = tetrisMachine;
    }

    @Override
    public void execute() {
        // 调用游戏机里的具体方法执行操作
        tetrisMachine.transform();
    }
}

对于请求者，这里我们以一个Buttons类来表示，命令由按钮来执行。

请求者类 命令由按钮发起

package com.guifa.commanddemo.game;

public class Buttons {

    /**
     * 向左移动的命令对象引用
     */
    private LeftCommand leftCommand;
    /**
     * 向右移动的命令对象引用
     */
    private RightCommand rightCommand;
    /**
     * 快速落下的命令对象引用
     */
    private FallCommand fallCommand;
    /**
     * 改变形状命令对象引用
     */
    private TransformCommand transformCommand;

    /**
     * 设置向左移动的命令对象
     *
     * @param leftCommand 向左移动的命令对象
     */
    public void setLeftCommand(LeftCommand leftCommand) {
        this.leftCommand = leftCommand;
    }

    /**
     * 设置向右移动的命令对象
     *
     * @param rightCommand 向右移动的命令对象
     */
    public void setRightCommand(RightCommand rightCommand) {
        this.rightCommand = rightCommand;
    }

    /**
     * 设置快速落下的命令对象
     *
     * @param fallCommand 快速落下的命令对象
     */
    public void setFallCommand(FallCommand fallCommand) {
        this.fallCommand = fallCommand;
    }

    /**
     * 设置改变形状的命令对象
     *
     * @param transformCommand 改变形状命令对象
     */
    public void setTransformCommand(TransformCommand transformCommand) {
        this.transformCommand = transformCommand;
    }

    /**
     * 按下按钮向左移动
     */
    public void toLeft() {
        leftCommand.execute();
    }

    /**
     * 按下按钮向右移动
     */
    public void toRight() {
        rightCommand.execute();
    }

    /**
     * 按下按钮快速落下
     */
    public void fall() {
        fallCommand.execute();
    }

    /**
     * 按下按钮改变形状
     */
    public void transform() {
        transformCommand.execute();
    }
}

最后，由客户端来决定如何调用。

客户类

package com.guifa.commanddemo.game;

public class Player {

    public static void main(String[] args) {
        // 首先要有俄罗斯方块游戏
        TetrisMachine tetrisMachine = new TetrisMachine();
        // 根据游戏我们构造4种命令
        LeftCommand leftCommand = new LeftCommand(tetrisMachine);
        RightCommand rightCommand = new RightCommand(tetrisMachine);
        FallCommand fallCommand = new FallCommand(tetrisMachine);
        TransformCommand transformCommand = new TransformCommand(tetrisMachine);
        // 按钮可以执行不同的命令
        Buttons buttons = new Buttons();
        buttons.setLeftCommand(leftCommand);
        buttons.setRightCommand(rightCommand);
        buttons.setFallCommand(fallCommand);
        buttons.setTransformCommand(transformCommand);
        // 具体按下哪个按钮玩家说了算
        buttons.toLeft();
        buttons.toRight();
        buttons.fall();
        buttons.transform();
    }
}

或许大家在看了这一长篇代码后心存疑惑，明明就是一个很简单的调用逻辑，为什么要做得如此复杂呢？对于大部分开发者来说更愿意接受如下代码：

package com.guifa.commanddemo.game;

public class Player {

    public static void main(String[] args) {
        // 俄罗斯方块游戏
        TetrisMachine tetrisMachine = new TetrisMachine();
        // 要实现怎样的控制方式，我们就直接调用相关的函数就行
        tetrisMachine.toLeft();
        tetrisMachine.toRight();
        tetrisMachine.fastToBottom();
        tetrisMachine.transform();
    }
}

调用逻辑做得如此复杂，这是因为开发起来方便。每次我们增加或修改游戏功能只需修改TetrisMachine类就行了，然后对应的改一改Player类，但是这样的逻辑留给后来者，没人会觉得方便。设计模式有一条重要的原则：对修改关闭对扩展开放。
　　除此之外，使用命令模式的另一个好处是可以实现命令记录功能，如上例，我们在请求者Buttons里使用一个数据结构来存储执行过的命令对象，以此可方便的知道刚才执行过哪些命令动作，并可以在需要时恢复。

总结

在命令模式中其充分体现了几乎所有设计模式的通病，就是类膨胀，大量的衍生类的创建，这是一个不可避免的问题，但是，其给我们带来的好处也非常多，更弱的耦合性、更灵活的控制性以及更好的扩展性，不过，在实际开发过程中是不是需要采用命令模式还是需要斟酌。