JAVA设计模式(二十二)——命令行模式

1、命令行模式

        命令行也就是Command，Command模式是行为设计模式的一种。就像我们常常看到的命令行窗口一样，只要输入一个命令，就可以开启某种功能，明令行模式的定义就是：通过被称为Command的类封装了对目标对象的调用行为以及调用参数。这就是命令行模式，可以说是我们最常见的设计模式。

2、应用场景

        在面向对象的程序设计中，一个对象调用另一个对象，一般情况下的调用过程是：创建目标对象实例；设置调用参数；调用目标对象的方法。 但在有些情况下有必要使用一个专门的类对这种调用过程加以封装，我们把这种专门的类称作command类。

        整个调用过程比较繁杂，或者存在多处这种调用。这时，使用Command类对该调用加以封装，便于功能的再利用。

        调用前后需要对调用参数进行某些处理。

        调用前后需要进行某些额外处理，比如日志，缓存，记录历史操作等。

        比如我们每次说完一种设计模式，定义了他的角色，编写完相应代码之后，往往会再写一个测试类，命名为MainClass，然后通过这个类去调用其它的方法，这就是命令行模式了。

3、结构图示

4、角色职责

通过上门的图示，我们看到命令行模式主要有以下几种角色：

Command：Command抽象类。

ConcreteCommand：Command的具体实现类，通过该类的实现，我们调用各种方法。

Receiver：需要被调用的目标对象，比如我们常常使用的Person的doSomething()方法。

Invorker：通过Invorker执行Command对象。

5、源码示例

我们先来看看方法的封装类，等下我们会在Command抽象类中持有该对象，如下：

/**
 * 这里是一些方法的封装，对应调用
 * @author ljtyzhr
 *
 */
public class Peddler {  
  
    public void sailApple() {  
        System.out.println("您调用了卖苹果功能！！！");  
    }  
      
    public void sailBanana() {  
        System.out.println("猴子吃香蕉。");  
    }  
}

接下来是Command这个抽象类，抽象类主要是抽象方法，以及对一个方法封装类的引用，如下：

public abstract class Command {  
      
    private Peddler peddler;  
      
    public Command(Peddler peddler) {  
        this.peddler = peddler;  
    }  
  
    public abstract void sail();  
  
    public Peddler getPeddler() {  
        return peddler;  
    }  
  
    public void setPeddler(Peddler peddler) {  
        this.peddler = peddler;  
    }  
      
}

两个Command的实现类，表示分别调用不同的方法，如下：

public class AppleCommand extends Command {  
  
    public AppleCommand(Peddler peddler) {  
        super(peddler);  
    }  
  
    @Override  
    public void sail() {  
        this.getPeddler().sailApple();  
    }
} 

public class BananaCommand extends Command {  
	  
    public BananaCommand(Peddler peddler) {  
        super(peddler);  
    }  
  
    @Override  
    public void sail() {  
        this.getPeddler().sailBanana();  
    }  
} 

最后，我们看看Invorker，来执行Command的类，如下：

import java.util.ArrayList;  
import java.util.List;  

/**
 * 这里就是一个Invorker对象，我们通过它来实现命令的调用
 * @author ljtyzhr
 *
 */
public class Waiter {  
  
    private List<Command> commands = new ArrayList<Command>();  
  
    public List<Command> getCommands() {  
        return commands;  
    }  
  
    public void setCommands(List<Command> commands) {  
        this.commands = commands;  
    }  
      
    //添加订单项  
    public void setOrder(Command command) {  
        commands.add(command);  
    }  
      
    //删除订单项  
    public void remove(Command command) {  
        commands.remove(command);  
    }  
  
    public void sail() {  
        for(Command command : commands)  
            command.sail();  
    }  
} 

6、测试分析

测试代码，如下：

public class MainClass {  
  
    public static void main(String[] args) {  
        Peddler peddler = new Peddler();  
          
        Command appleCommand = new AppleCommand(peddler);  
        Command bananaCommand = new BananaCommand(peddler);  
          
        Waiter waiter = new Waiter();  
        waiter.setOrder(appleCommand);  
        waiter.setOrder(bananaCommand);  
        waiter.sail();  
          
        System.out.println("--------");  
          
        waiter.remove(appleCommand);  
        waiter.sail();  
    }  
}

结果分析：

您调用了卖苹果功能！！！
猴子吃香蕉。
--------
猴子吃香蕉。

7、模式总结

        命令行模式把一个请求或者操作封装到一个对象中。

        命令行模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。命令模式允许请求的一方和发送的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否执行，何时被执行以及是怎么被执行的。系统支持命令的撤消。