命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作
命令模式是对命令进行封装，由调用者发起命令请求，接收者执行请求。
基本结构：
- Command类：是一个抽象类，类中对需要执行的命令进行声明，一般来说要对外公布一个 execute 方法用来执行命令。
- ConcreteCommand类：Command类的实现类，对抽象类中声明的方法进行实现。
- Invoker类：调用者，负责调用命令。
- Receiver类：接收者，负责接收命令并且执行命令。
当我们调用时，执行的时序首先是调用者类，然后是命令类，最后是接收者类。也就是说一条命令的执行被分成了三步，它的耦合度要比把所有的操作都封装到一个类中要低的多，而这也正是命令模式的精髓所在：把命令的调用者与执行者分开，使双方不必关心对方是如何操作的。
实现：
Java 代码表示：
调用类：
class Invoker {
Command command;
public void setCommand(Command command) {
this.command = command;
}
public void action() {
System.out.println("调用者调用");
command.execute();
}
}
命令类：
interface Command {
public void execute();
}
class ConcreteCommand implements Command {
Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
public void execute() {
System.out.println("命令执行!");
receiver.doSomething();
}
}
接收者类：
class Receiver {
public void doSomething() {
System.out.println("接收者处理业务");
}
}
客户端调用：
class Client {
public static void main(String[] args) {
Receiver r = new Receiver();
Command c = new ConcreteCommand(r);
// 客户端直接执行具体命令方式（此方式与类图相符）
c.execute();
System.out.println("------------------------------------");
Invoker i = new Invoker();
i.setCommand(c);
//客户端通过调用者来执行命令
i.action();
}
}
优缺点：
首先，命令模式的封装性很好：每个命令都被封装起来，对于客户端来说，需要什么功能就去调用相应的命令，而无需知道命令具体是怎么执行的。比如有一组文件操作的命令：新建文件、复制文件、删除文件。如果把这三个操作都封装成一个命令类，客户端只需要知道有这三个命令类即可，至于命令类中封装好的逻辑，客户端则无需知道。
其次，命令模式的扩展性很好，在命令模式中，在接收者类中一般会对操作进行最基本的封装，命令类则通过对这些基本的操作进行二次封装，当增加新命令的时候，对命令类的编写一般不是从零开始的，有大量的接收者类可供调用，也有大量的命令类可供调用，代码的复用性很好。比如，文件的操作中，我们需要增加一个剪切文件的命令，则只需要把复制文件和删除文件这两个命令组合一下就行了，非常方便。
最后说一下命令模式的缺点，那就是命令如果很多，开发起来就要头疼了。特别是很多简单的命令，实现起来就几行代码的事，而使用命令模式的话，不用管命令多简单，都需要写一个命令类来封装。
应用场景：
您被要求为文字处理器开发菜单系统。初步要求是：
- 用户应该能够打开，关闭和创建文档以及复制和粘贴文本。
- 用户应该能够创建，删除和执行宏命令并将处理文字。
根据上面的场景，可以选用命令模式来对其进行编码。
首先先创建文档类即(Receiver 接收者类)：
class Document {
public void create() {
System.out.println("Created!");
}
public void open() {
System.out.println("Opened!");
}
public void close() {
System.out.println("Closed!");
}
public void copy() {
System.out.println("Copyed!");
}
public void paste() {
System.out.println("Pasted!");
}
}
接着是文档命令类：
abstract class DocumentCommand {
protected Document doc;
public DocumentCommand(Document doc) {
this.doc = doc;
}
public abstract void execute();
}
class CloseCommand extends DocumentCommand {
public CloseCommand(Document doc) {
super(doc);
}
public void execute() {
doc.close();
}
}
class OpenCommand extends DocumentCommand {
public OpenCommand(Document doc) {
super(doc);
}
public void execute() {
doc.open();
}
}
class CopyCommand extends DocumentCommand {
public CopyCommand(Document doc) {
super(doc);
}
public void execute() {
doc.copy();
}
}
class PasteCommand extends DocumentCommand {
public PasteCommand(Document doc) {
super(doc);
}
public void execute() {
doc.paste();
}
}
接着定义宏命令类即(Invoker 调用者类)，命令集合：
import java.util.ArrayList;
import java.util.List;
class Macro {
private List<DocumentCommand> myCommands;
public Macro() {
myCommands = new ArrayList<DocumentCommand>();
}
public void addCommand(DocumentCommand dc) {
myCommands.add(dc);
}
public void removeCommand(DocumentCommand dc) {
myCommands.remove(dc);
}
public void execute() {
for(DocumentCommand dc: myCommands) {
dc.execute();
}
}
}
菜单调用：
public class Application {
public static void main(String[] args) {
Document doc = new Document();
Macro myMacro = new Macro();
myMacro.addCommand(new OpenCommand(doc));
myMacro.addCommand(new CopyCommand(doc));
myMacro.addCommand(new PasteCommand(doc));
DocumentCommand cc = new CloseCommand(doc);
myMacro.addCommand(cc);
myMacro.execute();
System.out.println("------------------------------");
myMacro.removeCommand(cc);
myMacro.execute();
}
}