命令模式

Encapsulate a request as object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

命令模式的通用类图

命令模式的通用源码

• 抽象接受者类

  public abstract class AbstractReceiver {
  
      //抽象接受者定义每个具体接受者都要完成的任务
      public abstract void doSomething();
  }
  

• 具体接受者类1

  public class ConcreteReceiver1 extends AbstractReceiver{
  
      @Override
      public void doSomething() {
          System.out.println("HelloWorld");
      }
  }
  

• 具体接受者类2

  public class ConcreteReceicer2 extends AbstractReceiver {
  
      @Override
      public void doSomething() {
  
      }
  }
  

• 抽象命令类

  public abstract class AbstractCommand {
  
      //每一个命令类都必须有一个执行命令的方法
      public abstract void execute();
  }
  

• 具体命令类1

  public class ConcreteCommand1 extends AbstractCommand {
  
      //对哪个AbstractReceiver类进行命令处理
      private AbstractReceiver receiver;
  
      //构造函数传递接受者
      public ConcreteCommand1(AbstractReceiver _receiver) {
          this.receiver = _receiver;
      }
  
      @Override
      public void execute() {
          this.receiver.doSomething();
      }
  }
  

• 具体命令类2

  public class ConcreteCommand2 extends AbstractCommand {
  
      //对哪个AbstractRecevier类进行处理
      private AbstractReceiver receiver;
  
      //构造函数用于传递接受者
      public ConcreteCommand2(AbstractReceiver _recevier) {
          this.receiver = _recevier;
      }
  
      @Override
      public void execute() {
          this.receiver.doSomething();
      }
  }
  

• 调用者类

  public class Invoker {
  
      //什么命令
      private AbstractCommand command;
  
      //接受命令
      public void setCommand(AbstractCommand _command) {
          this.command = _command;
      }
  
      //执行命令
      public void action() {
          this.command.execute();
      }
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
  
          //声明一个接头人（调用者）
          Invoker invoker = new Invoker();
          //定义接受者
          AbstractReceiver receiver = new ConcreteReceiver1();
          //定义一个发送给接受者的命令
          AbstractCommand command = new ConcreteCommand1(receiver);
          //把命令交个接头人
          invoker.setCommand(command);
          //接头人执行mingling
          invoker.action(); //其实是接受者执行的命令
      }
  }
  

命令模式的优点

• 类间解耦。调用者角色与接收者角色之间没有任何依赖关系，调用者实现功能时只需要调用AbstractCommand类execute()就可以，不需要了解到底是哪个接收者执行。
• 可扩展性。AbstractCommand的子类可以可以非常容易地扩展，二调用者Invoker和高层的模块Client不会产生严重的代码耦合。
• 命令模式结合其他模式会更加优秀。结合责任链模式，实现命令族解析任务；结合模板方法模式，则可以减少AbstractCommand子类的膨胀问题。

命令模式的缺点

• 如果AbstractCommand的子类有N个命令，则其子类就有N个，膨胀非常大。

命令模式的使用场景

• GUI开发中，添加按钮可以理解为是一个命令。
• 模式DOS命令的时候。

命令模式的简单使用的类图及源码

• 抽象组类（抽象接受者类）

  public abstract class Group {
  
      //甲乙双方分开办公，如果甲方需要和乙方某个组讨论，首先需要找到这个组
      public abstract void find();
      //被要求增加功能
      public abstract void add();
      //被要求删除功能
      public abstract void delete();
      //被要求修改功能
      public abstract void change();
      //被要求给出所有的变更计划
      public abstract void plan();
  }
  

• 需求组类（具体接受者类1）

  public class RequirmentGroup extends Group {
  
      @Override
      public void find() {
          System.out.println("找到需求组");
      }
  
      @Override
      public void add() {
          System.out.println("客户要求增加一项需求");
      }
  
      @Override
      public void delete() {
          System.out.println("客户要求修改一项需求");
      }
  
      @Override
      public void change() {
          System.out.println("客户要求删除一项需求");
      }
  
      @Override
      public void plan() {
          System.out.println("客户要求变更需求计划");
      }
  }
  

• 美工组类（具体接受者类2）

  public class PageGroup extends Group {
  
      @Override
      public void find() {
          System.out.println("找到美工组");
      }
  
      @Override
      public void add() {
          System.out.println("客户要求增加一项页面");
      }
  
      @Override
      public void delete() {
          System.out.println("客户要求修改一项页面");
      }
  
      @Override
      public void change() {
          System.out.println("客户要求删除一项页面");
      }
  
      @Override
      public void plan() {
          System.out.println("客户要求变更页面计划");
      }
  }
  

• 代码组类（具体接受者类3）

  public class CodeGroup extends Group {
  
      @Override
      public void find() {
          System.out.println("找到代码组");
      }
  
      @Override
      public void add() {
          System.out.println("客户要求增加一项功能");
      }
  
      @Override
      public void delete() {
          System.out.println("客户要求修改一项功能");
      }
  
      @Override
      public void change() {
          System.out.println("客户要求删除一项功能");
      }
  
      @Override
      public void plan() {
          System.out.println("客户要求变更功能计划");
      }
  }
  

• 抽象命令类

  public class DeletePageCommand extends Command {
  
      @Override
      public void execute() {
          super.pg.find();
          super.pg.delete();
          super.pg.plan();
      }
  }
  

• 具体命令类1

  public class AddRequirementCommand extends Command {
  
      @Override
      public void execute() {
          super.rg.find();
          super.rg.add();
          super.rg.plan();
      }
  }
  

• 具体命令类2

  public class DeletePageCommand extends Command {
  
      @Override
      public void execute() {
          super.pg.find();
          super.pg.delete();
          super.pg.plan();
      }
  }
  

• 调用者类（接头人）

  public class Invoker {
  
      //什么命令
      private Command command;
  
      //客户发出什么命令，接头人接受什么命令
      public void setCommand(Command command) {
          this.command = command;
      }
  
      //接头人执行什么的命令
      public void action() {
          this.command.execute();
      }
  }
  

• 场景类

  public class Client {
  
      public static void main(String[] args) {
          //定义接头人
          Invoker invoker = new Invoker();
          //客户要求增加一项需求
          System.out.println("客户要求增加一项需求 ------------>");
          //客户给我们下命令
          Command command = new AddRequirementCommand();
          //接头人接受到命令
          invoker.setCommand(command);
          //接头人执行命令
          invoker.action();
      }
  }