设计模式14---设计模式之命令模式（Command）（行为型）

1.场景模拟

请用软件模拟开机过程
按下启动按钮

然后电源供电

主板开始加电自检

BIOS依次寻找其他设备的BIOS并且让他们初始化自检

开始检测CPU，内存，光盘，硬盘，光驱，串口，并口，软驱即插即用设备

进入系统引导

上面的过程可以抽象为如下：

客户端只是想要发出命令或者请求，不关心请求的真正接受者是谁，也不关心具体如何实现，而且同一个请求的动作可以有不同的请求内容，当然具体的处理功能也不一样。请问如何实现呢？

2.使用命令模式来解决问题

2.1命令模式定义

将一个请求封装为一个对象，从而是你可以用不同的请求对客户进行参数化，队请求排队或者请求日志，以及支持可撤销的操作。

2.2命令模式的结构图

在命令模式中，会定义一个命令的接口，用来约束所有的命令对象，然后提供具体的命令实现，每个命令实现对象是对客户端某个请求的封装，对应于机箱上的按钮，一个机箱上可以有很多按钮，也就相当于会有多个具体的命令实现对象。在命令模式中，命令对象并不知道如何处理命令，会有相应的接受者对象来真正执行命令。

3.命令模式示例代码详解

3.1命令接口，声明执行的操作

package demo12.command.example1;
/**
* 命令接口，声明执行的操作
*/
public interface Command {
/**
* 执行命令对应的操作
*/
public void execute();
}

3.2具体的命令实现对象

package demo12.command.example1;
/**
* 具体的命令实现对象
*/
public class ConcreteCommand implements Command {
/**
* 持有相应的接受者对象
*/
private Receiver receiver = null;
/**
* 示意，命令对象可以有自己的状态
*/
private String state;
/**
* 构造方法，传入相应的接受者对象
* @param receiver 相应的接受者对象
*/
public ConcreteCommand(Receiver receiver){
this.receiver = receiver;
}

public void execute() {
//通常会转调接受者对象的相应方法，让接受者来真正执行功能
receiver.action();
}
}

3.3接收者对象

package demo12.command.example1;
/**
* 接收者对象
*/
public class Receiver {
/**
* 示意方法，真正执行命令相应的操作
*/
public void action(){
//真正执行命令操作的功能代码
}
}

3.4调用者对象

package demo12.command.example1;
/**
* 调用者
*/
public class Invoker {
/**
* 持有命令对象
*/
private Command command = null;
/**
* 设置调用者持有的命令对象
* @param command 命令对象
*/
public void setCommand(Command command) {
this.command = command;
}
/**
* 示意方法，要求命令执行请求
*/
public void runCommand() {
//调用命令对象的执行方法
command.execute();
}
}

3.5客户端使用

package demo12.command.example1;

public class Client {
/**
* 示意，负责创建命令对象，并设定它的接受者
*/
public void assemble() {
// 创建接受者
Receiver receiver = new Receiver();
// 创建命令对象，设定它的接收者
Command command = new ConcreteCommand(receiver);
// 创建Invoker，把命令对象设置进去
Invoker invoker = new Invoker();
invoker.setCommand(command);
}
}

4.使用命令模式来实现场景中的问题

4.1代码示例结构图

机箱上的按钮就相当于命令对象
机箱相当于调用者

主板相当于接受者对象

命令对象持有一个接受者对象，相当于给机箱的按钮连了一根连接线

当机箱上的按钮被按下的时候，机箱就把这个命令通过连接线发送出去。

4.2定义主板接口

package demo12.command.example2;
/**
* 主板的接口
*/
public interface MainBoardApi {
/**
* 主板具有能开机的功能
*/
public void open();
}

4.3技嘉主板

package demo12.command.example2;
/**
* 技嘉主板类，开机命令的真正实现者，在Command模式中充当Receiver
*/
public class GigaMainBoard implements MainBoardApi{
/**
* 真正的开机命令的实现
*/
public void open(){
System.out.println("技嘉主板现在正在开机，请等候");
System.out.println("接通电源......");
System.out.println("设备检查......");
System.out.println("装载系统......");
System.out.println("机器正常运转起来......");
System.out.println("机器已经正常打开，请操作");
}
}

4.4命令接口

package demo12.command.example2;
/**
* 命令接口，声明执行的操作
*/
public interface Command {
/**
* 执行命令对应的操作
*/
public void execute();
}

4.5命令的具体实现

package demo12.command.example2;
/**
* 开机命令的实现，实现Command接口，
* 持有开机命令的真正实现，通过调用接收者的方法来实现命令
*/
public class OpenCommand implements Command{
/**
* 持有真正实现命令的接收者——主板对象
*/
private MainBoardApi mainBoard = null;
/**
* 构造方法，传入主板对象
* @param mainBoard 主板对象
*/
public OpenCommand(MainBoardApi mainBoard) {
this.mainBoard = mainBoard;
}

public void execute() {
//对于命令对象，根本不知道如何开机，会转调主板对象
//让主板去完成开机的功能
this.mainBoard.open();
}
}

4.6提供机箱

package demo12.command.example2;
/**
* 机箱对象，本身有按钮，持有按钮对应的命令对象
*/
public class Box {
/**
* 开机命令对象
*/
private Command openCommand;
/**
* 设置开机命令对象
* @param command 开机命令对象
*/
public void setOpenCommand(Command command){
this.openCommand = command;
}
/**
* 提供给客户使用，接受并相应用户请求，相当于按钮被按下触发的方法
*/
public void openButtonPressed(){
//按下按钮，执行命令
openCommand.execute();
}
}

4.7客户端使用

package demo12.command.example2;

public class Client {
public static void main(String[] args) {
//1：把命令和真正的实现组合起来，相当于在组装机器，
//把机箱上按钮的连接线插接到主板上。
MainBoardApi mainBoard = new GigaMainBoard();
OpenCommand openCommand = new OpenCommand(mainBoard);
//2：为机箱上的按钮设置对应的命令，让按钮知道该干什么
Box box = new Box();
box.setOpenCommand(openCommand);

//3：然后模拟按下机箱上的按钮
box.openButtonPressed();
}
}

5.命令模式讲解

5.1命令模式的关键

就是把请求也封装为对象
命令模式中通常会有一个命令的组装者，用它来维护虚实现和真实实现之间的关系。

并且发起请求的对象和真正实现的对象是解耦的。

5.2命令模式的调用顺序图如下

6.命令的参数化配置

可以用不同的命令对象，去参数化配置客户的请求。

实际上也很简单，举个例子：比如添加一个重启功能。

那么就在MainBoardApi上添加一个reset()函数即可，然后再重新写一个ResetCommand实现Command，当然box中也要添加一个重启的函数resetButtonPressed()就行啦。那么客户端调用就如下

package demo12.command.example3;

public class Client {
public static void main(String[] args) {
//1：把命令和真正的实现组合起来，相当于在组装机器，
//把机箱上按钮的连接线插接到主板上。
MainBoardApi mainBoard = new GigaMainBoard();
//创建开机命令
OpenCommand openCommand = new OpenCommand(mainBoard);
//创建重启机器的命令
ResetCommand resetCommand = new ResetCommand(mainBoard);

//2：为机箱上的按钮设置对应的命令，让按钮知道该干什么
Box box = new Box();
//先正确配置，就是开机按钮对开机命令，重启按钮对重启命令
box.setOpenCommand(openCommand);
box.setResetCommand(resetCommand);

//3：然后模拟按下机箱上的按钮
System.out.println("正确配置下------------------------->");
System.out.println(">>>按下开机按钮：>>>");
box.openButtonPressed();
System.out.println(">>>按下重启按钮：>>>");
box.resetButtonPressed();

//然后来错误配置一回，反正是进行参数化配置
//就是开机按钮对重启命令，重启按钮对开机命令
box.setOpenCommand(resetCommand);
box.setResetCommand(openCommand);
//4：然后还是来模拟按下机箱上的按钮
System.out.println("错误配置下------------------------->");
System.out.println(">>>按下开机按钮：>>>");
box.openButtonPressed();
System.out.println(">>>按下重启按钮：>>>");
box.resetButtonPressed();
}
}

7.可撤销的操作（重点）

可撤销操作的意思就是：放弃该操作，回到未执行该操作的状态。
有两种基本思路：

1.补尝试，又称反操作式。

打开关闭 加减

2.存储恢复式

把操作前得状态记录下来。

8.补尝试，又称反操作式（以计算器为例）

8.1操作运算接口（相当于主板接口）

package demo12.command.example4;
/**
* 操作运算的接口
*/
public interface OperationApi {
/**
* 获取计算完成后的结果
* @return 计算完成后的结果
*/
public int getResult();
/**
* 设置计算开始的初始值
* @param result 计算开始的初始值
*/
public void setResult(int result);
/**
* 执行加法
* @param num 需要加的数
*/
public void add(int num);
/**
* 执行减法
* @param num 需要减的数
*/
public void substract(int num);
}

8.2操作运算真实实现类（相当于主板）

package demo12.command.example4;
/**
* 运算类，真正实现加减法运算
*/
public class Operation implements OperationApi{
/**
* 记录运算的结果
*/
private int result;
public int getResult() {
return result;
}
public void setResult(int result) {
this.result = result;
}

public void add(int num){
//实现加法功能
result += num;
}
public void substract(int num){
//实现减法功能
result -= num;
}
}

8.3抽象命令接口

package demo12.command.example4;
/**
* 命令接口，声明执行的操作，支持可撤销操作
*/
public interface Command {
/**
* 执行命令对应的操作
*/
public void execute();
/**
* 执行撤销命令对应的操作
*/
public void undo();
}

8.4真实实现命令类（加命令和减命令）

package demo12.command.example4;
/**
* 具体的加法命令实现对象
*/
public class AddCommand implements Command{
/**
* 持有具体执行计算的对象
*/
private OperationApi operation = null;
/**
* 操作的数据，也就是要加上的数据
*/
private int opeNum;
/**
* 构造方法，传入具体执行计算的对象
* @param operation 具体执行计算的对象
* @param opeNum 要加上的数据
*/
public AddCommand(OperationApi operation,int opeNum){
this.operation = operation;
this.opeNum = opeNum;
}

public void execute() {
//转调接收者去真正执行功能，这个命令是做加法
this.operation.add(opeNum);
}

public void undo() {
//转调接收者去真正执行功能
//命令本身是做加法，那么撤销的时候就是做减法了
this.operation.substract(opeNum);
}
}

package demo12.command.example4;
/**
* 具体的减法命令实现对象
*/
public class SubstractCommand implements Command{
/**
* 持有具体执行计算的对象
*/
private OperationApi operation = null;
/**
* 操作的数据，也就是要减去的数据
*/
private int opeNum;
/**
* 构造方法，传入具体执行计算的对象
* @param operation 具体执行计算的对象
* @param opeNum 要减去的数据
*/
public SubstractCommand(OperationApi operation,int opeNum){
this.operation = operation;
this.opeNum = opeNum;
}

public void execute() {
//转调接收者去真正执行功能，这个命令是做减法
this.operation.substract(opeNum);
}

public void undo() {
//转调接收者去真正执行功能
//命令本身是做减法，那么撤销的时候就是做加法了
this.operation.add(opeNum);
}
}

8.5计算器类（相当于机箱）

package demo12.command.example4;
import java.util.*;
/**
* 计算器类，计算器上有加法按钮、减法按钮，还有撤销和恢复的按钮
*/
public class Calculator {
/**
* 命令的操作的历史记录，在撤销时候用
*/
private List<Command> undoCmds = new ArrayList<Command>();
/**
* 命令被撤销的历史记录，在恢复时候用
*/
private List<Command> redoCmds = new ArrayList<Command>();

private Command addCmd = null;
private Command substractCmd = null;
public void setAddCmd(Command addCmd) {
this.addCmd = addCmd;
}
public void setSubstractCmd(Command substractCmd) {
this.substractCmd = substractCmd;
}
public void addPressed(){
this.addCmd.execute();
//把操作记录到历史记录里面
undoCmds.add(this.addCmd);
}
public void substractPressed(){
this.substractCmd.execute();
//把操作记录到历史记录里面
undoCmds.add(this.substractCmd);
}
public void undoPressed(){
if(this.undoCmds.size()>0){
//取出最后一个命令来撤销
Command cmd = this.undoCmds.get(this.undoCmds.size()-1);
cmd.undo();
//如果还有恢复的功能，那就把这个命令记录到恢复的历史记录里面
this.redoCmds.add(cmd );
//然后把最后一个命令删除掉，
this.undoCmds.remove(cmd);
}else{
System.out.println("很抱歉，没有可撤销的命令");
}
}
public void redoPressed(){
if(this.redoCmds.size()>0){
//取出最后一个命令来重做
Command cmd = this.redoCmds.get(this.redoCmds.size()-1);
cmd.execute();
//把这个命令记录到可撤销的历史记录里面
this.undoCmds.add(cmd);
//然后把最后一个命令删除掉
this.redoCmds.remove(cmd);
}else{
System.out.println("很抱歉，没有可恢复的命令");
}
}
}

8.6客户端使用

package demo12.command.example4;

public class Client {
public static void main(String[] args) {
//1：组装命令和接收者
//创建接收者
OperationApi operation = new Operation();
//创建命令对象，并组装命令和接收者
AddCommand addCmd = new AddCommand(operation,5);
SubstractCommand substractCmd = new SubstractCommand(operation,3);

//2：把命令设置到持有者，就是计算器里面
Calculator calculator = new Calculator();
calculator.setAddCmd(addCmd);
calculator.setSubstractCmd(substractCmd);

//3:模拟按下按钮，测试一下
calculator.addPressed();
System.out.println("一次加法运算后的结果为："+operation.getResult());
calculator.substractPressed();
System.out.println("一次减法运算后的结果为："+operation.getResult());

//测试撤消
calculator.undoPressed();
System.out.println("撤销一次后的结果为："+operation.getResult());
calculator.undoPressed();
System.out.println("再撤销一次后的结果为："+operation.getResult());

//测试恢复
calculator.redoPressed();
System.out.println("恢复操作一次后的结果为："+operation.getResult());
calculator.redoPressed();
System.out.println("再恢复操作一次后的结果为："+operation.getResult());
}
}

9.存储恢复式

先说几个概念：
宏命令：多个命令的集合的命令

队列请求：就是对命令对象进行排队，组成工作队列，然后依次取出命令对象来执行。

存储恢复式的要点就在于将请求队列日志化，具体的案例我没有理解的很清楚， 以后遇到合适的例子再重新补充。

10.思考命令模式

10.1命令模式本质：

封装请求

10.2什么时候选用

需要抽象出需要执行的动作，并参数化这些对象

需要在不同时刻指定排列和执行请求

需要支持取消操作

当支持系统崩溃时，能将系统的操作功能重新执行一遍