Java设计模式之命令模式-526互联

命令模式（Command Pattern）是一种行为型设计模式，又叫动作模式或事务模式。它将请求（命令）封装成对象，使得可以用不同的请求对客户端进行参数化，具体的请求可以在运行时更改、排队或记录，它讲发出者和接收者解耦（顺序：发出者-->命令-->接收者）
本质：封装请求

抽象命令（Command）：命令是一个抽象接口，定义了执行操作的统一方法。具体的命令类会实现这个接口，并提供执行相应操作的具体逻辑。
具体命令（Concrete Command）：具体命令类实现了抽象命令，它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
接收者（Receiver）：执行实际命令的类，命令对象会调用接收者的方法来执行请求。
调用者（Invoker）：持有命令对象，通常是多个，并通过访问命令对象来执行相关请求，他不直接访问接收者。

优点：

解耦：命令模式可以将发送命令的对象和执行命令的对象解耦，使得两者可以独立变化。
可扩展性：可以方便地添加新的命令类和接收者类，而无需修改现有的代码结构。
容易实现撤销和重做功能：由于每个命令对象都封装了具体的操作，可以很容易地实现命令的撤销和重做功能。
支持操作的队列化和延迟执行：命令对象可以被组织成队列或堆栈，实现对操作的排队和延迟执行。
缺点：

增加了类和对象的数量：使用命令模式可能会增加一些新的类和对象，从而增加了代码的复杂性。
需要额外的开销：封装命令对象和操作会增加一些额外的开销，可能会稍微降低性能。
可能导致过多的具体命令类：如果系统的命令比较多，可能会导致需要创建很多具体的命令类，增加了代码维护的难度。

实验16：命令模式

[实验任务一]：多次撤销和重复的命令模式

某系统需要提供一个命令集合（注：可以使用链表，栈等集合对象实现），用于存储一系列命令对象，并通过该命令集合实现多次undo()和redo()操作，可以使用加法运算来模拟实现。

import java.util.Stack;
public abstract class AbstractCommand {
    public abstract int execute(int value);
    public abstract int undo();
    public abstract int redo();
}
public class AddCommand extends AbstractCommand {
      private Adder adder = new Adder();
      private Stack<Integer> unStack = new Stack<Integer>();// 返回栈，用来记录所做的每一步操作，用于撤回
      private Stack<Integer> reStack = new Stack<Integer>();// 重复栈，用来存储返回栈弹出的数据，由于重复
     /**
             * 撤回
             *
       */
     public int undo() {
         int i=0;
         if (unStack.isEmpty()) {
            
             i=-1;
         }else{
             Integer pop = unStack.pop();
             reStack.push(pop);
             if(!unStack.isEmpty()){//判断弹出数据后是否为空，如果为空，说明已撤回到最原始状态
                 i=unStack.peek();
             }
         }
         return i;
     }
     /**
      * 恢复
      */
     public int redo() {
         int i=0;
         if (reStack.isEmpty()) {
             i=-1;
         }else{//撤回时只要可以可以撤回，则返回栈一定有数据
             Integer pop = reStack.pop();
             unStack.push(pop);
             i=pop;
         }
         return i;
     }
     /**
      * 执行计算，并进行栈的更新
      */
     public int execute(int value) {
         int v = 0;
         if (unStack.isEmpty()) {// 说明还没有数据
             v = adder.add(value);
             unStack.push(v);
         } else {// 需要更新两个栈中的内容，并计算结果,其中返回栈应该更新，重复栈应该清空
             v = adder.add(value);
             unStack.push(v);
             if (!reStack.isEmpty()) {
                 for (int i = 0; i < reStack.size(); i++) {
                     reStack.pop();
                 }
             }
         }
         return v;
     }
 }
public class Adder {
     private int num =0;
     public int add(int value) {
        num+=value;
        return num;
     }
}
public class CalculatorForm {
          private AbstractCommand command;
          public void setCommand(AbstractCommand command) {
              this.command =command;
          }
          /**
               * 执行运算
           * @param value
           */
         public void compute(int value) {
             command.execute(value);
         }
         /**
        * 撤回
          */
         public void undo() {
             int i = command.undo();
             if(i==-1){
                 System.out.println("缓存中已不存在数据");
             }else{
                 System.out.println("执行成功，运算结果是："+i);
             }
         }
         /**
          * 恢复
          */
         public void redo() {
              int i = command.redo();
             if(i==-1){
                 System.out.println("已恢复至最新数据");
             }
             else{
                 System.out.println("执行成功，运算结果是："+i);
             }
         }
     }
public class Client {
    public static void main(String[] args) {
        CalculatorForm form = new CalculatorForm();
        AddCommand command = new AddCommand();
        form.setCommand(command);
        //计算
        System.out.println("------计算过程------");
        form.compute(1);
        form.compute(2);
        form.compute(3);
        form.compute(4);
        //多次撤回
        System.out.println("------撤回过程------");
        form.undo();
        form.undo();
        form.undo();
        form.undo();
        form.undo();
        //多次恢复
        System.out.println("------恢复过程------");
        form.redo();
        form.redo();
        form.redo();
        form.redo();
        form.redo();   
    }
}