跳至主要內容

行为型命令模式

gavin-james设计模式设计模式大约 9 分钟

命令模式基本介绍

在软件开发系统中，「方法的请求者」与「方法的实现者」之间经常存在紧密的耦合关系，这不利于软件功能的扩展与维护。例如，想对方法进行「撤销、重做、记录」等处理都很不方便，因此「如何将方法的请求者与实现者解耦？」变得很重要，命令模式就能很好地解决这个问题。

命令模式（Command Pattern）：在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计。

命名模式使得 请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活，实现解耦。

在命名模式中，会将一个请求封装为一个对象，以便使用不同参数来表示不同的请求（即命名），同时命令模式也支持可撤销的操作。

  • 通俗易懂的理解：将军发布命令，士兵去执行。其中有几个角色：将军（命令发布者）、士兵（命令的具体执行者）、命令（连接将军和士兵）

  • Invoker 是调用者（将军），Receiver 是被调用者（士兵），MyCommand 是命令，实现了 Command 接口，持有接收对象

  • 再比如，我们去餐厅吃饭，菜单不是等到客人来了之后才定制的，而是已经预先配置好的。这样，客人来了就只需要点菜，而不是任由客人临时定制。餐厅提供的菜单就相当于把请求和处理进行了解耦，这就是命令模式的体现

主要优点

  • 通过引入中间件（抽象接口）降低系统的耦合度
  • 扩展性良好，增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，且满足「开闭原则」
  • 可以实现宏命令。命令模式可以与 组合模式open in new window 结合，将多个命令装配成一个组合命令，即宏命令
  • 方便实现 Undo 和 Redo 操作。命令模式可以与 备忘录模式open in new window 结合，实现命令的撤销与恢复
  • 可以在现有命令的基础上，增加额外功能。比如日志记录，结合装饰器模式会更加灵活

主要缺点

  • 可能产生大量具体的命令类。因为每一个具体操作都需要设计一个具体命令类，这会增加系统的复杂性
  • 命令模式的结果其实就是接收方的执行结果，但是为了以命令的形式进行架构、解耦请求与实现，引入了额外类型结构（引入了请求方与抽象命令接口），增加了理解上的困难。不过这也是设计模式的通病，抽象必然会额外增加类的数量，代码抽离肯定比代码聚合更加难理解

命令模式的结构与实现

可以将系统中的相关操作抽象成命令，使调用者与实现者相关分离。

命令模式包含以下主要角色：

  • 抽象命令类（Command）角色：声明执行命令的接口，拥有执行命令的抽象方法 execute()
  • 具体命令类（Concrete Command）角色：是抽象命令类的具体实现类，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作
  • 实现者/接收者（Receiver）角色：执行命令功能的相关操作，是具体命令对象业务的真正实现者
  • 调用者/请求者（Invoker）角色：是请求的发送者，它通常拥有很多的命令对象，并通过访问命令对象来执行相关请求，它不直接访问接收者

结构图如下：

image-20220326120837468
image-20220326120837468

代码实现：

// 抽象命令
interface Command {
    public abstract void execute();
}
// 接收者
class Receiver {
    public void action() {
        System.out.println("接收者的action()方法被调用...");
    }
}
// 具体命令
class ConcreteCommand implements Command {
    private Receiver receiver;
    ConcreteCommand() {
        receiver = new Receiver();
    }
    public void execute() {
        receiver.action();
    }
}
// 调用者
class Invoker {
    private Command command;
    public Invoker(Command command) {
        this.command = command;
    }
    public void setCommand(Command command) {
        this.command = command;
    }
    public void call() {
        System.out.println("调用者执行命令command...");
        command.execute();
    }
}
public class CommandPattern {
    public static void main(String[] args) {
        Command cmd = new ConcreteCommand();
        Invoker ir = new Invoker(cmd);
        System.out.println("客户访问调用者的call()方法...");
        ir.call();
    }
}

命令模式解决智能生活项目

  • 我们买了一套智能家电，有照明灯、风扇、冰箱、洗衣机，我们只要在手机上安装 APP 就可以控制对这些家电工作

  • 这些智能家电来自不同的厂家，我们不想针对每一种家电都安装一个 APP，分别控制，我们希望只要一个 APP 就可以控制全部智能家电

  • 要实现一个 APP 控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口给 APP 调用，这时就可以考虑使用 命令模式。

命令模式可将 动作的请求者 从 动作的执行者 对象中解耦出来。

在我们的例子中，动作的请求者是手机 APP，动作的执行者是每个厂商的一个家电产品。

思路分析和类图：

image-20220326121345564
image-20220326121345564

代码实现：

命令类

// 创建命令接口
public interface Command {
    // 执行动作(操作)
    public void execute();
    // 撤销动作(操作)
    public void undo();
}
// 灯的开启类
public class LightOnCommand implements Command {
    
    LightReceiver lightReceiver;
    
    public LightOnCommand() {
        lightReceiver = new LightReceiver();
    }
    @Override
    public void execute() {
        lightReceiver.on();
    }

    @Override
    public void undo() {
        lightReceiver.off();
    }
}
// 灯的关闭类
public class LightOffCommand implements Command {
 
    private LightReceiver lightReceiver;

    public LightOffCommand() {
        lightReceiver = new LightReceiver();
    }
    @Override
    public void execute() {
        lightReceiver.off();
    }
    @Override
    public void undo() {
        lightReceiver.on();
    }
}
// 电视的开机类
public class TVOnCommand implements Command {
    TVReceiver tvReceiver;
    public TVOnCommand() {
        tvReceiver = new TVReceiver();
    }
    @Override
    public void execute() {
        tvReceiver.on();
    }

    @Override
    public void undo() {
        tvReceiver.off();
    }
}
// 电视的关机类
public class TVOffCommand implements Command {
       
    private TVReceiver tvReceiver;

    public TVOffCommand() {
        tvReceiver = new TVReceiver();
    }

    @Override
    public void execute() {
        tvReceiver.off();
    }

    @Override
    public void undo() {
        tvReceiver.on();
    }
}
/**
 * 没有任何命令，即空执行: 用于初始化每个按钮, 当调用空命令时，对象什么都不做
 * 其实，这样是一种设计模式, 可以省掉对空判断
 *
 */
public class NoCommand implements Command {

	@Override
	public void execute() {
	}

	@Override
	public void undo() {
	}
}

控制器类

// 灯的遥控器
public class LightReceiver {
    public void on() {
        System.out.println(" 电灯打开了.. ");
    }

    public void off() {
        System.out.println(" 电灯关闭了.. ");
    }
}
// 电视的遥控器
public class TVReceiver {
	
	public void on() {
		System.out.println(" 电视机打开了.. ");
	}
	
	public void off() {
		System.out.println(" 电视机关闭了.. ");
	}
}

调用者类

public class RemoteController {

    // 开按钮的命令数组
    Command[] onCommands;
    Command[] offCommands;

    // 执行撤销的命令
    Command undoCommand;

    // 构造器，完成对按钮初始化
    public RemoteController() {
        onCommands = new Command[5];
        offCommands = new Command[5];
        for (int i = 0; i < 5; i++) {
            onCommands[i] = new NoCommand();
            offCommands[i] = new NoCommand();
        }
    }

    // 给我们的按钮设置你需要的命令
    public void setCommand(int no, Command onCommand, Command offCommand) {
        onCommands[no] = onCommand;
        offCommands[no] = offCommand;
    }

    // 按下开按钮
    public void onButtonWasPushed(int no) { // no 0
        // 找到你按下的开的按钮， 并调用对应方法
        onCommands[no].execute();
        // 记录这次的操作，用于撤销
        undoCommand = onCommands[no];
    }

    // 按下开按钮
    public void offButtonWasPushed(int no) { // no 0
        // 找到你按下的关的按钮，并调用对应方法
        offCommands[no].execute();
        // 记录这次的操作，用于撤销
        undoCommand = offCommands[no];
    }

    // 按下撤销按钮
    public void undoButtonWasPushed() {
        undoCommand.undo();
    }
}

测试类

public class Client {

    public static void main(String[] args) {
        // 使用命令设计模式，完成通过遥控器，对电灯的操作

        // 创建电灯相关的开关命令
        LightOnCommand lightOnCommand = new LightOnCommand();
        LightOffCommand lightOffCommand = new LightOffCommand();

        // 需要一个遥控器
        RemoteController remoteController = new RemoteController();

        // 给我们的遥控器设置命令, 比如 no = 0 是电灯的开和关的操作
        remoteController.setCommand(0, lightOnCommand, lightOffCommand);

        System.out.println("--------按下灯的开按钮-----------");
        remoteController.onButtonWasPushed(0);
        System.out.println("--------按下灯的关按钮-----------");
        remoteController.offButtonWasPushed(0);
        System.out.println("--------按下撤销按钮-----------");
        remoteController.undoButtonWasPushed();

        System.out.println("=========使用遥控器操作电视机==========");

        TVOffCommand tvOffCommand = new TVOffCommand();
        TVOnCommand tvOnCommand = new TVOnCommand();

        // 给我们的遥控器设置命令, 比如 no = 1 是电视机的开和关的操作
        remoteController.setCommand(1, tvOnCommand, tvOffCommand);

        System.out.println("--------按下电视机的开按钮-----------");
        remoteController.onButtonWasPushed(1);
        System.out.println("--------按下电视机的关按钮-----------");
        remoteController.offButtonWasPushed(1);
        System.out.println("--------按下撤销按钮-----------");
        remoteController.undoButtonWasPushed();
    }
}

JdbcTemplate 的命令模式分析

Spring 框架的 JdbcTemplate 就使用到了命令模式。

image-20220326122114890
image-20220326122114890
  • StatementCallback 接口，类似命令接口（Command）
  • class QueryStatementCallback implements StatementCallback, SqlProvider，是个匿名内部类，实现了命令接口，同时也充当命令接收者
  • 命令调用者是 JdbcTemplate，其中 execute(StatementCallback action) 方法中，调用 action.doInStatement() 方法，不同的实现 StatementCallback 接口的对象，对应不同的 doInStatemnt
  • 另外实现 StatementCallback 命令接口的子类还有 QueryStatementCallback 等，如下图：
image-20220326122132691
image-20220326122132691

命令模式的注意事项和细节

将发起请求的对象与执行请求的对象解耦。发起请求的对象是调用者，调用者只要调用命令对象的 execute() 方法就可以让接收者工作，而不必知道具体的接收者对象是谁、是如何实现的，命令对象会负责让接收者执行请求的动作，也就是说：「请求发起者」和「请求执行者」之间的解耦是通过命令对象实现的，命令对象起到了纽带桥梁的作用。

容易设计一个命令队列。只要把命令对象放到列队，就可以多线程的执行命令，容易实现对请求的撤销和重做。

命令模式不足：可能导致某些系统有过多的具体命令类，增加了系统的复杂度，这点在在使用的时候要注意。

空命令 也是一种设计模式，它为我们省去了判空的操作。在上面的实例中，如果没有用空命令，我们每按下一个按键都要判空，这给我们编码带来一定的麻烦。

命令模式的应用场景

当系统的某项操作具备命令语义，且命令实现不稳定（变化）时，可以通过命令模式解耦请求与实现。使用抽象命令接口使请求方的代码架构稳定，封装接收方具体命令的实现细节。接收方与抽象命令呈现弱耦合（内部方法无需一致），具备良好的扩展性。

命令模式通常适用于以下场景：

  • 请求调用者需要与请求接收者解耦时，命令模式可以使调用者和接收者不直接交互
  • 系统随机请求命令或经常增加、删除命令时，命令模式可以方便地实现这些功能
  • 当系统需要执行一组操作时，命令模式可以定义宏命令来实现该功能
  • 当系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作时，可以将命令对象存储起来，采用备忘录模式来实现
本文章大部分来自pdai:地址https://www.pdai.tech
Copyright © 2023 gavin-james