设计模式（十） — 命令模式

让程序畅通执行——命令模式

命令模式的定义

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

命令模式的使用场景

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

命令模式的实例

角色介绍
Receiver：接收者角色
负责实施或执行一个请求，说得通俗点就是，执行具体逻辑的角色。
Command：命令角色
定义所有具体命令类的抽象接口。
ConcreteCommand：具体命令角色
实现Command接口，在实现方法中调用接受者角色的相关方法，在接收者和命令执行的具体行为之间加以弱耦合。
Invoker：请求者角色
调用命令对象执行具体的请求。

以俄罗斯方块为例，俄罗斯方块有四个按钮，左右移动、快速落下和变换形状。四个按钮相当于请求者，执行具体按钮命令的逻辑方法可以看作是命令角色。

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

public class TetrisMachine {
    private static final String TAG = "TetrisMachine";

    /**
     * description: 真正处理"向左"操作的逻辑代码
     */
    public void toLeft() {
        Log.i(TAG, "向左");
    }

    /**
     * description: 真正处理"向右"操作的逻辑代码
     */
    public void toRight() {
        Log.i(TAG, "向右");
    }

    /**
     * description: 真正处理"快速下落"操作的逻辑代码
     */
    public void fastToBottom() {
        Log.i(TAG, "快速下落");
    }

    /**
     * description: 真正处理"改变形状"操作的逻辑代码
     */
    public void transform() {
        Log.i(TAG, "改变形状");
    }
}

命令者抽象
Command.class

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

具体命令者 向右
RightCommand.class

public class RightCommand implements Command {
    //持有一个接收者俄罗斯方块游戏对象的引用
    private TetrisMachine tetrisMachine;

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

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

具体命令者 向左
LeftCommand.class

public class LeftCommand implements Command {
    //持有一个接收者俄罗斯方块游戏对象的引用
    private TetrisMachine tetrisMachine;

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

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

具体命令者 快速落下
FallCommand.class

public class FallCommand implements Command {
    //持有一个接收者俄罗斯方块游戏对象的引用
    private TetrisMachine tetrisMachine;

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

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

具体命令者 改变形状
TransformCommand.class

public class TransformCommand implements Command {
    //持有一个接收者俄罗斯方块游戏对象的引用
    private TetrisMachine tetrisMachine;

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

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

请求者
Buttons.class

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

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

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

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

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

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

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

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

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

客户端
Player.class

public class Player {
    public void play() {
        //首先要有俄罗斯方块游戏
        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();
    }
}

看到这，可能会犯嘀咕，明明可以很简单的调用，像这样：

        TetrisMachine tetrisMachine = new TetrisMachine();
        tetrisMachine.toLeft();
        tetrisMachine.toRight();
        tetrisMachine.fastToBottom();
        tetrisMachine.transform();

而且要是增加或者修改一个命令，需要改4处地方，这哪里是设计模式呀。

这个确实可以两个类搞定，但是命令模式的主旨是对命令请求者和命令接收者的解耦，方便对命令进行各种控制。什么叫方便对命令进行控制呢，打个比方，我们需要在按下俄罗斯方块游戏的时候记录命令执行的日志、命令的执行有某些条件。如果直接用两个类就会有大量的业务逻辑要在客户端进行处理，当命令增加，对每个命令的控制增加时，就会在Client里面产生大量的变化点，这样耦合就出来了。

小结

优点

更弱的耦合性、更灵活的控制性以及更好的扩展性。

缺点

设计模式的通病，类的膨胀，大量衍生类的创建。