影落离风

The shadow falls away from the wind

0%

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

前言

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

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

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

其缺点是:

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

过程

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /**
    * 兵种的抽象命令
    * 不同兵种处理不同的命令
    * 如 炮兵负责开炮、骑兵负责冲锋
    *
    * @author MinWeikai
    * @date 2021/8/23 14:33
    */
    public interface ArmsCommand {

    /**
    * 执行的抽象方法
    */
    void execute();

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28

    /**
    * 首长调用者
    *
    * @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. 士兵接收者负责接收命令去执行(因为独立团是全能精英,所以骑兵、炮兵都是同种接收者);如果业务复杂可抽象接收者去实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    /**
    * 士兵接收者
    *
    * @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. 创建炮兵兵种的命令,负责指挥士兵开炮

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    /**
    * 炮兵命令
    *
    * @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. 创建测试方法去执行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    /**
    * @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

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