设计模式——命令模式

一 介绍

命令模式（Command Pattern），是行为型设计模式之一。命令模式相对于其他的设计模式来说并没有那么多的条条框框，其实它不是一个很”规范“的模式，不过，就是基于这一点，命令模式相对于其他的设计模式更为灵活多变。我们接触比较多的命令模式个例无非就是程序菜单命令，如在操作系统中，我们点击”关机“命令，系统就会执行一系列的操作，如先是暂停处理事件，保存系统的一些配置，然后结束程序进程，最后调用内核命令关闭计算机等，对于这一系列的命令，用户不用去管，用户只需点击系统的关机按钮即可完成如上一系列的命令。而我们的命令模式其实也与之相同，将一系列的方法调用封装，用户只需调用一个方法执行，那么所有这些被封装的方法就会被挨个执行调用。

二 定义

将一个请求封装成一个对象，从而让用户使用不同的请求把客户端参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。

三 使用场景

1. 需要抽象出待执行的动作，然后以参数的形式提供出来——类似于过程设计中的回调机制，而命令模式正是回调机制的一个面向对象的替代品。
2. 在不同的时刻指定、排列和执行请求。一个命令对象可以有与初始请求无关的生存期。
3. 需要支持取消操作。
4. 支持修改日志功能，这样当系统崩溃时，这些修改可以被重做一遍。
5. 需要支持事务操作。

四 命令模式的UML类图

UML类图：

通用模式代码：

接收者类：

public class Receiver {
  /*
   * 真正执行具体命令逻辑的方法
   */
  public void action(){
    System.out.println("具体执行");
  }
}

抽象命令接口：

public interface Command {
  /*
   * 执行具体操作的命令
   */
  void excute();
}

具体命令类：

public class ConcreteCommand implements Command {
  private Receiver receiver;
  public ConcreteCommand(Receiver receiver) {
    this.receiver = receiver;
  }
  @Override
  public void excute() {
    //调用接收者的相关方法来执行具体逻辑
    receiver.action();
  }
}

请求者类：

public class Invoker {
  private Command command;
  public Invoker(Command command) {
    this.command = command;
  }
  public void action(){
    //调用具体命令对象的相关方法，执行具体命令
    command.excute();
  }
}

客户类：

public class Client {
  public static void main(String[] args) {
    //构造一个接收者对象
    Receiver receiver = new Receiver();
    //根据接收者对象构造一个命令对象
    Command command = new ConcreteCommand(receiver);
    //根据具体的对象构造请求者对象
    Invoker invoker = new Invoker(command);
    //执行请求方法
    invoker.action();
  }
}

1. Receiver：接收者角色，该类负责具体实施或执行一个请求，说得通俗点就是，执行具体逻辑的角色，以本节开头的”关机“命令操作为例，其接收者角色就是真正执行各项关机逻辑的底层代码。任何一个类都可以成为一个接收者，而在接收者类中封装具体操作逻辑的方法我们则称为行动方法

2. Command：命令角色，定义所有具体命令类的抽象接口。

3. ConcreteCommand：具体命令角色，该类实现了Command接口，在execute方法中调用接收者角色的相关方法，在接收者和命令执行的具体行为之间加以弱耦合。而execute则通常称为执行方法，如本文开头所述”关机“的操作实现，具体可能还包含很多相关的操作，比如保存数据、关闭文件、结束进程等，如果将这一系列具体的逻辑处理看作接收者，那么调用这些具体逻辑的方法就可以看作是执行方法。

4. Invoker：请求者角色，该类的职责就是调用命令对象执行具体的请求，相关的方法我们称为行动方法，还是用”关机“为例，”关机“这个菜单命令一般就对应一个关机方法，我们点击了”关机“命令后，由这个关机方法去调用具体的命令执行具体的逻辑，这里的”关机“对应的这个方法就可以看作是请求者

五 代码实例

5.1 接收者：Machine

class Machine {
fun toleft(){
Log.d(“jack”,“向左转”)
}
fun toright(){
Log.d(“jack”,“向右转”)
}
fun totop(){
Log.d(“jack”,“向上转”)
}
fun toBottom(){
Log.d(“jack”,“向下转”)
}
}

5.2 命令抽象和具体实现：

 interface Command {
     var machine:Machine
    fun execute()
}

class LeftCommand(override var machine: Machine) : Command {

    override fun execute() {
        machine.toleft()
    }
}

class RightCommand(override var machine: Machine) : Command {

    override fun execute() {
        machine.toright()
    }
}
class TopCommand(override var machine: Machine) : Command {

    override fun execute() {
        machine.totop()
    }
}

class BottomCommand(override var machine: Machine) : Command {

    override fun execute() {
        machine.toBottom()
    }
}

5.3 请求者角色：

class Buttons {


    var leftCommand:LeftCommand?=null
    var rightCommand:RightCommand?=null
    var topCommand:TopCommand?=null
    var BottomCommand:BottomCommand?=null

    fun toleft(){
       leftCommand?.execute()
    }
    fun toright(){
        rightCommand?.execute()
    }
    fun totop(){
        topCommand?.execute()
  }
     fun toBottom(){
        BottomCommand?.execute()
    }
 }

5.4 客户发起请求下达命令：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

     var machine = Machine()
     var buttons = Buttons()
    buttons.leftCommand = LeftCommand(machine)
    buttons.rightCommand = RightCommand(machine)
    buttons.topCommand = TopCommand(machine)
    buttons.BottomCommand = BottomCommand(machine)

    buttons.toleft()
    buttons.toright()
    buttons.totop()
    buttons.toBottom()

}

5.5 结果

2022-09-01 18:20:32.955 2261-2261/com.luojie.myapplication D/jack: 向左转
2022-09-01 18:20:32.955 2261-2261/com.luojie.myapplication D/jack: 向右转
2022-09-01 18:20:32.955 2261-2261/com.luojie.myapplication D/jack: 向上转
2022-09-01 18:20:32.955 2261-2261/com.luojie.myapplication D/jack: 向下转

六 Android源码中的应用

1. Android事件机制中底层逻辑对事件的转发处理，命令请求者是InputDispather，命令抽象和实现是NotiftyArgs和NotifyKeyArgs，至于接收者则是android底层的硬件设备了
2. PackageHandler：
   PackageManagerService中，其对包的相关消息处理由其内部类PackageHandler承担，其将需要处理的请求作为对象通过消息传递给相关的方法，而对于包的安装、移动以及包大小的测量则分别封装为HandlerParams的具体子类InstallParams、MoveParams和MeasureParams。

private abstract class HandlerParams {
    private static final int MAX_RETRIES = 4;
    /**
     * Number of times startCopy() has been attempted and had a non-fatal
     * error.
     */
    private int mRetries = 0;
    final boolean startCopy() {
      boolean res;
      try {
        if (DEBUG_INSTALL) Slog.i(TAG, "startCopy");
        if (++mRetries > MAX_RETRIES) {
          Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up");
          mHandler.sendEmptyMessage(MCS_GIVE_UP);
          handleServiceError();
          return false;
        } else {
          handleStartCopy();
          res = true;
        }
      } catch (RemoteException e) {
        if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
        mHandler.sendEmptyMessage(MCS_RECONNECT);
        res = false;
      }
      handleReturnCode();
      return res;
    }
    final void serviceError() {
      if (DEBUG_INSTALL) Slog.i(TAG, "serviceError");
      handleServiceError();
      handleReturnCode();
    }
    abstract void handleStartCopy() throws RemoteException;
    abstract void handleServiceError();
    abstract void handleReturnCode();
}

可以看出HandlerParams也是一个命令者。

七 总结

1. 优点：命令模式的封装性很好，更弱的耦合性，更灵活的控制性以及更好的扩展性。
2. 缺点：类的膨胀，大量衍生类的创建。