命令模式(行为型)
一、相关概述
1). 案例引入
Sunny软件公司开发人员为公司内部OA系统开发了一个桌面版应用程序，该应用程序为用户提供了一系列自定义功能键，用户可以通过这些功能键来实现一些快捷操作。Sunny软件公司开发人员通过分析，发现不同的用户可能会有不同的使用习惯，在设置功能键的时候每个人都有自己的喜好，例如有的人喜欢将第一个功能键设置为“打开帮助文档”，有的人则喜欢将该功能键设置为“最小化至托盘”，为了让用户能够灵活地进行功能键的设置，开发人员提供了一个“功能键设置”窗口，该窗口界面如图2所示：
命令模式功能键.png
2). 命令模式概述
在软件开发中，我们经常需要向某些对象发送请求（调用其中的某个或某些方法），但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，此时，我们特别希望能够以一种松耦合的方式来设计软件，使得请求发送者与请求接收者能够消除彼此之间的耦合，让对象之间的调用关系更加灵活，可以灵活地指定请求接收者以及被请求的操作。命令模式为此类问题提供了一个较为完美的解决方案。命令模式可以将请求发送者和接收者完全解耦，发送者与接收者之间没有直接引用关系，发送请求的对象只需要知道如何发送请求，而不必知道如何完成请求。
- 命令模式: 将一个请求封装为一个对象，从而让我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象行为型模式，其别名为动作(Action)模式或事务(Transaction)模式。
命令模式的核心在于引入了命令类，通过命令类来降低发送者和接收者的耦合度。
命令模式结构图.png
3). 命令模式相关角色
- Command（抽象命令类）：抽象命令类一般是一个抽象类或接口，在其中声明了用于执行请求的execute()等方法，通过这些方法可以调用请求接收者的相关操作。
- ConcreteCommand（具体命令类）：具体命令类是抽象命令类的子类，实现了在抽象命令类中声明的方法，它对应具体的接收者对象，将接收者对象的动作绑定其中。在实现execute()方法时，将调用接收者对象的相关操作(Action)。
- Invoker（调用者）：调用者即请求发送者，它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联关系。在程序运行时可以将一个具体命令对象注入其中，再调用具体命令对象的execute()方法，从而实现间接调用请求接收者的相关操作。
- Receiver（接收者）：接收者执行与请求相关的操作，它具体实现对请求的业务处理。命令模式的本质是对请求进行封装，一个请求对应于一个命令，将发出命令的责任和执行命令的责任分割开。每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行相应的操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求如何被接收、操作是否被执行、何时被执行，以及是怎么被执行的。
4). 命令模式典型代码
- 抽象命令类
abstract class Command {
public abstract void execute();
}
- 具体命令类
class ConcreteCommand extends Command {
//维持一个对请求接收者对象的引用
private Receiver receiver;
public void execute() {
//调用请求接收者的业务处理方法action()
receiver.action();
}
}
- 请求发送者
class Invoker {
private Command command;
//构造注入
public Invoker(Command command) {
this.command = command;
}
//设值注入
public void setCommand(Command command) {
this.command = command;
}
//业务方法，用于调用命令类的execute()方法
public void call() {
command.execute();
}
}
- 请求接受者
class Receiver {
public void action() {
//具体操作
}
}
二、案例实现
1). UML设计
命令模式自定义功能键.png
- 其他类
import java.util.ArrayList;
import java.util.List;
/**
* 功能键设置窗口类
*/
class FBSettingWindow {
// 窗口标题
private String title;
// 存储所有功能键的集合
private List<FunctionButton> functionButtons = new ArrayList<FunctionButton>();
public FBSettingWindow (String title) {
this.setTitle(title);
}
public void setTitle(String title) {
this.title = title;
}
public String getTitle() {
return title;
}
public void addFunctionButton (FunctionButton functionButton) {
this.functionButtons.add(functionButton);
}
public void removeFunctionButton(FunctionButton functionButton) {
this.functionButtons.remove(functionButton);
}
/**
* 显示窗口以及功能键
*/
public void display() {
System.out.println("显示窗口：" + this.title);
System.out.println("显示功能键：");
for (FunctionButton functionButton : functionButtons) {
functionButton.getName();
}
System.out.println("```````````````````````````");
}
}
- 请求发送者
/**
* 请求发送者：功能键类
*/
class FunctionButton {
// 功能键名称
private String name;
// 维持一个抽象命令的引用
private Command command;
public FunctionButton(String name) {
this.name = name;
}
public String getName() {
return name;
}
// 为功能键注入命令
public void setCommand(Command command) {
this.command = command;
}
// 发送请求的方法
public void onClick() {
System.out.println("点击功能键：");
command.execute();
}
}
- 命令类，注入对应的接受者
/**
* 抽象命令类：（也可以是抽象类）
*/
interface Command {
public abstract void execute();
}
/**
* 具体命令类：帮助命令类
*/
class HelpCommand implements Command {
// 维持对请求接收者的引用
private HelpHandler helpHandler;
public HelpCommand() {
helpHandler = new HelpHandler();
}
// 执行命令的方法，调用请求接收者的业务方法
public void execute() {
this.helpHandler.display();
}
}
/**
* 具体命令类：最小化命令类
*/
class MinimizeCommand implements Command {
// 维持对请求接收者的引用
private WindowHandler windowHandler;
public MinimizeCommand() {
this.windowHandler = new WindowHandler();
}
// 命令执行方法，将调用请求接收者的业务方法
public void execute() {
windowHandler.minimize();
}
}
- 请求接受者
/**
* 请求接收者：窗口处理类
*/
class WindowHandler {
public void minimize() {
System.out.println("将窗口最小化至托盘!");
}
}
/**
* 请求接收者：帮助文档处理类
*/
class HelpHandler {
public void display() {
System.out.println("显示帮助文档！");
}
}
- 客户端
/**
* 命令模式客户端
* @author liucheng
* @since 2019/9/3
*/
public class Client {
public static void main(String[] args) {
// 创建一个功能设置窗口
FBSettingWindow fbSettingWindow = new FBSettingWindow("功能键设置窗口");
// 创建两个功能键
FunctionButton fb1 = new FunctionButton("按键1");
FunctionButton fb2 = new FunctionButton("按键2");
// 创建具体的命令对象【建议写成xml配置】
Command showHelp = new HelpCommand();
Command turnMin = new MinimizeCommand();
// 将命令对象绑定到功能键
fb1.setCommand(showHelp);
fb2.setCommand(turnMin);
// 将功能键添加到功能设置窗口
fbSettingWindow.addFunctionButton(fb1);
fbSettingWindow.addFunctionButton(fb2);
// 显示功能窗口
fbSettingWindow.display();
// 点击对应的按钮
fb1.onClick();
fb2.onClick();
}
}
三、拓展
1). 命令队列
有时候我们需要将多个请求排队，当一个请求发送者发送一个请求时，将不止一个请求接收者产生响应，这些请求接收者将逐个执行业务方法，完成对请求的处理。此时，我们可以通过命令队列来实现。命令队列的实现方法有多种形式，其中最常用、灵活性最好的一种方式是增加一个CommandQueue类，由该类来负责存储多个命令对象，而不同的命令对象可以对应不同的请求接收者。典型代码如下：
import java.util.ArrayList;
import java.util.List;
/**
* 命令队列：对应原先的命令类
*/
class CommandQueue {
// 定义一个List类存储命令队列
private List<Command> commands = new ArrayList<Command>();
private void addCommand(Command command) {
commands.add(command);
}
private void removeCommand(Command command) {
commands.remove(command);
}
// 循环调用每一个命令对象的execute() 方法
public void execute() {
for (Command command : commands) {
command.execute();
}
}
}
/**
* 请求发送者：面向命令队列编程
*/
class Invoker {
// 维持一个CommandQueue的引用
private CommandQueue commandQueue;
// 构造注入
public Invoker(CommandQueue commandQueue) {
this.commandQueue = commandQueue;
}
// set注入
public void setCommandQueue(CommandQueue commandQueue) {
this.commandQueue = commandQueue;
}
// 调用CommandQueue类的execute()方法
public void call() {
commandQueue.execute();
}
}
命令队列与我们常说的“批处理”有点类似。批处理，顾名思义，可以对一组对象（命令）进行批量处理，当一个发送者发送请求后，将有一系列接收者对请求作出响应，命令队列可以用于设计批处理应用程序，如果请求接收者的接收次序没有严格的先后次序，我们还可以使用多线程技术来并发调用命令对象的execute()方法，从而提高程序的执行效率。
2). 撤销操作
可以在命令类中加一个撤销操作，让相关状态恢复到执行命令之前。备忘录模式(Memento Pattern)专门用于撤销等操作
- 请求发送者
/**
* 请求发送者：计算器界面类
*/
class CalculatorForm {
private AbstractCommand command;
public void setCommand(AbstractCommand command) {
this.command = command;
}
// 执行计算
public void compute(int value) {
int i = command.execute(value);
System.out.println("执行运算，运算结果为：" + i);
}
public void undo() {
int i = command.undo();
System.out.println("执行撤销，运算结果为：" + i);
}
public void redo() {
int i = command.redo();
System.out.println("执行恢复，运行结果为：" + i);
}
}
- 命令类
/**
* 抽象命令类
*/
abstract class AbstractCommand {
// 声明执行方法
public abstract int execute(int value);
// 声明撤销方法
public abstract int undo();
// 声明恢复的方法
public abstract int redo();
}
/**
* 具体命令类
*/
class ConcreteCommand extends AbstractCommand {
private Adder adder = new Adder();
private int value;
// 加法操作
public int execute(int value) {
this.value = value;
return adder.add(value);
}
// 撤销操作
public int undo() {
return adder.undo();
}
public int redo() {
return adder.redo();
}
}
- 命令接受者
import java.util.Stack;
/**
* 请求接收者：加法类
*/
class Adder {
// 定义初始值为0
private int num = 0;
// 定义历史状态栈
Stack<Integer> historyStack = new Stack<Integer>();
// 定义撤销状态栈
Stack<Integer> undoStack = new Stack<Integer>();
// 加法操作，每次将传入的值与num做加法运算
public int add(int value) {
if (this.undoStack.size() != 0) {
this.undoStack.clear();
}
this.historyStack.push(num);
this.num += value;
return num;
}
// 撤销操作，从历史栈中去除栈顶元素
public int undo() {
if (this.historyStack.size() != 0) {
this.undoStack.push(this.num);
this.num = this.historyStack.pop();
}
return this.num;
}
// 恢复操作，从undo栈中取出最新入栈元素
public int redo() {
if (this.undoStack.size() != 0) {
this.historyStack.push(this.num);
this.num = this.undoStack.pop();
}
return this.num;
}
}
- 客户端测试
/**
* 撤销操作
* @author liucheng
* @since 2019/9/3
*/
public class ClientThree {
public static void main(String[] args) {
// 创建计算表单：请求发送者
CalculatorForm form = new CalculatorForm();
// 创建具体命令类
AbstractCommand command = new ConcreteCommand();
// 向发送者注入命令对象
form.setCommand(command);
// 执行操作
form.compute(10);
form.compute(5);
form.compute(10);
form.compute(10);
form.compute(10);
form.compute(10);
form.undo();
form.undo();
form.redo();
form.undo();
form.compute(3);
form.redo();
}
}
3). 请求日志
请求日志可以将命令操作保存，让系统恢复到指定的某个状态；实现批处理；防止由于网络故障、断电引起的请求丢失问题等；可以将命令对象通过序列化写到日志文件中，此时命令类必须实现Java.io.Serializable接口
案例：Sunny软件公司开发了一个网站配置文件管理工具，可以通过一个可视化界面对网站配置文件进行增删改等操作，该工具使用命令模式进行设计，结构如图6所示：
命令模式-日志.png
- 请求发送者
import java.io.*;
import java.util.*;
/**
* 请求发送者: 配置文件设置窗口类
*/
class ConfigSettingWindow {
//定义一个集合来存储每一次操作时的命令对象
private ArrayList<Command> commands = new ArrayList<Command>();
private Command command;
//注入具体命令对象
public void setCommand(Command command) {
this.command = command;
}
//执行配置文件修改命令，同时将命令对象添加到命令集合中
public void call(String args) {
command.execute(args);
commands.add(command);
}
//记录请求日志，生成日志文件，将命令集合写入日志文件
public void save() {
FileUtil.writeCommands(commands);
}
//从日志文件中提取命令集合，并循环调用每一个命令对象的execute()方法来实现配置文件的重新设置
public void recover() {
ArrayList list;
list = FileUtil.readCommands();
for (Object obj : list) {
((Command)obj).execute();
}
}
}
/**
* 工具类：文件操作类
*/
class FileUtil {
//将命令集合写入日志文件
public static void writeCommands(ArrayList commands) {
try {
FileOutputStream file = new FileOutputStream("config.log");
//创建对象输出流用于将对象写入到文件中
ObjectOutputStream objout = new ObjectOutputStream(new BufferedOutputStream(file));
//将对象写入文件
objout.writeObject(commands);
objout.close();
}
catch(Exception e) {
System.out.println("命令保存失败！");
e.printStackTrace();
}
}
//从日志文件中提取命令集合
public static ArrayList readCommands() {
try {
FileInputStream file = new FileInputStream("config.log");
//创建对象输入流用于从文件中读取对象
ObjectInputStream objin = new ObjectInputStream(new BufferedInputStream(file));
//将文件中的对象读出并转换为ArrayList类型
ArrayList commands = (ArrayList)objin.readObject();
objin.close();
return commands;
}
catch(Exception e) {
System.out.println("命令读取失败！");
e.printStackTrace();
return null;
}
}
}
- 命令类
/**
* 抽象命令类: 由于需要将命令对象写入文件，因此它实现了Serializable接口
*/
abstract class Command implements Serializable {
//命令名称
protected String name;
//命令参数
protected String args;
//维持对接收者对象的引用
protected ConfigOperator configOperator;
public Command(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public void setConfigOperator(ConfigOperator configOperator) {
this.configOperator = configOperator;
}
//声明两个抽象的执行方法execute()
public abstract void execute(String args);
public abstract void execute();
}
/**
* 具体命令: 增加命令类
*/
class InsertCommand extends Command {
public InsertCommand(String name) {
super(name);
}
public void execute(String args) {
this.args = args;
configOperator.insert(args);
}
public void execute() {
configOperator.insert(this.args);
}
}
/**
* 具体命令: 修改命令类
*/
class ModifyCommand extends Command {
public ModifyCommand(String name) {
super(name);
}
public void execute(String args) {
this.args = args;
configOperator.modify(args);
}
public void execute() {
configOperator.modify(this.args);
}
}
/**
* 具体命令: 删除命令类
*/
class DeleteCommand extends Command {
public DeleteCommand(String name) {
super(name);
}
public void execute(String args) {
this.args = args;
configOperator.delete(args);
}
public void execute() {
configOperator.delete(this.args);
}
}
- 请求接受者
/**
* 请求接收者
* 配置文件操作类：。由于ConfigOperator类的对象是Command的成员对象，
* 它也将随Command对象一起写入文件，因此ConfigOperator也需要实现Serializable接口
*/
class ConfigOperator implements Serializable {
public void insert(String args) {
System.out.println("增加新节点：" + args);
}
public void modify(String args) {
System.out.println("修改节点：" + args);
}
public void delete(String args) {
System.out.println("删除节点：" + args);
}
}
- 客户端测试
/**
* @author liucheng
* @since 2019/9/3
*/
public class ClientFour {
public static void main(String[] args) {
//定义请求发送者
ConfigSettingWindow csw = new ConfigSettingWindow();
//定义命令对象
Command command;
//定义请求接收者
ConfigOperator co = new ConfigOperator();
//四次对配置文件的更改
command = new InsertCommand("增加");
command.setConfigOperator(co);
csw.setCommand(command);
csw.call("网站首页");
command = new InsertCommand("增加");
command.setConfigOperator(co);
csw.setCommand(command);
csw.call("端口号");
command = new ModifyCommand("修改");
command.setConfigOperator(co);
csw.setCommand(command);
csw.call("网站首页");
command = new ModifyCommand("修改");
command.setConfigOperator(co);
csw.setCommand(command);
csw.call("端口号");
System.out.println("----------------------------");
System.out.println("保存配置");
csw.save();
System.out.println("----------------------------");
System.out.println("恢复配置");
System.out.println("----------------------------");
csw.recover();
}
}
4). 宏命令(Macro Command)
宏命令(Macro Command)又称为组合命令，它是组合模式和命令模式联用的产物。宏命令是一个具体命令类，它拥有一个集合属性，在该集合中包含了对其他命令对象的引用。通常宏命令不直接与请求接收者交互，而是通过它的成员来调用接收者的方法。当调用宏命令的execute()方法时，将递归调用它所包含的每个成员命令的execute()方法，一个宏命令的成员可以是简单命令，还可以继续是宏命令。执行一个宏命令将触发多个具体命令的执行，从而实现对命令的批处理，其结构如图7所示：
组合模式宏命令.png
命令模式是一种使用频率非常高的设计模式，它可以将请求发送者与接收者解耦，请求发送者通过命令对象来间接引用请求接收者，使得系统具有更好的灵活性和可扩展性。在基于GUI的软件开发，无论是在电脑桌面应用还是在移动应用中，命令模式都得到了广泛的应用。
四、拓展
1). 优点
- 降低系统的耦合度。由于请求者与接收者之间不存在直接引用，因此请求者与接收者之间实现完全解耦，相同的请求者可以对应不同的接收者，同样，相同的接收者也可以供不同的请求者使用，两者之间具有良好的独立性。
- 新的命令可以很容易地加入到系统中。由于增加新的具体命令类不会影响到其他类，因此增加新的具体命令类很容易，无须修改原有系统源代码，甚至客户类代码，满足“开闭原则”的要求。
- 可以比较容易地设计一个命令队列或宏命令（组合命令）。
- 为请求的撤销(Undo)和恢复(Redo)操作提供了一种设计和实现方案。
2). 缺点
- 使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个对请求接收者的调用操作都需要设计一个具体命令类，因此在某些系统中可能需要提供大量的具体命令类，这将影响命令模式的使用。
3). 适用场景
- 系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。请求调用者无须知道接收者的存在，也无须知道接收者是谁，接收者也无须关心何时被调用。
- 系统需要在不同的时间指定请求、将请求排队和执行请求。一个命令对象和请求的初始调用者可以有不同的生命期，换言之，最初的请求发出者可能已经不在了，而命令对象本身仍然是活动的，可以通过该命令对象去调用请求接收者，而无须关心请求调用者的存在性，可以通过请求日志文件等机制来具体实现。
- 系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。
- 系统需要将一组操作组合在一起形成宏命令。
