一聚教程网:一个值得你收藏的教程网站

热门教程

Android编程设计模式之命令模式详解

时间:2022-06-25 23:07:30 编辑:袖梨 来源:一聚教程网

本文实例讲述了Android编程设计模式之命令模式。分享给大家供大家参考,具体如下:

一、介绍

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

二、定义

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

三、使用场景

需要抽象出待执行的动作,然后以参数的形式提供出来——类似于过程设计中的回调机制,而命令模式正是回调机制的一个面向对象的替代品。

在不同的时刻指定、排列和执行请求。一个命令对象可以有与初始请求无关的生存期。

需要支持取消操作。

支持修改日志功能,这样当系统崩溃时,这些修改可以被重做一遍。

需要支持事务操作。

四、命令模式的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();
  }
}

角色介绍:

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

Command:命令角色,定义所有具体命令类的抽象接口。

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

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

Client:客户端类,Client可以创建具体的命令对象,并且设置命令对象的接收者。Tips:不能把Clinet理解为我们平常说的客户端,这里的Client是一个组装命令对象和接受者对象的角色,或者你把它理解为一个装配者。

五、简单实现

以推箱子游戏为例,一般游戏中会有五个按钮,分别是左移、右移、下移、上移和撤销。那么玩游戏的人就是客户端,五个按钮就是调用者,执行具体按钮命令的方法是命令角色。

接收者角色:

public class PushBox {
  /**
   * 执行向左命令
   */
  public void toLeft(){
    System.out.println("向左");
  }
  /**
   * 执行向右命令
   */
  public void toRight(){
    System.out.println("向右");
  }
  /**
   * 执行向下命令
   */
  public void toDown(){
    System.out.println("向下");
  }
  /**
   * 执行向上命令
   */
  public void toUp(){
    System.out.println("向上");
  }
  /**
   * 执行撤销命令
   */
  public void revoke(){
    System.out.println("撤销");
  }
}

抽象命令接口:

public interface Command {
  /**
   * 命令执行方法
   */
  void execute();
  /**
   * 获取命令类型
   */
  void getCommand();
}

具体命令者,左移命令类:

public class LeftCommand implements Command{
  //持有一个接受推箱子游戏对象的引用
  private PushBox pushBox;
  public LeftCommand(PushBox pushBox){
    this.pushBox = pushBox;
  }
  @Override
  public void execute() {
    //调用具体命令
    pushBox.toLeft();
  }
  @Override
  public void getCommand() {
    System.out.print("向左-->");
  }
}

具体命令者,右移命令类:

public class RightCommand implements Command{
  //持有一个接受推箱子游戏对象的引用
  private PushBox pushBox;
  public RightCommand(PushBox pushBox){
    this.pushBox = pushBox;
  }
  @Override
  public void execute() {
    //调用具体命令
    pushBox.toRight();
  }
  @Override
  public void getCommand() {
    System.out.print("向右-->");
  }
}

具体命令者,上移命令类:

public class UpCommand implements Command{
  //持有一个接受推箱子游戏对象的引用
  private PushBox pushBox;
  public UpCommand(PushBox pushBox){
    this.pushBox = pushBox;
  }
  @Override
  public void execute() {
    //调用具体命令
    pushBox.toUp();
  }
  @Override
  public void getCommand() {
    System.out.print("向上-->");
  }
}

具体命令者,下移命令类:

public class DownCommand implements Command{
  //持有一个接受推箱子游戏对象的引用
  private PushBox pushBox;
  public DownCommand(PushBox pushBox){
    this.pushBox = pushBox;
  }
  @Override
  public void execute() {
    //调用具体命令
    pushBox.toDown();
  }
  @Override
  public void getCommand() {
    System.out.print("向下-->");
  }
}

具体命令者,撤销命令类:

public class RevokeCommand implements Command{
  //持有一个接受推箱子游戏对象的引用
  private PushBox pushBox;
  public RevokeCommand(PushBox pushBox){
    this.pushBox = pushBox;
  }
  @Override
  public void execute() {
    //调用具体命令
    pushBox.revoke();;
  }
  @Override
  public void getCommand() {
  }
}

请求者类,命令由按钮发起:

public class Buttons {
  private LeftCommand leftCommand; //向左移动的命令对象引用
  private RightCommand rightCommand; //向右移动的命令对象引用
  private UpCommand upCommand; //向上移动的命令对象引用
  private DownCommand downCommand; //向下移动的命令对象引用
  private RevokeCommand revokeCommand; //撤销命令对象引用
  private ArrayList commandList = new ArrayList();//用于记录命令动作
  /**
   * 获取执行命令
   */
  public void getCommandList(){
    for(Command c : commandList){
      c.getCommand();
    }
    System.out.println("");
  }
  /**
   * 设置向左移动的命令对象
   *
   * @param leftCommand 向左移动的命令对象
   */
  public void setLeftCommand(LeftCommand leftCommand){
    this.leftCommand = leftCommand;
  }
  /**
   * 设置向右移动的命令对象
   *
   * @param rightCommand 向右移动的命令对象
   */
  public void setRightCommand(RightCommand rightCommand){
    this.rightCommand = rightCommand;
  }
  /**
   * 设置向上移动的命令对象
   *
   * @param upCommand 向上移动的命令对象
   */
  public void setUpCommand(UpCommand upCommand){
    this.upCommand = upCommand;
  }
  /**
   * 设置向下移动的命令对象
   *
   * @param downCommand 向下移动的命令对象
   */
  public void setDownCommand(DownCommand downCommand){
    this.downCommand = downCommand;
  }
  /**
   * 设置撤销命令对象
   *
   * @param revokeCommand 撤销命令对象
   */
  public void setRevokeCommand(RevokeCommand revokeCommand){
    this.revokeCommand = revokeCommand;
  }
  /**
   * 按下向左按钮
   */
  public void toLeft(){
    leftCommand.execute();
    commandList.add(leftCommand);
  }
  /**
   * 按下向右按钮
   */
  public void toRight(){
    rightCommand.execute();
    commandList.add(rightCommand);
  }
  /**
   * 按下向上按钮
   */
  public void toUp(){
    upCommand.execute();
    commandList.add(upCommand);
  }
  /**
   * 按下向下按钮
   */
  public void toDown(){
    downCommand.execute();
    commandList.add(downCommand);
  }
  /**
   * 按下撤销按钮
   */
  public void toRevoke(){
    revokeCommand.execute();
    commandList.remove(commandList.size()-1);
  }
}

客户端调用:

public class Client {
  public static void main(String[] args) {
    //首先创建游戏
    PushBox pushBox = new PushBox();
    //根据游戏构造5种命令
    LeftCommand leftCommand = new LeftCommand(pushBox);
    RightCommand rightCommand = new RightCommand(pushBox);
    UpCommand upCommand = new UpCommand(pushBox);
    DownCommand downCommand = new DownCommand(pushBox);
    RevokeCommand revokeCommand = new RevokeCommand(pushBox);
    //按钮可以执行不同命令
    Buttons buttons = new Buttons();
    buttons.setLeftCommand(leftCommand);
    buttons.setRightCommand(rightCommand);
    buttons.setUpCommand(upCommand);
    buttons.setDownCommand(downCommand);
    buttons.setRevokeCommand(revokeCommand);
    //执行操作
    buttons.toLeft();
    buttons.toDown();
    buttons.toDown();
    buttons.toRight();
    buttons.getCommandList();
    buttons.toRevoke();
    buttons.toUp();
    buttons.toLeft();
    buttons.toDown();
    buttons.toUp();
    buttons.getCommandList();
  }
}

执行结果:

向左
向下
向下
向右
向左-->向下-->向下-->向右-->
撤销
向上
向左
向下
向上
向左-->向下-->向下-->向上-->向左-->向下-->向上-->

在这么长的代码之后是不是觉得很烦琐,明明可以很简单的实现,如下:

public class Client {
  public static void main(String[] args) {
    //首先创建游戏
    PushBox pushBox = new PushBox();
    pushBox.toDown();
    pushBox.toRight();
    pushBox.toUp();
  }
}

其实设计模式有一个重要的原则:对修改关闭对扩展开放。如果使用如上的简单方式,那么以后的修改只能去修改PushBox类,然后修改Client类,这显然违反了这一原则。如果使用命令模式,那么Client类无需修改,只需要修改PushBox类的内部操作,Client类无需知道具体的内部实现。

六、Android源码中的命令模式

1、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也是一个抽象命令者。

七、总结

优点:

命令模式的封装性很好,更弱的耦合性,更灵活的控制性以及更好的扩展性。

缺点:

类的膨胀,大量衍生类的创建。

热门栏目