解锁命令模式：Java 编程中的解耦神器
系列文章目录
第一章 解锁单例模式：Java世界的唯一实例之道
第二章 解锁工厂模式：工厂模式探秘
第三章 解锁代理模式：代理模式的多面解析与实战
第四章 解锁装饰器模式：代码增强的魔法宝典
第五章 解锁建造者模式：Java 编程中的对象构建秘籍
第六章 解锁原型模式：Java 中的高效对象创建之道
第七章 解锁适配器模式：代码重构与架构优化的魔法钥匙
第八章 解锁桥接模式：Java架构中的解耦神器
第九章 解锁组合模式：Java 代码中的树形结构奥秘
第十章 解锁享元模式：内存优化与性能提升的关键密码
第十一章 解锁外观模式：Java 编程中的优雅架构之道
第十二章 解锁观察者模式：Java编程中的高效事件管理之道
第十三章 解锁策略模式：Java 实战与应用全景解析
第十四章 解锁状态模式：Java 编程中的行为魔法
第十五章 解锁模板方法模式：Java 实战与应用探秘
第十六章 解锁命令模式：Java 编程中的解耦神器
第十七章 解锁迭代器模式：Java 编程的遍历神器
第十八章 解锁责任链模式：Java 实战与应用探秘
第十九章 解锁中介者模式：代码世界的“社交达人”
第二十章 解锁备忘录模式：代码世界的时光机
第二十一章 解锁访问者模式：Java编程的灵活之道
第二十二章 解锁Java解释器模式：概念、应用与实战
文章目录
- 一、命令模式是什么
- 二、命令模式的结构与角色
-
- （一）命令接口（Command）
- （二）具体命令类（ConcreteCommand）
- （三）接收者（Receiver）
- （四）调用者（Invoker）
- （五）客户端（Client）
- 三、命令模式的使用场景
-
- （一）GUI 按钮与菜单操作
- （二）事务性系统
- （三）宏命令（Macro Command）
- （四）任务队列系统
- 四、Java 代码示例
-
- （一）基础示例：简单的遥控器控制灯
- （二）进阶示例：支持撤销操作的遥控器系统
- （三）宏命令示例：图形编辑软件中的操作组合
- 五、命令模式的优缺点
-
- （一）优点
- （二）缺点
- 六、命令模式与其他设计模式的对比
-
- （一）与策略模式的区别
- （二）与观察者模式的区别
- （三）与责任链模式的区别
- 七、总结
一、命令模式是什么
在软件开发的世界里，我们常常会遇到这样的场景：一个对象需要请求另一个对象执行某个操作，但它们之间的联系却过于紧密，这就像是两个舞者，靠得太近，反而限制了彼此的发挥空间。命令模式，就像是一位智慧的编舞师，巧妙地将请求封装成对象，从而让这两个对象之间的关系变得更加灵活、松散。
命令模式的定义是：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，方便将命令对象进行储存、传递、调用、增加与管理。简单来说，就是把 “做什么” 和 “谁来做” 分离开来。
为了更好地理解，我们可以想象一个生活中的场景：你在餐厅用餐，当你想要点餐时，你并不会直接跑到厨房告诉厨师你要吃什么，而是告诉服务员。服务员会把你的需求记录下来，形成一个 “命令”，然后将这个命令传递给厨师。在这里，你就是请求的发送者，厨师是请求的接收者，而服务员则扮演了命令对象的角色。服务员将你的请求封装起来，传递给厨师，这样你和厨师之间就不需要直接交流，各自专注于自己的职责，你只需要提出需求，厨师只需要按照订单做菜。
从代码的角度来看，命令模式包含以下几个关键角色：
- 抽象命令类（Command）：它定义了命令的接口，就像一个模板，规定了所有具体命令类必须实现的方法，一般会有一个抽象的执行方法 execute()。
- 具体命令类（ConcreteCommand）：这是抽象命令类的具体实现，它持有接收者对象的引用，并在 execute() 方法中调用接收者的相应操作，从而完成命令的具体执行。
- 接收者（Receiver）：真正执行命令的对象，它知道如何执行与请求相关的操作，实现了具体的业务逻辑。
- 调用者（Invoker）：也叫请求者，它负责调用命令对象来执行请求，通常会持有一个或多个命令对象，它是客户端真正触发命令执行的地方。
- 客户端（Client）：负责创建具体的命令对象，并设置命令对象的接收者，将命令对象与接收者进行关联。
下面是一个简单的 Java 代码示例，来展示命令模式的基本结构：
// 抽象命令类
interface Command {
void execute();
}
// 具体命令类
class ConcreteCommand implements Command {
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
receiver.action();
}
}
// 接收者
class Receiver {
public void action() {
System.out.println("执行具体操作");
}
}
// 调用者
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.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.call();
}
}
在这个示例中，Client 创建了 Receiver 和 ConcreteCommand，并将 ConcreteCommand 传递给 Invoker。当 Invoker 的 call 方法被调用时，它会执行 ConcreteCommand 的 execute 方法，进而调用 Receiver 的 action 方法，完成整个请求的处理过程。通过这种方式，请求发送者（Invoker）和请求接收者（Receiver）之间实现了解耦，提高了系统的灵活性和可维护性。
二、命令模式的结构与角色
（一）命令接口（Command）
命令接口是命令模式的核心抽象，它定义了一个统一的方法签名，用于执行命令。这个接口就像是一个标准契约，规定了所有具体命令类必须遵循的行为规范。在 Java 中，通常以接口的形式出现，例如：
interface Command {
void execute();
}
execute 方法是命令接口的核心，它代表了命令的执行逻辑。虽然在接口中并没有具体的实现，但它为所有具体命令类提供了一个明确的执行入口。不同的具体命令类会根据自身的业务需求，实现这个 execute 方法，从而完成特定的任务。比如在一个图形绘制系统中，可能有绘制圆形、绘制矩形等不同的命令，它们都实现了 Command 接口的 execute 方法，分别完成绘制圆形和矩形的操作。
（二）具体命令类（ConcreteCommand）
具体命令类是命令接口的具体实现，每个具体命令类对应一个特定的请求。它持有一个接收者对象的引用，通过调用接收者的方法来实现命令的具体执行逻辑。例如：
class ConcreteCommand implements Command {
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
receiver.action();
}
}
在这个例子中，ConcreteCommand 实现了 Command 接口，并且在构造函数中接收一个 Receiver 对象。在 execute 方法中，它调用了 Receiver 的 action 方法，从而将命令的执行委托给接收者。这就好比在餐厅点餐的场景中，点 “红烧肉” 这个具体命令，会持有厨师（接收者）的引用，在执行这个命令时，会调用厨师的 “做红烧肉” 方法。
（三）接收者（Receiver）
接收者是真正执行命令的对象，它知道如何执行与请求相关的具体操作，实现了命令的业务逻辑。接收者可以是任何类，只要它具备执行命令所需的方法。例如：
class Receiver {
public void action() {
System.out.println("执行具体操作");
}
}
在实际应用中，接收者的 action 方法可能会包含复杂的业务逻辑，比如在一个文件操作系统中，接收者可能是一个文件操作类，它的 action 方法可能是实现文件的读取、写入、删除等操作。
（四）调用者（Invoker）
调用者负责触发命令的执行，它持有一个或多个命令对象，并通过调用命令对象的 execute 方法来执行请求。调用者并不关心命令的具体实现细节，只知道如何触发命令。例如：
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.execute();
}
}
在这个例子中，Invoker 类持有一个 Command 对象，并提供了一个 call 方法。当 call 方法被调用时，它会输出提示信息，然后调用命令对象的 execute 方法，从而执行命令。这就像在使用遥控器控制电视时，遥控器（调用者）按下某个按钮（调用 call 方法），就会触发相应的命令（电视的开关、换台等操作）。
（五）客户端（Client）
客户端是命令模式的使用者，它负责创建具体命令对象，并设置命令对象的接收者，将命令对象与接收者进行关联。然后，客户端将命令对象传递给调用者，由调用者来触发命令的执行。例如：
public class Client {
public static void main(String[] args) {
Receiver receiver = new Receiver();
Command command = new ConcreteCommand(receiver);
Invoker invoker = new Invoker(command);
invoker.call();
}
}
在这个客户端代码中，首先创建了一个 Receiver 对象和一个 ConcreteCommand 对象，并将 Receiver 对象传递给 ConcreteCommand 的构造函数，建立了命令与接收者之间的关联。然后，创建了一个 Invoker 对象，并将 ConcreteCommand 对象传递给它。最后，调用 Invoker 的 call 方法，触发命令的执行。这就如同在餐厅中，顾客（客户端）告诉服务员（调用者）要点什么菜（具体命令），服务员根据顾客的要求通知厨师（接收者）做菜。
三、命令模式的使用场景
（一）GUI 按钮与菜单操作
在图形用户界面（GUI）开发中，命令模式有着广泛的应用。以常见的桌面应用程序为例，其中的按钮和菜单操作是用户与程序交互的重要方式。每个按钮的点击、菜单项的选择都对应着一个具体的操作，比如保存文件、打开文件、复制文本等。
假设我们正在开发一个简单的文本编辑器，其中有 “保存” 按钮和 “撤销” 按钮。我们可以将 “保存文件” 这一操作封装成一个具体的命令类，例如SaveFileCommand。这个类实现了Command接口，在execute方法中调用文件操作相关的接收者对象的保存方法，从而完成文件保存的实际操作。同样，“撤销” 操作可以封装为UndoCommand类，它会记录之前的操作状态，在execute方法中根据记录的状态进行撤销操作。
这样，当用户点击 “保存” 按钮时，按钮作为调用者，调用SaveFileCommand的execute方法来执行保存操作；当点击 “撤销” 按钮时，调用UndoCommand的execute方法实现撤销。如果需要实现重做功能，也可以类似地封装RedoCommand。通过这种方式，将界面元素（按钮）与具体的业务操作解耦，使得代码结构更加清晰，也方便实现撤销和重做等复杂功能。例如，在实现撤销功能时，只需要维护一个命令历史记录栈，将每次执行的命令对象压入栈中，当需要撤销时，从栈顶取出命令对象并调用其undo方法（如果命令类实现了undo方法）即可。
（二）事务性系统
在许多需要支持可撤销操作的系统中，命令模式发挥着关键作用。
以数据库事务为例，数据库操作通常涉及多个步骤，如插入数据、更新数据、删除数据等，这些操作需要保证原子性，即要么全部成功执行，要么全部回滚。我们可以将每个数据库操作封装成一个命令对象，例如InsertCommand、UpdateCommand、DeleteCommand。每个命令对象在execute方法中执行相应的数据库操作，同时在undo方法中实现反向操作，用于回滚事务。
在一个转账的业务场景中，从账户 A 向账户 B 转账 100 元，这个过程涉及两个数据库操作：从账户 A 中减去 100 元（UpdateCommand）和向账户 B 中增加 100 元（UpdateCommand）。这两个操作可以封装为两个命令对象，并且可以将它们组合成一个复合命令，比如TransferCommand。当执行TransferCommand时，依次执行两个子命令的execute方法；如果在执行过程中出现错误，需要回滚事务，就依次调用两个子命令的undo方法。
文本编辑器也是一个典型的例子，用户在文本编辑器中的每一个操作，如插入字符、删除字符、修改文本格式等，都可以封装成一个命令对象。当用户进行一系列操作后，想要撤销上一步操作时，文本编辑器可以从操作历史记录中取出上一个命令对象并调用其undo方法，实现操作的撤销。如果用户想要重做被撤销的操作，也可以通过操作历史记录找到对应的命令对象并调用其redo方法（如果实现了重做功能）。
在命令行工具中，每一条命令也可以看作是一个命令对象。例如，在 Linux 系统中，rm命令用于删除文件，我们可以将其封装为一个RmCommand类，在execute方法中实现文件删除的逻辑。如果需要支持撤销删除操作，可以在undo方法中实现文件恢复的逻辑，比如从回收站中恢复文件（如果系统支持回收站功能）。
（三）宏命令（Macro Command）
当我们需要将一组操作组合为一个操作时，宏命令就派上了用场。宏命令是命令模式的一种扩展应用，它允许将多个命令组合成一个更大的命令，从而实现批量操作。
比如在一个自动化测试工具中，可能需要执行一系列的测试步骤，包括打开测试页面、输入测试数据、点击提交按钮、验证测试结果等。我们可以将每个测试步骤封装成一个命令对象，如OpenPageCommand、InputDataCommand、ClickButtonCommand、
VerifyResultCommand。然后，创建一个宏命令类TestMacroCommand，它实现了Command接口，并且持有一个命令对象列表。在execute方法中，遍历命令对象列表，依次调用每个命令对象的execute方法，从而实现整个测试流程的自动化执行。
在一个多媒体编辑软件中，用户可能经常需要进行一系列的操作来处理音频或视频文件，比如裁剪音频、添加特效、调整音量等。这些操作可以分别封装成CropAudioCommand、AddEffectCommand、AdjustVolumeCommand等命令对象。用户可以根据自己的需求创建不同的宏命令，比如 “制作短视频特效” 宏命令，将裁剪视频、添加转场特效、添加背景音乐等命令组合在一起。当用户执行这个宏命令时，就可以一次性完成多个操作，大大提高了工作效率。
以下是一个简单的 Java 代码示例，展示如何实现宏命令：
import java.util.ArrayList;
import java.util.List;
// 抽象命令类
interface Command {
void execute();
}
// 具体命令类1
class ConcreteCommand1 implements Command {
@Override
public void execute() {
System.out.println("执行命令1");
}
}
// 具体命令类2
class ConcreteCommand2 implements Command {
@Override
public void execute() {
System.out.println("执行命令2");
}
}
// 宏命令类
class MacroCommand implements Command {
private List<Command> commands = new ArrayList<>();
public void addCommand(Command command) {
commands.add(command);
}
@Override
public void execute() {
for (Command command : commands) {
command.execute();
}
}
}
// 客户端
public class Client {
public static void main(String[] args) {
MacroCommand macroCommand = new MacroCommand();
macroCommand.addCommand(new ConcreteCommand1());
macroCommand.addCommand(new ConcreteCommand2());
macroCommand.execute();
}
}
在这个示例中，MacroCommand类实现了宏命令，通过addCommand方法可以将多个具体命令添加到宏命令中，在execute方法中依次执行这些具体命令，从而实现了将一组操作组合为一个操作的功能。
（四）任务队列系统
在一些场景下，我们需要将命令加入队列中，实现延迟执行或异步执行，命令模式为这种需求提供了很好的解决方案。
例如，在一个分布式任务调度系统中，有大量的任务需要执行，这些任务可能来自不同的客户端，并且对执行时间和顺序有不同的要求。我们可以将每个任务封装成一个命令对象，比如TaskCommand，然后将这些命令对象加入到任务队列中。调度器作为调用者，从任务队列中取出命令对象，并调用其execute方法来执行任务。通过这种方式，可以实现任务的排队执行，并且可以根据任务的优先级、执行时间等条件对任务队列进行管理和调度。
在一个电商系统中，订单处理是一个复杂的过程，可能涉及多个步骤，如库存检查、订单生成、支付处理、物流配送等。为了提高系统的性能和响应速度，可以将这些步骤封装成命令对象，如CheckStockCommand、GenerateOrderCommand、ProcessPaymentCommand、ArrangeDeliveryCommand，并将它们加入到订单处理队列中。订单处理系统从队列中依次取出命令对象并执行，实现订单的异步处理。这样，当用户提交订单后，系统可以立即返回响应，告知用户订单已提交成功，而订单的后续处理则在后台异步进行，不会影响用户的操作体验。
在一个消息队列系统中，生产者将消息发送到队列中，消费者从队列中获取消息并进行处理。我们可以将消息处理逻辑封装成命令对象，消费者从队列中取出消息对应的命令对象并执行，实现消息的异步处理。例如，在一个邮件发送系统中，当用户发送邮件时，将邮件发送任务封装成SendEmailCommand，加入到消息队列中。邮件发送服务作为消费者，从队列中取出SendEmailCommand并执行，完成邮件的发送操作。通过这种方式，可以实现邮件发送的异步化，避免因为邮件发送过程中的网络延迟等问题影响系统的整体性能。
四、Java 代码示例
（一）基础示例：简单的遥控器控制灯
在日常生活中，我们经常使用遥控器来控制各种电器设备，比如电灯。下面我们以遥控器控制灯的开关为例，逐步展示命令模式的实现过程。
- 定义命令接口
首先，我们需要定义一个命令接口，它规定了所有具体命令类必须实现的方法。在这个例子中，命令接口非常简单，只包含一个执行命令的方法 execute。
// 命令接口
interface Command {
void execute();
}
- 实现具体命令类
接下来，我们编写开灯和关灯的具体命令类，它们都实现了命令接口。每个具体命令类都持有一个灯对象的引用，在 execute 方法中调用灯的相应开关方法。
// 开灯命令类
class LightOnCommand implements Command {
private Light light;
public LightOnCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.turnOn();
}
}
// 关灯命令类
class LightOffCommand implements Command {
private Light light;
public LightOffCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.turnOff();
}
}
- 实现接收者类
灯类就是我们的接收者，它包含打开和关闭灯的具体操作。
// 灯类，作为接收者
class Light {
public void turnOn() {
System.out.println("灯已打开");
}
public void turnOff() {
System.out.println("灯已关闭");
}
}
- 实现调用者类
遥控器类作为调用者，它持有命令对象，并提供按下按钮执行命令的方法。
// 遥控器类，作为调用者
class RemoteControl {
private Command command;
public void setCommand(Command command) {
this.command = command;
}
public void pressButton() {
command.execute();
}
}
- 客户端代码
在客户端代码中，我们创建灯、具体命令对象和遥控器对象，然后设置遥控器的命令并执行。
// 客户端
public class Client {
public static void main(String[] args) {
Light light = new Light();
Command lightOn = new LightOnCommand(light);
Command lightOff = new LightOffCommand(light);
RemoteControl remote = new RemoteControl();
// 按下打开灯的按钮
remote.setCommand(lightOn);
remote.pressButton();
// 按下关闭灯的按钮
remote.setCommand(lightOff);
remote.pressButton();
}
}
运行上述代码，输出结果如下：
灯已打开
灯已关闭
通过这个简单的示例，我们可以清晰地看到命令模式如何将请求的发送者（遥控器）和接收者（灯）解耦，使得系统更加灵活和易于扩展。如果我们需要添加新的命令，比如调节灯的亮度，只需要创建一个新的具体命令类，实现 Command 接口，并在其中调用灯的调节亮度方法即可，而不需要修改遥控器和灯的代码。
（二）进阶示例：支持撤销操作的遥控器系统
在基础示例的基础上，我们进一步扩展，实现一个支持撤销操作的遥控器系统。这在实际应用中非常有用，比如用户误操作时可以撤销上一步操作。
- 修改命令接口
首先，在命令接口中增加一个撤销方法 undo，用于撤销命令的执行。
// 修改后的命令接口
interface Command {
void execute();
void undo();
}
- 实现具体命令类
然后，修改开灯和关灯的具体命令类，实现 undo 方法。在 undo 方法中，调用灯的相反操作，以实现撤销功能。
// 修改后的开灯命令类
class LightOnCommand implements Command {
private Light light;
public LightOnCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.turnOn();
}
@Override
public void undo() {
light.turnOff();
}
}
// 修改后的关灯命令类
class LightOffCommand implements Command {
private Light light;
public LightOffCommand(Light light) {
this.light = light;
}
@Override
public void execute() {
light.turnOff();
}
@Override
public void undo() {
light.turnOn();
}
}
- 修改调用者类
接下来，在遥控器类中增加记录上一个命令的功能，并提供一个撤销按钮的方法，用于撤销上一个命令的执行。
// 修改后的遥控器类
class RemoteControl {
private Command command;
private Command lastCommand;
public void setCommand(Command command) {
this.command = command;
}
public void pressButton() {
command.execute();
lastCommand = command;
}
public void pressUndoButton() {
if (lastCommand!= null) {
lastCommand.undo();
}
}
}
以下是使用这个支持撤销操作的遥控器系统的客户端代码：
// 客户端
public class Client {
public static void main(String[] args) {
Light light = new Light();
Command lightOn = new LightOnCommand(light);
Command lightOff = new LightOffCommand(light);
RemoteControl remote = new RemoteControl();
// 按下打开灯的按钮
remote.setCommand(lightOn);
remote.pressButton();
// 按下关闭灯的按钮
remote.setCommand(lightOff);
remote.pressButton();
// 按下撤销按钮
remote.pressUndoButton();
}
}
运行上述代码，输出结果如下：
灯已打开
灯已关闭
灯已打开
通过这个进阶示例，我们实现了一个支持撤销操作的遥控器系统，进一步展示了命令模式在实现复杂功能时的强大能力。这种设计使得系统的操作更加灵活和用户友好，能够满足更多实际应用场景的需求。
（三）宏命令示例：图形编辑软件中的操作组合
在图形编辑软件中，用户常常需要执行一系列的操作，比如新建文档并打开网格线。我们可以使用宏命令来实现这样的操作组合，将多个命令封装成一个命令，从而方便用户操作。
- 定义命令接口
首先，展示命令接口的代码定义，它包含执行命令的方法 execute。
// 命令接口
interface Command {
void execute();
}
- 实现具体命令类
创建新建文档和打开网格线的具体命令类，它们都实现了命令接口，在 execute 方法中执行相应的操作。
// 新建文档命令类
class NewDocumentCommand implements Command {
@Override
public void execute() {
System.out.println("新建文档");
}
}
// 打开网格线命令类
class OpenGridCommand implements Command {
@Override
public void execute() {
System.out.println("打开网格线");
}
}
- 实现宏命令类
定义宏命令类，它持有一个命令列表，在 execute 方法中依次执行列表中的命令。
import java.util.ArrayList;
import java.util.List;
// 宏命令类
class MacroCommand implements Command {
private List<Command> commands = new ArrayList<>();
public void addCommand(Command command) {
commands.add(command);
}
@Override
public void execute() {
for (Command command : commands) {
command.execute();
}
}
}
- 客户端代码
在客户端代码中，创建宏命令对象，添加具体命令到宏命令中，然后执行宏命令。
// 客户端
public class Client {
public static void main(String[] args) {
MacroCommand macroCommand = new MacroCommand();
macroCommand.addCommand(new NewDocumentCommand());
macroCommand.addCommand(new OpenGridCommand());
macroCommand.execute();
}
}
运行上述代码，输出结果如下：
新建文档
打开网格线
通过这个宏命令示例，我们可以看到命令模式如何将多个操作组合成一个操作，提高了系统的操作效率和用户体验。在图形编辑软件中，用户可以通过一个宏命令快速完成多个相关操作，而不需要逐个执行每个命令，大大简化了操作流程。
五、命令模式的优缺点
（一）优点
-
降低耦合度
命令模式的核心优势之一在于它能够显著降低系统中各组件之间的耦合度。通过将请求封装成命令对象，请求发送者（调用者）和请求接收者之间不再直接交互，而是通过命令对象进行沟通。这就好比在一场复杂的舞台剧表演中，导演（调用者）不需要直接指挥每个演员（接收者）的具体动作，而是通过剧本（命令对象）来传达指令。演员们只需要按照剧本的要求进行表演，而不需要关心导演的具体想法和指令方式。在软件开发中，这种解耦方式使得发送者和接收者可以独立变化，互不影响。例如，在一个图形绘制系统中，绘制圆形、矩形等操作的命令对象可以独立于绘制工具和图形对象进行修改和扩展，而不会影响到其他部分的代码。这种低耦合性不仅提高了代码的可维护性，还使得系统更加灵活，易于应对需求的变化。 -
扩展性强
命令模式具有很强的扩展性，这得益于它符合开闭原则。开闭原则强调软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。在命令模式中，当我们需要添加新的功能时，只需要创建一个新的具体命令类，实现命令接口即可。例如，在一个游戏开发项目中，最初可能只有 “移动角色” 和 “攻击怪物” 两个命令。随着游戏的发展，需要增加 “释放技能” 的功能。此时，我们只需要创建一个 “ReleaseSkillCommand” 类，实现命令接口中的 “execute” 方法，在其中编写释放技能的具体逻辑，而不需要修改原有的 “移动角色” 和 “攻击怪物” 命令类以及其他相关的代码。这种方式使得系统能够轻松地应对新功能的添加，大大提高了软件的可维护性和可扩展性。 -
支持撤销与重做
对于许多需要支持撤销和重做操作的系统来说，命令模式是一个理想的选择。在命令模式中，每个命令对象都可以记录自己的执行状态和操作细节。当需要撤销操作时，只需调用命令对象的 “undo” 方法，该方法会执行与 “execute” 方法相反的操作，将系统恢复到操作之前的状态。例如，在一个文本编辑器中，用户输入文字的操作可以封装为一个 “InsertTextCommand” 类，在 “execute” 方法中实现文字插入的功能，在 “undo” 方法中实现文字删除的功能。当用户点击 “撤销” 按钮时，就可以调用 “InsertTextCommand” 对象的 “undo” 方法，删除刚刚插入的文字。同样，当需要重做操作时，调用命令对象的 “redo” 方法，再次执行 “execute” 方法中的操作。这种机制使得系统能够方便地实现撤销和重做功能，为用户提供了更加友好和灵活的操作体验。 -
组合复杂操作
命令模式允许将多个简单命令组合成一个复杂的操作，即宏命令。通过这种方式，可以将一系列相关的操作封装在一起，作为一个整体进行处理。例如，在一个自动化测试工具中，可能需要执行一系列的测试步骤，包括打开测试页面、输入测试数据、点击提交按钮、验证测试结果等。我们可以将每个测试步骤封装成一个命令对象，然后创建一个宏命令对象，将这些命令对象组合在一起。当执行宏命令时，就会依次执行各个子命令，完成整个测试流程。这种组合操作的方式不仅提高了操作的效率，还使得代码结构更加清晰，易于维护。同时，宏命令还可以被重复使用，进一步提高了代码的复用性。
（二）缺点
-
命令类数量增加
命令模式的一个明显缺点是，随着系统功能的增加，命令类的数量可能会急剧增多。因为每个具体操作都需要定义一个命令类，这就导致系统中类的数量大幅增加。例如，在一个功能丰富的办公软件中，可能有打开文件、保存文件、打印文件、设置字体格式、设置段落格式等众多操作，每个操作都需要对应一个命令类。过多的命令类会使系统的结构变得复杂，增加了代码的管理和维护难度。同时，在查找和理解某个功能的实现时，需要在众多的命令类中进行搜索，也会降低开发效率。此外，类数量的增加还可能导致编译时间变长，占用更多的系统资源。 -
实现成本较高
如果系统不需要撤销、重做或记录操作日志等功能，使用命令模式可能会带来不必要的复杂性和冗余性。因为命令模式的实现需要定义多个角色和类，包括命令接口、具体命令类、接收者、调用者等，这增加了系统的设计和实现成本。在一些简单的应用场景中，直接调用方法可能更加简洁高效，而使用命令模式则显得过于繁琐。例如，在一个简单的计算器程序中，只需要实现基本的加、减、乘、除运算，直接在一个类中定义相应的方法即可，使用命令模式反而会使代码变得复杂。此外，命令模式中对象的创建和管理也会带来一定的性能开销，在对性能要求较高的场景下，需要谨慎考虑是否使用命令模式。
六、命令模式与其他设计模式的对比
（一）与策略模式的区别
命令模式和策略模式都是行为型设计模式，它们在某些方面有相似之处，但也存在明显的区别。
从意图上看，命令模式的核心意图是将请求封装成对象，从而使发送者和接收者解耦，它更侧重于对请求的封装和管理，方便实现请求的参数化、队列化、日志记录以及撤销和重做等操作。例如，在一个图形绘制系统中，“绘制圆形”“绘制矩形” 等操作可以封装成命令对象，发送者（如用户界面）不需要知道具体的绘制实现细节，只需要触发相应的命令即可。而策略模式的意图是定义一系列算法，并将每个算法封装起来，使它们可以相互替换，它主要关注的是算法的封装和切换，让算法的变化独立于使用它的客户。比如在一个排序系统中，可能有冒泡排序、快速排序、插入排序等多种算法，策略模式可以将这些算法封装成不同的策略类，客户端可以根据具体需求选择不同的排序策略。
在使用场景方面，命令模式常用于需要支持撤销、重做、日志记录、事务处理等功能的场景，以及需要将请求的发送者和接收者解耦的场景，如 GUI 按钮操作、任务队列系统等。而策略模式则适用于当有多个不同的算法或行为，并且需要在运行时动态选择和切换的场景，例如不同的支付方式（现金支付、银行卡支付、第三方支付等）、不同的加密算法等。
从实现方式来看，命令模式通常包含命令接口、具体命令类、接收者和调用者等角色。具体命令类实现命令接口，持有接收者的引用，并在执行方法中调用接收者的相应操作。调用者通过调用命令对象的执行方法来触发请求。而策略模式包含策略接口、具体策略类和上下文对象。具体策略类实现策略接口，上下文对象持有策略对象的引用，并在需要时调用策略对象的方法。上下文对象起到了一个桥梁的作用，它将客户端与具体的策略实现解耦。
下面通过一个简单的代码示例来进一步说明两者的区别。假设我们有一个计算面积的功能，对于圆形和矩形有不同的计算方法。
使用策略模式的代码示例：
// 策略接口
interface AreaStrategy {
double calculateArea(double param1, double param2);
}
// 圆形面积计算策略
class CircleAreaStrategy implements AreaStrategy {
@Override
public double calculateArea(double radius, double ignored) {
return Math.PI * radius * radius;
}
}
// 矩形面积计算策略
class RectangleAreaStrategy implements AreaStrategy {
@Override
public double calculateArea(double length, double width) {
return length * width;
}
}
// 上下文对象
class AreaCalculator {
private AreaStrategy strategy;
public AreaCalculator(AreaStrategy strategy) {
this.strategy = strategy;
}
public double calculate(double param1, double param2) {
return strategy.calculateArea(param1, param2);
}
}
// 客户端
public class StrategyClient {
public static void main(String[] args) {
AreaCalculator circleCalculator = new AreaCalculator(new CircleAreaStrategy());
double circleArea = circleCalculator.calculate(5, 0);
AreaCalculator rectangleCalculator = new AreaCalculator(new RectangleAreaStrategy());
double rectangleArea = rectangleCalculator.calculate(4, 6);
System.out.println("圆形面积: " + circleArea);
System.out.println("矩形面积: " + rectangleArea);
}
}
使用命令模式的代码示例：
// 命令接口
interface Command {
void execute();
}
// 接收者：图形对象
class Circle {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
public double calculateArea() {
return Math.PI * radius * radius;
}
}
class Rectangle {
private double length;
private double width;
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
public double calculateArea() {
return length * width;
}
}
// 具体命令类：计算圆形面积命令
class CalculateCircleAreaCommand implements Command {
private Circle circle;
public CalculateCircleAreaCommand(Circle circle) {
this.circle = circle;
}
@Override
public void execute() {
double area = circle.calculateArea();
System.out.println("圆形面积: " + area);
}
}
// 具体命令类：计算矩形面积命令
class CalculateRectangleAreaCommand implements Command {
private Rectangle rectangle;
public CalculateRectangleAreaCommand(Rectangle rectangle) {
this.rectangle = rectangle;
}
@Override
public void execute() {
double area = rectangle.calculateArea();
System.out.println("矩形面积: " + area);
}
}
// 调用者
class Invoker {
private Command command;
public Invoker(Command command) {
this.command = command;
}
public void executeCommand() {
command.execute();
}
}
// 客户端
public class CommandClient {
public static void main(String[] args) {
Circle circle = new Circle(5);
Command circleCommand = new CalculateCircleAreaCommand(circle);
Invoker circleInvoker = new Invoker(circleCommand);
circleInvoker.executeCommand();
Rectangle rectangle = new Rectangle(4, 6);
Command rectangleCommand = new CalculateRectangleAreaCommand(rectangle);
Invoker rectangleInvoker = new Invoker(rectangleCommand);
rectangleInvoker.executeCommand();
}
}
通过上述代码可以看出，策略模式更侧重于算法的切换，而命令模式更侧重于请求的封装和执行。
（二）与观察者模式的区别
命令模式和观察者模式虽然都涉及到对象之间的交互，但它们在关注重点和对象关系上有着显著的不同。
观察者模式主要关注对象之间的一对多依赖关系，当一个对象（被观察者）的状态发生变化时，所有依赖于它的对象（观察者）都会收到通知并自动更新。例如，在一个新闻发布系统中，新闻发布者是被观察者，而订阅该新闻的用户是观察者。当新闻发布者发布新的新闻时，所有订阅的用户都会收到通知并获取最新的新闻内容。观察者模式强调的是对象状态的变化通知和自动更新机制，它的目的是实现对象之间的状态同步。
而命令模式关注的是请求的封装和解耦，将请求发送者和接收者分离，使得请求可以被存储、传递、调用、增加与管理。比如在一个游戏中，玩家的操作（如攻击、移动等）可以封装成命令对象，发送者（玩家操作界面）不需要知道具体的执行细节，只需要将命令发送给接收者（游戏逻辑处理模块）即可。命令模式更注重的是请求的处理和控制流程。
在对象关系方面，观察者模式中被观察者和观察者之间是一种松耦合的关系，观察者只需要实现特定的接口，以便在被观察者状态变化时能够接收通知。观察者并不知道被观察者的具体实现细节，只关心其状态的变化。而命令模式中，调用者和接收者之间通过命令对象进行通信，调用者只知道命令对象的接口，而不关心具体的接收者是谁以及如何执行命令。接收者负责实现命令的具体操作，但它与调用者之间没有直接的依赖关系。
例如，在一个股票交易系统中，如果使用观察者模式，当股票价格发生变化时，所有关注该股票的投资者（观察者）都会收到通知，他们可以根据新的价格进行相应的操作。而如果使用命令模式，投资者的交易操作（如买入、卖出股票）可以封装成命令对象，由交易系统（调用者）将这些命令发送给股票交易执行模块（接收者）进行处理。
从代码实现角度来看，观察者模式通常包含被观察者接口（或抽象类）、具体被观察者类、观察者接口（或抽象类）和具体观察者类。被观察者类中维护一个观察者列表，当状态变化时，遍历该列表并通知所有观察者。而命令模式包含命令接口、具体命令类、接收者和调用者，具体命令类实现命令接口，调用接收者的方法来执行命令。
下面是一个简单的代码示例，展示观察者模式和命令模式的不同实现：
观察者模式代码示例：
import java.util.ArrayList;
import java.util.List;
// 观察者接口
interface Observer {
void update(String message);
}
// 具体观察者类
class Investor implements Observer {
private String name;
public Investor(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " 收到通知: " + message);
}
}
// 被观察者接口
interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notifyObservers(String message);
}
// 具体被观察者类：股票
class Stock implements Subject {
private List<Observer> observers = new ArrayList<>();
private String stockName;
private double price;
public Stock(String stockName, double price) {
this.stockName = stockName;
this.price = price;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
notifyObservers("股票 " + stockName + " 的价格变为: " + price);
}
@Override
public void attach(Observer observer) {
observers.add(observer);
}
@Override
public void detach(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
// 客户端
public class ObserverClient {
public static void main(String[] args) {
Stock stock = new Stock("AAPL", 150.0);
Investor investor1 = new Investor("张三");
Investor investor2 = new Investor("李四");
stock.attach(investor1);
stock.attach(investor2);
stock.setPrice(155.0);
}
}
命令模式代码示例：
// 命令接口
interface Command {
void execute();
}
// 接收者：股票交易执行模块
class StockTradingSystem {
public void buyStock(String stockName, double price, int quantity) {
System.out.println("买入 " + quantity + " 股 " + stockName + "，价格为: " + price);
}
public void sellStock(String stockName, double price, int quantity) {
System.out.println("卖出 " + quantity + " 股 " + stockName + "，价格为: " + price);
}
}
// 具体命令类：买入股票命令
class BuyStockCommand implements Command {
private StockTradingSystem tradingSystem;
private String stockName;
private double price;
private int quantity;
public BuyStockCommand(StockTradingSystem tradingSystem, String stockName, double price, int quantity) {
this.tradingSystem = tradingSystem;
this.stockName = stockName;
this.price = price;
this.quantity = quantity;
}
@Override
public void execute() {
tradingSystem.buyStock(stockName, price, quantity);
}
}
// 具体命令类：卖出股票命令
class SellStockCommand implements Command {
private StockTradingSystem tradingSystem;
private String stockName;
private double price;
private int quantity;
public SellStockCommand(StockTradingSystem tradingSystem, String stockName, double price, int quantity) {
this.tradingSystem = tradingSystem;
this.stockName = stockName;
this.price = price;
this.quantity = quantity;
}
@Override
public void execute() {
tradingSystem.sellStock(stockName, price, quantity);
}
}
// 调用者
class Trader {
private Command command;
public Trader(Command command) {
this.command = command;
}
public void executeCommand() {
command.execute();
}
}
// 客户端
public class CommandClient {
public static void main(String[] args) {
StockTradingSystem tradingSystem = new StockTradingSystem();
Command buyCommand = new BuyStockCommand(tradingSystem, "AAPL", 150.0, 100);
Command sellCommand = new SellStockCommand(tradingSystem, "AAPL", 155.0, 50);
Trader trader1 = new Trader(buyCommand);
trader1.executeCommand();
Trader trader2 = new Trader(sellCommand);
trader2.executeCommand();
}
}
通过以上代码可以清晰地看到观察者模式和命令模式在实现和应用场景上的差异。
（三）与责任链模式的区别
命令模式和责任链模式都是用于处理请求的设计模式，但它们在处理请求的方式和灵活性方面存在明显的区别。
责任链模式通过将请求的处理者组织成一条链，使得请求可以沿着这条链依次传递，直到有一个处理者能够处理该请求为止。它的主要目的是解耦请求的发送者和接收者，并且可以动态地调整处理链的结构。例如，在一个审批流程中，请假申请可能需要依次经过组长、部门经理、总经理的审批，每个审批者都有机会处理这个请求，如果当前审批者无法处理（如权限不足），则将请求传递给下一个审批者。责任链模式强调的是请求在一系列处理者之间的传递和处理顺序。
而命令模式是将请求封装成对象，重点在于解耦请求的发送者和接收者，使得请求可以被参数化、存储、延迟执行、支持撤销和重做等操作。比如在一个文本编辑器中，用户的各种操作（如插入文本、删除文本、复制文本等）可以封装成命令对象，发送者（用户界面）通过调用命令对象的执行方法来触发相应的操作，而不需要知道具体的接收者（文本编辑模块）是如何实现这些操作的。
在处理请求的方式上，责任链模式是顺序处理，请求沿着处理链依次传递，每个处理者根据自己的条件决定是否处理请求，如果不处理则传递给下一个处理者。而命令模式是由调用者直接调用命令对象的执行方法来执行请求，没有中间的传递过程。
从灵活性角度来看，责任链模式的灵活性主要体现在可以动态地添加、删除或调整处理链中的处理者，以适应不同的业务规则和流程变化。例如，在一个工作流系统中，可以根据项目的需求动态地调整审批流程中的审批节点。而命令模式的灵活性则体现在可以方便地扩展新的命令，并且可以轻松地实现命令的组合（如宏命令），以及对命令的各种管理操作（如撤销、重做、日志记录等）。
下面通过一个简单的代码示例来展示两者的区别：
责任链模式代码示例：
// 抽象处理者类
abstract class Handler {
protected Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
public abstract void handleRequest(int request);
}
// 具体处理者类1
class ConcreteHandler1 extends Handler {
@Override
public void handleRequest(int request) {
if (request >= 0 && request < 10) {
System.out.println("ConcreteHandler1 处理请求: " + request);
} else if (nextHandler!= null) {
nextHandler.handleRequest(request);
}
}
}
// 具体处理者类2
class ConcreteHandler2 extends Handler {
@Override
public void handleRequest(int request) {
if (request >= 10 && request < 20) {
System.out.println("ConcreteHandler2 处理请求: " + request);
} else if (nextHandler!= null) {
nextHandler.handleRequest(request);
}
}
}
// 客户端
public class ChainOfResponsibilityClient {
public static void main(String[] args) {
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
handler1.setNextHandler(handler2);
handler1.handleRequest(5);
handler1.handleRequest(15);
}
}
命令模式代码示例：
// 命令接口
interface Command {
void execute();
}
// 接收者
class Receiver {
public void action(int request) {
System.out.println("执行操作: " + request);
}
}
// 具体命令类
class ConcreteCommand implements Command {
private Receiver receiver;
private int request;
public ConcreteCommand(Receiver receiver, int request) {
this.receiver = receiver;
this.request = request;
}
@Override
public void execute() {
receiver.action(request);
}
}
// 调用者
class Invoker {
private Command command;
public Invoker(Command command) {
this.command = command;
}
public void executeCommand() {
command.execute();
}
}
// 客户端
public class CommandClient {
public static void main(String[] args) {
Receiver receiver = new Receiver();
Command command1 = new ConcreteCommand(receiver, 5);
Command command2 = new ConcreteCommand(receiver, 15);
Invoker invoker
七、总结
命令模式作为一种重要的行为型设计模式，在Java编程领域中占据着独特的地位。它将请求封装成对象，巧妙地实现了请求发送者与接收者之间的解耦，这种设计理念极大地提升了系统的灵活性和可维护性。
从结构上看，命令模式由命令接口、具体命令类、接收者、调用者和客户端这几个关键角色构成。命令接口定义了统一的执行方法，为具体命令类提供了规范；具体命令类实现了命令接口，持有接收者对象并调用其方法来完成具体操作；接收者负责执行实际的业务逻辑；调用者通过调用命令对象的执行方法来触发请求；客户端则负责创建具体命令对象并将其与接收者和调用者进行关联。这种清晰的结构使得命令模式在各种场景中都能有条不紊地发挥作用。
在实际应用中，命令模式有着广泛的使用场景。在GUI开发中，按钮和菜单操作可以通过命令模式进行封装，实现界面与业务逻辑的解耦，同时方便实现撤销和重做等功能；在事务性系统中，命令模式能够很好地支持可撤销操作，确保系统的一致性和可靠性；宏命令的应用则允许将多个操作组合成一个操作，提高了操作的效率和便捷性；在任务队列系统中，命令模式使得命令可以被加入队列中，实现延迟执行或异步执行，满足了不同场景下的任务处理需求。
通过Java代码示例，我们直观地展示了命令模式的实现过程。从简单的遥控器控制灯的示例，到支持撤销操作的遥控器系统，再到图形编辑软件中的宏命令示例，逐步深入地体现了命令模式的灵活性和强大功能。这些示例不仅帮助我们理解了命令模式的工作原理，也为在实际项目中应用命令模式提供了参考。
命令模式具有诸多优点，如降低耦合度，使得系统各组件之间的依赖关系更加松散，便于独立开发和维护；扩展性强，符合开闭原则，能够轻松应对新功能的添加；支持撤销与重做操作，为用户提供了更加友好和灵活的操作体验；可以组合复杂操作，通过宏命令实现一系列操作的封装和执行。然而，命令模式也存在一些缺点，例如命令类数量可能会随着系统功能的增加而大量增多，导致系统结构变得复杂，增加了代码的管理和维护难度；在一些简单场景下，使用命令模式可能会带来不必要的复杂性和冗余性，增加了实现成本。
与其他设计模式相比，命令模式与策略模式、观察者模式、责任链模式等在意图、使用场景和实现方式上都存在明显的区别。了解这些区别，有助于我们在实际开发中根据具体需求选择最合适的设计模式，以达到最佳的设计效果。
命令模式为Java开发者提供了一种强大的工具，能够有效地解决许多实际问题。在软件开发过程中，我们应充分理解命令模式的原理和应用场景，合理运用该模式，以提高软件的质量和可维护性，为用户提供更加优质的软件产品。