命令模式(Command Pattern)：将一个请求封装为一个对象，从而让我们可用不同的请求对客户
进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。命令模式是一种对象
行为型模式，其别名为动作(Action)模式或事务(Transaction)模式。
image.png
在命令模式结构图中包含如下几个角色：
● Command（抽象命令类）：抽象命令类一般是一个抽象类或接口，在其中声明了用于执行
请求的execute()等方法，通过这些方法可以调用请求接收者的相关操作。
● ConcreteCommand（具体命令类）：具体命令类是抽象命令类的子类，实现了在抽象命令类
中声明的方法，它对应具体的接收者对象，将接收者对象的动作绑定其中。在实现execute()方
法时，将调用接收者对象的相关操作(Action)。
● Invoker（调用者）：调用者即请求发送者，它通过命令对象来执行请求。一个调用者并不
需要在设计时确定其接收者，因此它只与抽象命令类之间存在关联关系。在程序运行时可以
将一个具体命令对象注入其中，再调用具体命令对象的execute()方法，从而实现间接调用请求
接收者的相关操作。
● Receiver（接收者）：接收者执行与请求相关的操作，它具体实现对请求的业务处理。
自定义功能键
image.png
在图4中：
FBSettingWindow是“功能键设置”界面类，
FunctionButton充当请求调用者，
Command充当抽象命令类，
MinimizeCommand和HelpCommand充当具体命令类，
WindowHanlder和HelpHandler充当请求接收者。
image.png
import java.util.ArrayList;
//功能键设置窗口类
class FBSettingWindow {
private String title; //窗口标题
//定义一个ArrayList来存储所有功能键
private ArrayList<FunctionButton> functionButtons = new ArrayList<FunctionButton>();
public FBSettingWindow(String title) {
this.title = title;
}
public void setTitle(String title) {
this.title = title;
}
public String getTitle() {
return this.title;
}
public void addFunctionButton(FunctionButton fb) {
functionButtons.add(fb);
}
public void removeFunctionButton(FunctionButton fb) {
functionButtons.remove(fb);
}
//显示窗口及功能键
public void display() {
System.out.println("显示窗口：" + this.title);
System.out.println("显示功能键：");
for (Object obj : functionButtons) {
System.out.println(((FunctionButton) obj).getName());
}
System.out.println("------------------------------");
}
}
//功能键类：请求发送者
class FunctionButton {
private String name; //功能键名称
private Command command; //维持一个抽象命令对象的引用
public FunctionButton(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
//为功能键注入命令
public void setCommand(Command command) {
this.command = command;
}
//发送请求的方法
public void onClick() {
System.out.print("点击功能键：");
command.execute();
}
}
//抽象命令类
public abstract class Command {
public abstract void execute();
}
-------------------------------------------------
//帮助命令类：具体命令类
class HelpCommand extends Command {
private HelpHandler hhObj; //维持对请求接收者的引用
public HelpCommand() {
hhObj = new HelpHandler();
}
//命令执行方法，将调用请求接收者的业务方法
public void execute() {
hhObj.display();
}
}
-------------------------------------------------
//最小化命令类：具体命令类
class MinimizeCommand extends Command {
private WindowHanlder whObj; //维持对请求接收者的引用
public MinimizeCommand() {
whObj = new WindowHanlder();
}
//命令执行方法，将调用请求接收者的业务方法
public void execute() {
whObj.minimize();
}
}
//帮助文档处理类：请求接收者
class HelpHandler {
public void display() {
System.out.println("显示帮助文档！");
}
}
---------------------------------------------------
//窗口处理类：请求接收者
class WindowHanlder {
public void minimize() {
System.out.println("将窗口最小化至托盘！");
}
}
class Client {
public static void main(String args[]) {
FBSettingWindow fbsw = new FBSettingWindow("功能键设置");
FunctionButton fb1, fb2;
fb1 = new FunctionButton("功能键1");
fb2 = new FunctionButton("功能键1");
Command command1, command2;
command1 = new HelpCommand();
command2 = new MinimizeCommand();
//将命令对象注入功能键
fb1.setCommand(command1);
fb2.setCommand(command2);
fbsw.addFunctionButton(fb1);
fbsw.addFunctionButton(fb2);
fbsw.display();
//调用功能键的业务方法
fb1.onClick();
fb2.onClick();
}
}
image.png
命令队列的实现
import java.util.ArrayList;
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();
}
}
}
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();
}
}
请求日志
现在Sunny软件公司开发人员希望将对配置文件的操作请求记录在日志文件中，如果网站重新
部署，只需要执行保存在日志文件中的命令对象即可修改配置文件。
image.png
//配置文件设置窗口类：请求发送者
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();
}
}
}
//抽象命令类，由于需要将命令对象写入文件，因此它实现了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);
}
}
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);
}
}
//工具类：文件操作类
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;
}
}
}
class Client {
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();
}
}
宏命令
宏命令(Macro Command)又称为组合命令，它是组合模式和命令模式联用的产物。宏命令是一
个具体命令类，它拥有一个集合属性，在该集合中包含了对其他命令对象的引用。通常宏命
令不直接与请求接收者交互，而是通过它的成员来调用接收者的方法。当调用宏命令的
execute()方法时，将递归调用它所包含的每个成员命令的execute()方法，一个宏命令的成员可
以是简单命令，还可以继续是宏命令。执行一个宏命令将触发多个具体命令的执行，从而实
现对命令的批处理，其结构如图7所示：
image.png
网友评论