命令模式--导读
在开发过程中，我们经常会碰到一些请求，我们不知道具体的操作是什么，我们不知道请求的接收者是谁，具体该做什么我们也了解，而接收者只只具体怎么执行，不知道命令由谁发送。这样就会使得发送者和接收者之间的耦合度降低，发送者和接收者之间没有直接联系，发送者只需要知道如何发送，而不需要如何完成，这样就使得一个命令的发送者可以对应多个命令的接收者。就像在战争中元帅给下级将领下达命令时，元帅只需要知道自己的命令该怎么下达，而根本不需要知道命令的传送和命令的具体执行，而下面的小兵不需要具体的命令是谁下达的，元帅并不需要现场给小兵下命令，这样元帅就可以给更多地小兵下命令。这种使得发送者和接受者之间完全解耦的设计方式就是命令模式
命令模式--定义
命令模式(Command Pattern)：将一个请求封装为一个对象，从而让我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象行为型模式，其别名为动作(Action)模式或事务(Transaction)模式。
这种模式可以对发送者和接受者完全解耦，发送者也接收者之间并没有直接的联系，发送者只需要知道如何发送请求，不需要关心请求是如何完成了
命令模式的定义比较复杂，提到了很多术语，例如“用不同的请求对客户进行参数化”、“对请求排队”，“记录请求日志”、“支持可撤销操作”等，在后面我们将对这些术语进行一一讲解。
命令模式--结构
从上图可以看出命令模式包含如下几个角色：
Command: 抽象命令类一般是一个抽象类或接口，在其中声明了用于执行请求的execute()等方法，通过这些方法可以调用请求接收者的相关操作。
ConcreteCommand: 具体命令类是抽象命令类的子类，实现了在抽象命令类中声明的方法，它对应具体的接收者对象，将接收者对象的动作绑定其中。在实现execute()方法时，将调用接收者对象的相关操作
Invoker: 调用者即请求发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联关系。在程序运行时可以将一个具体命令对象注入其中，再调用具体命令对象的execute()方法，从而实现间接调用请求接收者的相关操作。
Receiver: 接收者执行与请求相关的操作，它具体实现对请求的业务处理。
Client:客户类
命令模式的本质就在于将命令进行封装，将发出命令的责任和执行命令的责任分开，使的发送者只需要知道如何发送命令即可，不需要命令是如何实现的，甚至命令执行是否成功都不需要理会。同时命令模式使得请求也变成了一个对象，它像其他对象一样可以被存储和传递。
命令模式的关键在于引入了抽象命令类，请求发送者针对抽象命令类编程，只有实现了抽象命令类的具体命令才与请求接收者相关联。在最简单的抽象命令类中只包含了一个抽象的execute()方法，每个具体命令类将一个Receiver类型的对象作为一个实例变量进行存储，从而具体指定一个请求的接收者，不同的具体命令类提供了execute()方法的不同实现，并调用不同接收者的请求处理方法。
命令模式--代码实现
下面我以元帅对下属下命令为例进行代码实现：
Marshal.java命令的发出者，在类中保持对命令对象的引用
package Command_Pattern; import java.util.HashMap; import java.util.Map; /** * 具体命令的发送者 * @author xyxy001 * */ public class Marshal { //元帅会发送很多命令，所以用集合来存放命令 private Map<String,Command> commands=new HashMap<String,Command>(); //元帅的名字 private String name; public Marshal(Map<String,Command> commands,String name){ this.commands=commands; this.name=name; } public String getName() { return name; } public void setName(String name) { this.name = name; } //元帅发送命令 public void sendCommand(String name){ Command command=commands.get(name); //System.out.println(); if(command!=null) { System.out.println(this.name+"元帅发布了"+name); command.execute(); } } }
soldier.java具体命令的执行者，具体动作的执行者，实现对请求的业务执行
package Command_Pattern; /** *士兵类，具体的命令执行者 * @author xyxy001 * */ public class Soldier { //执行进攻的方法 public void attack(){ System.out.println("像敌军进攻"); } //执行撤退的方法 public void retreat(){ System.out.println("向后撤退"); } //执行休息的命令 public void getRest(){ System.out.println("原地休息"); } //开炮 public void fire(){ System.out.println("二营长你他娘的意大利跑呢"); } }
Command.java,抽象的命令类
package Command_Pattern; /** * 抽象命令类,代替命令的发送者，成为接收者的直接关联者 * @author xyxy001 * */ public abstract class Command { Soldier soldier; //定义一个抽象的执行方法，该方法将会调用具体接受者的方法 public abstract void execute(); public Command(){ this.soldier=new Soldier(); } }
下面是四个具体的命令类：
package Command_Pattern; public class CommandAttact extends Command { public void execute() { System.out.println("执行进攻命令"); soldier.attack(); } } package Command_Pattern; public class CommandFire extends Command { @Override public void execute() { System.out.println("执行开火的命令"); soldier.fire(); } } package Command_Pattern; public class CommandGetRest extends Command{ @Override public void execute() { System.out.println("执行休息的命令"); soldier.getRest(); } } package Command_Pattern; public class CommandRetreat extends Command{ @Override public void execute() { System.out.println("执行向后撤退的命令"); soldier.retreat(); } }
为了提高系统的可拓展性和灵活性，所以这里使用反射机制来创建命令类
package Command_Pattern; import java.io.File; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import org.w3c.dom.Document; import org.w3c.dom.Node; import org.w3c.dom.NodeList; public class XMLUtil { public static Object getFacade(int i) { try { DocumentBuilderFactory bFactory=DocumentBuilderFactory.newInstance(); DocumentBuilder db=bFactory.newDocumentBuilder(); Document doc=db.parse(new File("src//Command_Pattern//config.xml")); NodeList nodes=doc.getElementsByTagName("className"); Node node=nodes.item(i).getFirstChild(); String name=node.getNodeValue(); Class c=Class.forName(name); Object oc=c.newInstance(); return oc; } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); return null; } } }
通过config.xml来进行反射：
<?xml version="1.0" encoding="GBK"?> <config> <className>Command_Pattern.CommandAttact</className> <className>Command_Pattern.CommandFire</className> <className>Command_Pattern.CommandGetRest</className> <className>Command_Pattern.CommandRetreat</className> </config>
客户端执行代码：
package Command_Pattern;
import java.util.HashMap;
import java.util.Map;
public class client {
public static void main(String[] args) {
//创建集合类用于存放元帅所有的命令
Map<String,Command> commands=new HashMap<String,Command>();
Command c1=(Command)XMLUtil.getFacade(0);
Command c2=(Command)XMLUtil.getFacade(1);
Command c3=(Command)XMLUtil.getFacade(2);
Command c4=(Command)XMLUtil.getFacade(3);
//将命令放入集合中
commands.put("进攻", c1);
commands.put("开火", c2);
commands.put("休息", c3);
commands.put("撤退", c4);
Marshal mar=new Marshal(commands,"卫青");
//现在元帅下达命令
mar.sendCommand("开火");
}
}
运行效果如下：
命令模式--拓展
对于只想了解命令模式的思想来说上面的内容已经够了，下面我们来介绍命令模式更深层次的东西：
一.撤销操作的实现：
有两种基本的思路来实现可撤销的操作：
1、逆向操作实现：比如被撤销的操作是添加功能，那撤消的实现就变成删除功能；同理被撤销的操作是删除功能，那么撤销的实现就变成添加功能；
2、存储恢复实现，意思就是把操作前的状态记录下来，然后要撤销操作的时候就直接恢复回去就可以了，可使用备忘录模式(Memento Pattern)来实现（稍后会讲到备忘录模式）;
这里主要讲解通过逆向操作来实现撤销(undo)：
具体操作：在命令模式中，我们可以通过调用一个命令对象的execute()方法来实现对请求的处理，如果需要撤销(undo)请求，可通过在命令类中增加一个逆向操作来实现。
下面是撤销命令的实现代码：
用栈来保存之前执行的命令，用于撤销
package Command_Pattern; /** * 栈的抽象接口用于存储撤销和恢复命令的栈 * @author liu * */ public interface Stack<E> { //判断栈是否为空 public boolean isEmpty(); //判断栈是否是满的 public boolean isMax(); //出栈 public E pop(); //进栈 public boolean push(E e); //返回栈顶元素 public E peek(); //返回栈的长度 public int size(); //返回栈的容量 public int getMaxSize(); //用于清空当前栈的所有数据 public void clear(); }
mystack.java实现了stack接口的具体类
package Command_Pattern; public class MyStack<E> implements Stack<E> { private Object[] data = null;// 栈的数据域 private int top = -1;// 指向栈顶的指针，初始值为-1 private int maxSize = 0;// 栈的容量 // 初始化栈 public MyStack(int initSize) { if (initSize > 0) { data = new Object[initSize]; maxSize = initSize; this.top = -1; } } public MyStack() { data = new Object[20]; maxSize = 20; } @Override public boolean isEmpty() { //如果为空则返回true，否则返回false return top==-1 ?true:false; } @Override public boolean isMax() { //判断栈是否满了 return top==maxSize-1?true:false; } @Override public E pop() { if(isEmpty()) { System.out.println("对不起当前为空栈"); return null; }else { E e=(E) data[top]; top--; return e; } } @Override public boolean push(Object e) { if(isMax()) { System.out.println("对不起当前栈满，不能进栈"); return false; }else { top++; data[top]=e; return true; } } @Override public E peek() { if(isEmpty()) { System.out.println("当前栈为空"); return null; } else { E e=(E)data[top]; return e; } } @Override public int size() { return top+1; } @Override public int getMaxSize() { // TODO Auto-generated method stub return maxSize; } @Override public void clear() { top=-1; } }
CommandManager.java用于管理执行和撤销
package Command_Pattern; /** * 用于管理命令的执行和撤销 * @author liu * */ public class CommandManager { //撤销的步数,当为-1是不限撤销步数 private int undoCount=-1; //用于存放撤销操作的队列 MyStack<Command> stack=null; public CommandManager() { //默认撤销步数为4,如果有需要可以通过配置文件更改 undoCount=4; stack=new MyStack(4); } //执行命令 public void executeCommand(Command command) { command.execute(); //将之前的步骤给清空，如果超过撤销的步骤数 if(undoCount!=-1&& stack.size()>=undoCount) stack.clear(); //加入新的要撤销的步骤数 stack.push(command); } //执行撤销命令 public void undo() { if(stack.size()<0) System.out.println("无撤销操作"); else { Command c=stack.pop(); c.undo(); } } }
command抽象类和具体实现类只是增加了undo的相应方法而已,具体代码如下：
package Command_Pattern; /** * 抽象命令类,代替命令的发送者，成为接收者的直接关联者 * @author xyxy001 * */ public abstract class Command { Soldier soldier; //定义一个抽象的执行方法，该方法将会调用具体接受者的方法 public abstract void execute(); //用于撤销操作 public abstract void undo(); public Command(){ this.soldier=new Soldier(); } } package Command_Pattern; public class CommandAttact extends Command { public void execute() { System.out.println("执行进攻命令"); soldier.attack(); } public void undo() { System.out.println("撤销进攻命令"); } }
下面是执行效果：
二.请求日志
概念：将所有的动作都记录在日志中，并能在系统死机后，重新调用这些动作恢复到之前的状态。当我们执行命令的时候，将历时记录存储在磁盘中。一旦系统死机，我们就可以将命令对象重新加载，并依次调用这些对象的execute()方法。
实现方法：利用对象的序列化把对象保存起来（记录日志），在需要的时候反序列化（恢复事务）。
请求日志文件可以实现很多功能，常用功能如下：
1、什么事情都存在意外，如一旦系统发生故障，日志文件可以为系统提供一种恢复机制，在请求日志文件中可以记录用户对系统的每一步操作，从而让系统能够顺利恢复到某一个特定的状态；
2 、请求日志也可以用于实现批处理，在一个请求日志文件中可以存储一系列命令对象，例如一个命令队列；
3、可以将命令队列中的所有命令对象都存储在一个日志文件中，每执行一个命令则从日志文件中删除一个对应的命令对象，防止因为断电或者系统重启等原因造成请求丢失，而且可以避免重新发送全部请求时造成某些命令的重复执行，只需读取请求日志文件，再继续执行文件中剩余的命令即可。
三.宏命令
宏命令(Macro Command)又称为组合命令，它是组合模式和命令模式联用的产物。宏命令是一个具体命令类，它拥有一个集合属性，在该集合中包含了对其他命令对象的引用。通常宏命令不直接与请求接收者交互，而是通过它的成员来调用接收者的方法。当调用宏命令的execute()方法时，将递归调用它所包含的每个成员命令的execute()方法，一个宏命令的成员可以是简单命令，还可以继续是宏命令。执行一个宏命令将触发多个具体命令的执行，从而实现对命令的批处理。
四.命令队列
有时候我们需要将多个请求排队，当一个请求发送者发送一个请求时，将不止一个请求接收者产生响应，这些请求接收者将逐个执行业务方法，完成对请求的处理。此时，我们可以通过命令队列来实现。
命令队列的实现方法有多种形式，其中最常用、灵活性最好的一种方式是增加一个CommandQueue类，由该类来负责存储多个命令对象，而不同的命令对象可以对应不同的请求接收者，CommandQueue类的典型代码如下所示：
import java.util.*; class CommandQueue { //定义一个ArrayList来存储命令队列 private ArrayList<Command> commands = new ArrayList<Command>(); public void addCommand(Command command) { commands.add(command); } public void removeCommand(Command command) { commands.remove(command); } //循环调用每一个命令对象的execute()方法 public void execute() { for (Object command : commands) { ((Command)command).execute(); } } }
在增加了命令队列类CommandQueue以后，请求发送者类Invoker将针对CommandQueue编程，代码修改如下：
class Invoker { private CommandQueue commandQueue; //维持一个CommandQueue对象的引用 //构造注入 public Invoker(CommandQueue commandQueue) { this. commandQueue = commandQueue; } //设值注入 public void setCommandQueue(CommandQueue commandQueue) { this.commandQueue = commandQueue; } //调用CommandQueue类的execute()方法 public void call() { commandQueue.execute(); } }
命令模式--优缺点
命令模式的主要优点如下：
(1) 降低系统的耦合度。由于请求者与接收者之间不存在直接引用，因此请求者与接收者之间实现完全解耦，相同的请求者可以对应不同的接收者，同样，相同的接收者也可以供不同的请求者使用，两者之间具有良好的独立性。
(2) 新的命令可以很容易地加入到系统中。由于增加新的具体命令类不会影响到其他类，因此增加新的具体命令类很容易，无须修改原有系统源代码，甚至客户类代码，满足“开闭原则”的要求。
(3) 可以比较容易地设计一个命令队列或宏命令（组合命令）。
(4) 为请求的撤销(Undo)和恢复(Redo)操作提供了一种设计和实现方案。
命令模式的主要缺点如下：
使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个对请求接收者的调用操作都需要设计一个具体命令类，因此在某些系统中可能需要提供大量的具体命令类，这将影响命令模式的使用。
命令模式--使用场景
(1) 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。请求调用者无须知道接收者的存在，也无须知道接收者是谁，接收者也无须关心何时被调用。
(2) 系统需要在不同的时间指定请求、将请求排队和执行请求。一个命令对象和请求的初始调用者可以有不同的生命期，换言之，最初的请求发出者可能已经不在了，而命令对象本身仍然是活动的，可以通过该命令对象去调用请求接收者，而无须关心请求调用者的存在性，可以通过请求日志文件等机制来具体实现。
(3) 系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。
(4) 系统需要将一组操作组合在一起形成宏命令。