1、原由

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

在现实生活中，命令模式的例子也很多。比如看电视时，我们只需要轻轻一按遥控器就能完成频道的切换，这就是命令模式，将换台请求和换台处理完全解耦了。电视机遥控器（命令发送者）通过按钮（具体命令）来遥控电视机（命令接收者）。

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

2、定义

命令（Command）模式的定义如下：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通，这样方便将命令对象进行储存、传递、调用、增加与管理。

3、优点

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

4、缺点

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

5、结构

可以将系统中的相关操作抽象成命令，使调用者与实现者相关分离，其结构如下。
命令模式包含以下主要角色。

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


其结构图如图 1 所示。
image.png

6、实现

命令模式的代码如下：

  1. package command;
  3. public class CommandPattern {
  4.     public static void main(String[] args) {
  5.         Command cmd = new ConcreteCommand();
  6.         Invoker ir = new Invoker(cmd);
  7.         System.out.println("客户访问调用者的call()方法...");
  8.         ir.call();
  9.     }
  10. }
  12. //调用者
  13. class Invoker {
  14.     private Command command;
  16.     public Invoker(Command command) {
  17.         this.command = command;
  18.     }
  20.     public void setCommand(Command command) {
  21.         this.command = command;
  22.     }
  24.     public void call() {
  25.         System.out.println("调用者执行命令command...");
  26.         command.execute();
  27.     }
  28. }
  30. //抽象命令
  31. interface Command {
  32.     public abstract void execute();
  33. }
  35. //具体命令
  36. class ConcreteCommand implements Command {
  37.     private Receiver receiver;
  39.     ConcreteCommand() {
  40.         receiver = new Receiver();
  41.     }
  43.     public void execute() {
  44.         receiver.action();
  45.     }
  46. }
  48. //接收者
  49. class Receiver {
  50.     public void action() {
  51.         System.out.println("接收者的action()方法被调用...");
  52.     }
  53. }

程序的运行结果如下：
image.png

7、应用实例

1、用命令模式实现客户去餐馆吃早餐的实例

分析：客户去餐馆可选择的早餐有肠粉、河粉和馄饨等，客户可向服务员选择以上早餐中的若干种，服务员将客户的请求交给相关的厨师去做。这里的点早餐相当于“命令”，服务员相当于“调用者”，厨师相当于“接收者”，所以用命令模式实现比较合适。

  • 首先，定义一个早餐类（Breakfast），它是抽象命令类，有抽象方法 cooking()，说明要做什么；
  • 再定义其子类肠粉类（ChangFen）、馄饨类（HunTun）和河粉类（HeFen），它们是具体命令类，实现早餐类的 cooking() 方法，但它们不会具体做，而是交给具体的厨师去做；
  • 具体厨师类有肠粉厨师（ChangFenChef）、馄饨厨师（HunTunChef）和河粉厨师（HeFenChef），他们是命令的接收者。


由于本实例要显示厨师做菜的效果图（点此下载要显示的效果图），所以把每个厨师类定义为 JFrame 的子类；最后，定义服务员类（Waiter），它接收客户的做菜请求，并发出做菜的命令。客户类是通过服务员类来点菜的，图 2 所示是其结构图。
image.png
程序代码如下：

  1. package command;
  3. import javax.swing.*;
  5. public class CookingCommand {
  6.     public static void main(String[] args) {
  7.         Breakfast food1 = new ChangFen();
  8.         Breakfast food2 = new HunTun();
  9.         Breakfast food3 = new HeFen();
  10.         Waiter fwy = new Waiter();
  11.         fwy.setChangFen(food1);//设置肠粉菜单
  12.         fwy.setHunTun(food2);  //设置河粉菜单
  13.         fwy.setHeFen(food3);   //设置馄饨菜单
  14.         fwy.chooseChangFen();  //选择肠粉
  15.         fwy.chooseHeFen();     //选择河粉
  16.         fwy.chooseHunTun();    //选择馄饨
  17.     }
  18. }
  20. //调用者：服务员
  21. class Waiter {
  22.     private Breakfast changFen, hunTun, heFen;
  24.     public void setChangFen(Breakfast f) {
  25.         changFen = f;
  26.     }
  28.     public void setHunTun(Breakfast f) {
  29.         hunTun = f;
  30.     }
  32.     public void setHeFen(Breakfast f) {
  33.         heFen = f;
  34.     }
  36.     public void chooseChangFen() {
  37.         changFen.cooking();
  38.     }
  40.     public void chooseHunTun() {
  41.         hunTun.cooking();
  42.     }
  44.     public void chooseHeFen() {
  45.         heFen.cooking();
  46.     }
  47. }
  49. //抽象命令：早餐
  50. interface Breakfast {
  51.     public abstract void cooking();
  52. }
  54. //具体命令：肠粉
  55. class ChangFen implements Breakfast {
  56.     private ChangFenChef receiver;
  58.     ChangFen() {
  59.         receiver = new ChangFenChef();
  60.     }
  62.     public void cooking() {
  63.         receiver.cooking();
  64.     }
  65. }
  67. //具体命令：馄饨
  68. class HunTun implements Breakfast {
  69.     private HunTunChef receiver;
  71.     HunTun() {
  72.         receiver = new HunTunChef();
  73.     }
  75.     public void cooking() {
  76.         receiver.cooking();
  77.     }
  78. }
  80. //具体命令：河粉
  81. class HeFen implements Breakfast {
  82.     private HeFenChef receiver;
  84.     HeFen() {
  85.         receiver = new HeFenChef();
  86.     }
  88.     public void cooking() {
  89.         receiver.cooking();
  90.     }
  91. }
  93. //接收者：肠粉厨师
  94. class ChangFenChef extends JFrame {
  95.     private static final long serialVersionUID = 1L;
  96.     JLabel l = new JLabel();
  98.     ChangFenChef() {
  99.         super("煮肠粉");
  100.         l.setIcon(new ImageIcon("src/command/ChangFen.jpg"));
  101.         this.add(l);
  102.         this.setLocation(30, 30);
  103.         this.pack();
  104.         this.setResizable(false);
  105.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  106.     }
  108.     public void cooking() {
  109.         this.setVisible(true);
  110.     }
  111. }
  113. //接收者：馄饨厨师
  114. class HunTunChef extends JFrame {
  115.     private static final long serialVersionUID = 1L;
  116.     JLabel l = new JLabel();
  118.     HunTunChef() {
  119.         super("煮馄饨");
  120.         l.setIcon(new ImageIcon("src/command/HunTun.jpg"));
  121.         this.add(l);
  122.         this.setLocation(350, 50);
  123.         this.pack();
  124.         this.setResizable(false);
  125.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  126.     }
  128.     public void cooking() {
  129.         this.setVisible(true);
  130.     }
  131. }
  133. //接收者：河粉厨师
  134. class HeFenChef extends JFrame {
  135.     private static final long serialVersionUID = 1L;
  136.     JLabel l = new JLabel();
  138.     HeFenChef() {
  139.         super("煮河粉");
  140.         l.setIcon(new ImageIcon("src/command/HeFen.jpg"));
  141.         this.add(l);
  142.         this.setLocation(200, 280);
  143.         this.pack();
  144.         this.setResizable(false);
  145.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  146.     }
  148.     public void cooking() {
  149.         this.setVisible(true);
  150.     }
  151. }

程序的运行结果如图 2 所示:
image.png

8、应用场景

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

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

  1. 请求调用者需要与请求接收者解耦时，命令模式可以使调用者和接收者不直接交互。
  2. 系统随机请求命令或经常增加、删除命令时，命令模式可以方便地实现这些功能。
  3. 当系统需要执行一组操作时，命令模式可以定义宏命令来实现该功能。
  4. 当系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作时，可以将命令对象存储起来，采用备忘录模式来实现。

9、扩展

在软件开发中，有时将命令模式与前面学的组合模式联合使用，这就构成了宏命令模式，也叫组合命令模式。宏命令包含了一组命令，它充当了具体命令与调用者的双重角色，执行它时将递归调用它所包含的所有命令，其具体结构图如图 3 所示。
image.png
程序代码如下：

  1. package command;
  3. import java.util.ArrayList;
  5. public class CompositeCommandPattern {
  6.     public static void main(String[] args) {
  7.         AbstractCommand cmd1 = new ConcreteCommand1();
  8.         AbstractCommand cmd2 = new ConcreteCommand2();
  9.         CompositeInvoker ir = new CompositeInvoker();
  10.         ir.add(cmd1);
  11.         ir.add(cmd2);
  12.         System.out.println("客户访问调用者的execute()方法...");
  13.         ir.execute();
  14.     }
  15. }
  17. //抽象命令
  18. interface AbstractCommand {
  19.     public abstract void execute();
  20. }
  22. //树叶构件: 具体命令1
  23. class ConcreteCommand1 implements AbstractCommand {
  24.     private CompositeReceiver receiver;
  26.     ConcreteCommand1() {
  27.         receiver = new CompositeReceiver();
  28.     }
  30.     public void execute() {
  31.         receiver.action1();
  32.     }
  33. }
  35. //树叶构件: 具体命令2
  36. class ConcreteCommand2 implements AbstractCommand {
  37.     private CompositeReceiver receiver;
  39.     ConcreteCommand2() {
  40.         receiver = new CompositeReceiver();
  41.     }
  43.     public void execute() {
  44.         receiver.action2();
  45.     }
  46. }
  48. //树枝构件: 调用者
  49. class CompositeInvoker implements AbstractCommand {
  50.     private ArrayList<AbstractCommand> children = new ArrayList<AbstractCommand>();
  52.     public void add(AbstractCommand c) {
  53.         children.add(c);
  54.     }
  56.     public void remove(AbstractCommand c) {
  57.         children.remove(c);
  58.     }
  60.     public AbstractCommand getChild(int i) {
  61.         return children.get(i);
  62.     }
  64.     public void execute() {
  65.         for (Object obj : children) {
  66.             ((AbstractCommand) obj).execute();
  67.         }
  68.     }
  69. }
  71. //接收者
  72. class CompositeReceiver {
  73.     public void action1() {
  74.         System.out.println("接收者的action1()方法被调用...");
  75.     }
  77.     public void action2() {
  78.         System.out.println("接收者的action2()方法被调用...");
  79.     }
  80. }

程序的运行结果如下：
image.png
当然，命令模式还可以同备忘录（Memento）模式组合使用，这样就变成了可撤销的命令模式，这将在后面介绍。

10、进阶阅读