设计模式系列——命令模式

前言

命令模式（Command Pattern）是行为模式之一。命令模式常用的地方是程序菜单命令，比如录音机的播放（Play）、停止（Stop）、倒带（Rewind）命令，当按下播放按钮，录音机就会执行一系列操作，从而播放音乐，至于它内部怎么执行的，用户不用去管。命令模式与之相同，将一系列的方法调用封装，用户只需发出命令，这些被封装的方法将被执行。感谢《Android源码设计模式解析与实战》。

命令模式定义

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

命令模式介绍

• 命令模式属于属于行为模式，又称行动（Action）模式或交易（Transaction）模式。
• 命令模式是对命令的封装，命令模式把发出命令的责任和执行命令的责任分隔开，委派给不同的对象。
• 每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。

命令模式使用场景

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

命令模式UML类图

命令模式UML类图.png

根据类图可以得到一个命令模式的通用模板代码。

接收者类

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

抽象命令接口

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

具体命令类

public class ConcreteCommand implements Command {
    private Receiver receiver;//持有一个接收者对象的引用

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

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

请求者类

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

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

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

客户端类

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: 请求者角色。
  该类的职责就是调用命令对象执行具体的请求，相关的方法称为行动方法。
  命令模式的应用其实就是将行为调用者与实现者解耦

命令模式的简单示例

这里以俄罗斯方块为例，对于这款游戏，相信大家都比较熟悉，主要有4个按钮，两个左右移动的按钮，一个快速落下的按钮，还有一个变化方块形状的按钮。玩游戏的人相当于我们的客户端，四个按钮相当于请求者，执行按钮命令的方法可以看作命令角色，最后真正执行具体操作逻辑实现功能的则是游戏本身，可以看作是各种机器码计算处理的，我们将其看作是接收者角色。

接收者角色

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

抽象命令者

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

具体命令者（向左移、向右移、快速下落和变换形状）

/**
 * 向左移动的命令类
 */
public class LeftCommand implements Command {
    //持有一个接收者对象的引用
    private TetrisMachine machine;

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

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

/**
 * 向右移动的命令类
 */
public class RightCommand implements Command {
    //持有一个接收者对象的引用
    private TetrisMachine machine;

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

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

/**
 * 快速下落的命令类
 */
public class FallCommand implements Command {
    //持有一个接收者对象的引用
    private TetrisMachine machine;

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

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

/**
 * 变换形状的命令类
 */
public class TransformCommand implements Command {
    //持有一个接收者对象的引用
    private TetrisMachine machine;

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

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

可以看出，命令者角色类中的方法名称与TetrisMachine接收者角色类中打的方法名可以不一样，两者之间仅是一种弱耦合。对于请求者，这里我们以一个Button类来表示，命令由按钮来执行。

请求者类

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

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

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

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

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

    /**
     * 请求者发出向左移动的命令
     */
    public void toLeft() {
        leftCommand.execute();
    }

    /**
     * 请求者发出向右移动的命令
     */
    public void toRight() {
        rightCommand.execute();
    }

    /**
     * 请求者发出快速下落的命令
     */
    public void fall() {
        fallCommand.execute();
    }

    /**
     * 请求者发出变换形状的命令
     */
    public void transform() {
        transformCommand.execute();
    }
}

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

public class Player {
    public static void main(String[] args) {
        //首先要有俄罗斯方块游戏
        TetrisMachine tetrisMachine = new TetrisMachine();

        //构造4种命令
        Command leftCommand = new LeftCommand(tetrisMachine);
        Command rightCommand = new RightCommand(tetrisMachine);
        Command fallCommand = new FallCommand(tetrisMachine);
        Command transformCommand = new TransformCommand(tetrisMachine);

        //按钮可以执行不同的命令
        Button button = new Button();
        button.setLeftCommand(leftCommand);
        button.setRightCommand(rightCommand);
        button.setFallCommand(fallCommand);
        button.setTransformCommand(transformCommand);

        //具体执行那个命令，玩家说了算
        button.toLeft();
        button.toRight();
        button.fall();
        button.transform();
    }
}

日志如下：

****** 向左 ******
****** 向右 ******
****** 快速落下 ******
****** 改变形状 ******

宏命令功能

假设需要一个功能，可以把一个个功能都记录下来，在必要的时候可以一次性执行所有记录的命令，这就是所谓的宏命令集的功能。代码如下：

需要新增一个代表宏命令的接口MacroCommand继承于Command接口，定义宏命令所需要的方法。

public interface MacroCommand extends Command {
    /**
     * 宏命令聚集的管理方法，
     * 添加一个命令
     *
     * @param command
     */
    void add(Command command);

    /**
     * 宏命令聚集的管理方法
     * 删除一个命令
     *
     * @param command
     */
    void remove(Command command);
}

新增具体的宏命令类MacroTetrisMachineCommand，实现具体管理宏命令的方法。

public class MacroTetrisMachineCommand implements MacroCommand {

    //管理命令的集合
    private Vector<Command> commands = new Vector<>();

    //添加一个命令
    @Override
    public void add(Command command) {
        commands.addElement(command);
    }

    //删除一个命令
    @Override
    public void remove(Command command) {
        commands.removeElement(command);
    }

    //执行方法
    @Override
    public void execute() {
        for (Command command : commands) {
            command.execute();
        }
    }
}

客户端如下

public class Player {
    public static void main(String[] args) {
        //首先要有俄罗斯方块游戏
        TetrisMachine tetrisMachine = new TetrisMachine();

        //构造4种命令
        Command leftCommand = new LeftCommand(tetrisMachine);
        Command rightCommand = new RightCommand(tetrisMachine);
        Command fallCommand = new FallCommand(tetrisMachine);
        Command transformCommand = new TransformCommand(tetrisMachine);

        MacroCommand macroCommand = new MacroTetrisMachineCommand();
        macroCommand.add(leftCommand);
        macroCommand.add(rightCommand);
        macroCommand.add(fallCommand);
        macroCommand.add(transformCommand);
        macroCommand.execute();
    }
}

总结

• 优点
  命令模式将将行为调用者与实现者解耦，使程序更灵活，易扩展，易维护。
• 缺点
  使用命令模式会带来过多的命令类，导致明显的类膨胀，所以实际开发中是否使用命令模式还是需要斟酌。