案例

1) 我们买了一套智能家电，有照明灯、风扇、冰箱、洗衣机，我们只要在手机上安装app就
可以控制对这些家电工作。
2) 这些智能家电来自不同的厂家，我们不想针对每一种家电都安装一个App，分别控制， 我
们希望只要一个app就可以控制全部智能家电。
3) 要实现一个app控制所有智能家电的需要，则每个智能家电厂家都要提供一个统一的接口
给app调用， 这时 就可以考虑使用命令模式。
4) 命令模式可将“动作的请求者”从“动作的执行者”对象中解耦出来.
5) 在我们的例子中，动作的请求者是手机app，动作的执行者是每个厂商的一个家电产品

命令模式

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

命令模式使得请求发送者与请求接收者之前消除彼此之间的耦合。

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

Invoker 调用者
Receiver 接收者
MyCommand 命令 实现了Command接口，持有接收 对象

image.png
、
Invoker 调用者
Command 命令角色 需要执行的命令都在这，可以视接口或者抽象类
Receiver 接收者， 知道如何实施和执行一个请求相关的操作
ConCreateCommand 将一个接收者与一个动作绑定，调用接收者相关的操作，实现excute

案例uml

image.png

  1. //创建命令接口
  2. public interface Command {
  4.     //执行动作(操作)
  5.     public void execute();
  6.     //撤销动作(操作)
  7.     public void undo();
  8. }
  11. public class LightOffCommand implements Command {
  13.     // 聚合LightReceiver
  15.     LightReceiver light;
  17.     // 构造器
  18.     public LightOffCommand(LightReceiver light) {
  19.             super();
  20.             this.light = light;
  21.         }
  23.     @Override
  24.     public void execute() {
  25.         // TODO Auto-generated method stub
  26.         // 调用接收者的方法
  27.         light.off();
  28.     }
  30.     @Override
  31.     public void undo() {
  32.         // TODO Auto-generated method stub
  33.         // 调用接收者的方法
  34.         light.on();
  35.     }
  36. }
  39. public class LightOnCommand implements Command {
  41.     //聚合LightReceiver
  43.     LightReceiver light;
  45.     //构造器
  46.     public LightOnCommand(LightReceiver light) {
  47.         super();
  48.         this.light = light;
  49.     }
  51.     @Override
  52.     public void execute() {
  53.         // TODO Auto-generated method stub
  54.         //调用接收者的方法
  55.         light.on();
  56.     }
  60.     @Override
  61.     public void undo() {
  62.         // TODO Auto-generated method stub
  63.         //调用接收者的方法
  64.         light.off();
  65.     }
  67. }
  70. public class LightReceiver {
  72.     public void on() {
  73.         System.out.println(" 电灯打开了.. ");
  74.     }
  76.     public void off() {
  77.         System.out.println(" 电灯关闭了.. ");
  78.     }
  79. }
  3. /**
  4.  * 没有任何命令，即空执行: 用于初始化每个按钮, 当调用空命令时，对象什么都不做
  5.  * 其实，这样是一种设计模式, 可以省掉对空判断
  6.  * @author Administrator
  7.  *
  8.  */
  9. public class NoCommand implements Command {
  11.     @Override
  12.     public void execute() {
  13.         // TODO Auto-generated method stub
  15.     }
  17.     @Override
  18.     public void undo() {
  19.         // TODO Auto-generated method stub
  21.     }
  23. }
  1. public class RemoteController {
  3.     // 开 按钮的命令数组
  4.     Command[] onCommands;
  5.     Command[] offCommands;
  7.     // 执行撤销的命令
  8.     Command undoCommand;
  10.     // 构造器，完成对按钮初始化
  12.     public RemoteController() {
  14.         onCommands = new Command[5];
  15.         offCommands = new Command[5];
  17.         for (int i = 0; i < 5; i++) {
  18.             onCommands[i] = new NoCommand();
  19.             offCommands[i] = new NoCommand();
  20.         }
  21.     }
  23.     // 给我们的按钮设置你需要的命令
  24.     public void setCommand(int no, Command onCommand, Command offCommand) {
  25.         onCommands[no] = onCommand;
  26.         offCommands[no] = offCommand;
  27.     }
  29.     // 按下开按钮
  30.     public void onButtonWasPushed(int no) { // no 0
  31.         // 找到你按下的开的按钮， 并调用对应方法
  32.         onCommands[no].execute();
  33.         // 记录这次的操作，用于撤销
  34.         undoCommand = onCommands[no];
  36.     }
  38.     // 按下开按钮
  39.     public void offButtonWasPushed(int no) { // no 0
  40.         // 找到你按下的关的按钮， 并调用对应方法
  41.         offCommands[no].execute();
  42.         // 记录这次的操作，用于撤销
  43.         undoCommand = offCommands[no];
  45.     }
  47.     // 按下撤销按钮
  48.     public void undoButtonWasPushed() {
  49.         undoCommand.undo();
  50.     }
  52. }
public static void main(String[] args) {
        // TODO Auto-generated method stub

        //使用命令设计模式，完成通过遥控器，对电灯的操作

        //创建电灯的对象(接受者)
        LightReceiver lightReceiver = new LightReceiver();

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

        //需要一个遥控器
        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();



    }

注意事项

将发起请求的对象和执行请求的对象解耦。发起请求的对象是调用者，调用者只需要调用对象的execute（）方法就可以让接收者工作，而不必知道具体接收者对象如何工作

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

不足：容易导致系统有过多的具体命令类

经典应用场景：界面的一个按钮都是一条命令，订单的撤销恢复，触发-反馈机制