命令模式完成李云龙对意大利炮的指挥

前言

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

命令模式的主要优点如下。

1. 通过引入中间件（抽象接口）降低系统的耦合度。
2. 扩展性良好，增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类，且满足“开闭原则”。

其缺点是：

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

过程

1. 创建抽象的兵种命令，用于不同兵种的实现；因为不同兵种开火的方式不同，使用的武器也不同

   /**
    * 兵种的抽象命令
    * 不同兵种处理不同的命令
    * 如 炮兵负责开炮、骑兵负责冲锋
    *
    * @author MinWeikai
    * @date 2021/8/23 14:33
    */
   public interface ArmsCommand {
   
       /**
        * 执行的抽象方法
        */
       void execute();
   
   }
   

2. 创建指挥官调用者，用于调用命令

   /**
    * 首长调用者
    *
    * @author MinWeikai
    * @date 2021/8/23 14:35
    */
   public class HeadInvoker {
   
       public HeadInvoker(String name) {
           this.name = name;
       }
   
       /**
        * 调用者姓名
        */
       private String name;
   
       /**
        * 开火方法，用于调用命令
        *
        * @param command
        */
       public void fire(ArmsCommand command) {
           System.out.println("指挥者：" + name + "发出命令");
           command.execute();
       }
   }
   

3. 士兵接收者负责接收命令去执行（因为独立团是全能精英，所以骑兵、炮兵都是同种接收者）；如果业务复杂可抽象接收者去实现

   /**
    * 士兵接收者
    *
    * @author MinWeikai
    * @date 2021/8/23 14:42
    */
   public class SoldierReceiver {
   
       public SoldierReceiver(String name) {
           this.name = name;
       }
   
       private String name;
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public void action(String msg) {
           System.out.println("士兵：" + this.getName() + "接收者已执行-" + msg);
       }
   }
   

4. 创建炮兵兵种的命令，负责指挥士兵开炮

   /**
    * 炮兵命令
    *
    * @author MinWeikai
    * @date 2021/8/23 14:40
    */
   public class ArtilleryCommand implements ArmsCommand {
   
       public ArtilleryCommand(SoldierReceiver soldierReceiver) {
           this.soldierReceiver = soldierReceiver;
       }
   
       /**
        * 命令接收处理者
        */
       private SoldierReceiver soldierReceiver;
   
       @Override
       public void execute() {
           System.out.println(soldierReceiver.getName() + "，你他娘的意大利炮呢？");
           soldierReceiver.action("开炮！");
       }
   
   }
   

5. 创建测试方法去执行

   /**
    * @author MinWeikai
    * @date 2021/8/23 15:50
    */
   public class ArmsCommandTest {
   
       public static void main(String[] args) {
           // 指挥者李云龙
           HeadInvoker invoker = new HeadInvoker("李云龙");
           // 发出了炮兵命令，由二营长进行
           ArmsCommand command = new ArtilleryCommand(new SoldierReceiver("二营长"));
           // 调用了开火方法
           invoker.fire(command);
           System.out.println("-------------------------------------------------");
           // 指挥者孔二愣子
           invoker = new HeadInvoker("孔二愣子");
           // 发出了炮兵命令，由一营长进行
           ArmsCommand command1 = new ArtilleryCommand(new SoldierReceiver("一营长"));
           // 调用了开火方法
           invoker.fire(command1);
           System.out.println("-------------------------------------------------");
           // 指挥者
           invoker = new HeadInvoker("孙德胜");
           ArmsCommand command2 = new CavalryCommand(new SoldierReceiver("众骑兵"));
           invoker.fire(command2);
   
       }
   }
   

总结

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

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

1. 请求调用者需要与请求接收者解耦时，命令模式可以使调用者和接收者不直接交互。
2. 系统随机请求命令或经常增加、删除命令时，命令模式可以方便地实现这些功能。

资料

参考http://c.biancheng.net/view/1380.html

我的命令模式代码示例地址