命令模式（Command Pattern）。

命令模式是一个高内聚的模式，其定义为：

将一个请求封装成一个对象，从而让你使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

通用代码：

• Receiver接收者角色

该角色就是干活的角色，命令传递到这里是应该被执行的。

• Command命令角色

需要执行的所有命令都在这里声明。

• Invoker调用者角色

接收到命令，并执行命令。

通用Receiver类

public abstract class Receiver {

// 抽象接收者，定义每个接收者都必须完成的业务

public abstract void doSomething();

}

很奇怪，为什么Receiver是一个抽象类？那是因为接收者可以有多个，有多个就需要定义一个所有特性的抽象集合——抽象的接收者。

具体的Receiver类

pubic class ConcreteReciver1 extends Receiver {

// 每个接收者都必须处理一定的业务逻辑

public void doSomething(){}

}

pubic class ConcreteReciver2 extends Receiver {

// 每个接收者都必须处理一定的业务逻辑

public void doSomething(){}

}

接收者可以是N个，这要依赖业务的具体定义。命令角色是命令模式的核心。

抽象的Command类

public abstract class Command {

// 定义一个子类的全局共享变量；

protected final Receiver receiver;

// 实现类必须定义一个接收者

public Command(Receiver _receiver) {

this.receiver = _receiver;

}

// 每个命令类都必须有一个执行命令的方法

public abstract void execute();

}

根据环境的需求，具体的命令类也可以有N个。

具体的Command类

public class ConcreteCommand1 extends Command {

// 声明自己的的默认接收者

public ConcreteCommand1(){

super(new ConcreteReciver1());

}

// 设置新的接收者

public ConcreteCommand1(Receiver _receiver) {

super(_receiver);

}

// 必须实现一个命令

public void execute(){

// 业务处理

super.receiver.doSomething();

}

}


public class ConcreteCommand2extends Command {

// 声明自己的的默认接收者

public ConcreteCommand2(){

super(new ConcreteReciver2());

}

// 设置新的接收者

public ConcreteCommand2Receiver _receiver) {

super(_receiver);

}

// 必须实现一个命令

public void execute(){

// 业务处理

super.receiver.doSomething();

}

}

调用者Invoker类

public class Invoker {

private Command command;

// 受气包，接受命令

public void setCommand(Command _command) {

this.command = _command;

}

// 执行命令

public void action() {

this.command.execute();

}

}

场景类

public class Client {

public static void main(String[] args) {

// 首先声明调用者Invoker

Invoker invoker = new Invoker();

// 定义一个发送给接收者的命令

Command command = new ConcreteCommand1();

// 把命令交给调用者去执行

invoker.setCommand(command);

invoker.action();

}

}

优点：

• 类间解耦

调用者角色与接收者角色之间没有任何依赖关系，调用者实现功能时只需调用Command抽象类的execute方法就可以，不需要了解到底是哪个接收者执行。

• 可扩展性

Command的子类可以非常容易的扩展，而调用者Invoker和高层次的模块Client不产生严重的代码耦合。

• 命令模式结合其他模式会更优秀

命令模式可以结合责任链模式，实现命令族解析任务，结合模板方法模式，则可以减少Command子类的膨胀问题。

缺点：

命令模式也是有缺点的，请看Command的子类：如果有N个命令，问题就出来了，Command的子类就可不是几个，而是N个，这个类膨胀的非常大，这个就需要读者在项目中慎重考虑使用。

使用场景：

只要你认为是命令的地方就可以采用命令模式。例如，在GUI开发中，一个按钮的点击是一个命令，可以采用命令模式；模拟DOS命令的时候，当然也要采用命令模式；触发——反馈机制等。

扩展：

• 反悔问题

有两种方法解决：一是结合备忘录模式还原最后状态，该方法适合接收者为状态的变更情况，而不适合事件处理；二是通过增加一个新的命令，实现事件的回滚。

示例代码：

抽象组

public abstract class Group {

// 甲乙双方分开办公，如果你要和某个组讨论，你首先要找到这个组

public abstract void find();

// 被要求增加功能

public abstract void add();

// 被要求删除功能

public abstract void delete();

// 被要求修改功能

public abstract void change();

// 被要求给出所有的变更计划

public abstract void plan();

// 每个接收者都要对直接执行的任务可以回滚

public void rollBack() {

// 根据日志进行回滚

}

}

需求组
 

public class RequirementGroup extends Group {

// 客户要求需求组过去和他们谈

public void finid(){

System.out.println("找到需求组...");

}

// 客户要求增加一项需求

public void add() {

System.out.println("客户要求增加一项需求...");

}

// 客户要求修改一项需求

public void change() {

System.out.println("客户要求修改一项需求...");

}

// 客户要求删除一项需求

public void delete() {

System.out.println("客户要求删除一项需求...");

}

// 客户要求给出变更计划

public void plan() {

System.out.println("客户要求需求变更计划");

}

}

美工组（PageGroup）、代码组（CodeGroup）代码与需求组（RequirementGroup）类似，故省略。

抽象命令类

public abstract class Command {

// 把三个组都定义好，子类可以直接使用

protected RequirementGroup rq = new RequirementGroup(); // 需求组

protected PageGroup pg = new PageGroup(); // 美工组

protected CodeGroup cg = new CodeGroup(); // 代码组

// 只有一个方法，你要我做什么事情

public abstract void execute();

}

增加需求的命令
 

public class AddRequirementCommand extends Command {

// 执行增加一项需求的命令

public void execute() {

// 找到需求组

super.rg.find();

// 增加一份需求

super.rg.add();

// 页面也要增加

super.pg.add();

// 功能也要增加

super.cg.add();

// 给出计划

super.rg.plan();

}

}

撤销命令

public class CancelDeletePageCommand extends Command {

// 撤销删除一个页面的命令

public void execute() {

super.pg.rollBack();

}

}

负责人
 

public class Invoker {

// 什么命令

private Command command;

// 客户发出命令

public void setCommand(Command command) {

this.command = command;

}

// 执行客户的命令

public void action() {

this.command.execute();

}

}

增加一项需求

public class Client {

public static void main(String[] args) {

// 定义我们的接头人

Invoker xiaoSan = new Invoker(); // 接头人就是小三

// 客户要求增加一项需求

System.out.println("------------------------客户要求增加一项需求---------------");

// 客户给我们下命令来

Command command =new AddRequirementCommand();

// 接头人接收命令

xiaoSan.setCommand(command);

// 接头人执行命令

xiaoSan.action();

}

}


public class ConcreteCommand1 extends Command {

// 对哪个Receiver类进行命令处理

private Receiver receiver;

// 构造函数传递接收者

public ConcreteCommand1(Receiver _receiver) {

this.receiver = _receiver;

}

// 必须实现一个命令

public void execute(){

// 业务处理

this.receiver.doSomething();

}

}

}