COMMAND 模式
一.概述
命令模式，又称动作模式，目的是将一个请求封装成一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
二.类图
image
三.结构
client：
装配者，用于创建命令对象以及设置命令对象的接收者
receiver:
接收者，封装了命令功能的具体实现，负责接收对象的调用请求并执行请求对应的方法
command
命令接口，规定了命令的执行方法
concretecommand
命令接口的具体实现，通过内部的接收者对象来完成命令要执行的功能
invoker
调用者，一般持有很多命令对象，负责组合，控制命令对象的调用，也是整个模式的核心。
四.实现
使用命令模式模拟文件的复制，粘贴，删除，移动操作
package cn.zzf.command.simple;
/**
* 接受者，也叫执行者
*
* @author GaoFeng2017
* @date 2018-06-02 09:00:40
**/
public class Receiver {
public void copy() {
System.out.println("复制文件");
}
public void paste() {
System.out.println("粘贴文件");
}
public void delete() {
System.out.println("删除文件");
}
public void move() {
System.out.println("移动文件");
}
}
package cn.zzf.command.simple;
/**
* 命令接口
*
* @author GaoFeng2017
* @date 2018-06-02 09:06:10
**/
interface Command {
/**
* 执行的方法
*/
void execute();
}
package cn.zzf.command.simple;
/**
* copy命令实现类
*
* @author GaoFeng2017
* @date 2018-06-02 09:11:52
**/
public class CopyCommand implements Command {
private Receiver receiver;
public CopyCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
receiver.copy();
}
}
package cn.zzf.command.simple;
/**
* delete命令实现类
*
* @author GaoFeng2017
* @date 2018-06-02 09:22:01
**/
public class DeleteCommand implements Command{
private Receiver receiver;
public DeleteCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
receiver.delete();
}
}
package cn.zzf.command.simple;
/**
* @author GaoFeng2017
* @date 2018-06-02 09:31:29
**/
public class MoveCommand implements Command{
private Receiver receiver;
public MoveCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
receiver.move();
}
}
package cn.zzf.command.simple;
/**
* paste命令实现类
*
* @author GaoFeng2017
* @date 2018-06-02 09:16:10
**/
public class PasteCommand implements Command {
private Receiver receiver;
public PasteCommand(Receiver receiver) {
this.receiver = receiver;
}
@Override
public void execute() {
receiver.paste();
}
}
package cn.zzf.command.simple;
/**
* 调用者
* @author GaoFeng2017
* @date 2018-06-02 09:32:56
**/
public class Invoker {
private Command copyCommand;
private Command pasteCommand;
private Command deleteCommand;
public Invoker(Command copyCommand, Command pasteCommand, Command deleteCommand) {
this.copyCommand = copyCommand;
this.pasteCommand = pasteCommand;
this.deleteCommand = deleteCommand;
}
public void action() {
this.copyCommand.execute();
this.pasteCommand.execute();
this.deleteCommand.execute();
}
}
package cn.zzf.command.simple;
/**
* 装配者，用于创建命令对象以及设置命令对象的接收者
*
* @author GaoFeng2017
* @date 2018-06-02 09:40:50
**/
public class Client {
public static void main(String[] args) {
Receiver receiver = new Receiver();
CopyCommand copyCommand = new CopyCommand(receiver);
PasteCommand pasteCommand = new PasteCommand(receiver);
DeleteCommand deleteCommand = new DeleteCommand(receiver);
Invoker invoker = new Invoker(copyCommand,pasteCommand,deleteCommand);
invoker.action();
}
}
运行结果
复制文件
粘贴文件
删除文件
分析
- 在上面案例中，我们似乎没有感觉到这个模式的作用，甚者有点为了模式而模式的感觉，完成文件操作我们只需要在client中调用receiver对象中的方法即可，为何需要通过两个多余对象(invoker,command)来间接调用呢？
- 其实，每个模式都有自己的应用场景，上面的案例并不适合command模式，更多的只是为了展示模式的具体实现。command模式的核心在于将invoker和receiver进行了解耦，通过command的实现类把每个方法变成了对象（把行为抽象为对象），这样灵活了很多，既可以作为参数，又能做持久化。试想一下，如果我们的文件操作需要支持操作记录功能，那直接使用receiver对象的方法就要写很多重复的业务逻辑，但是我们可以在invoker中去编写这些逻辑，每当调用invoker时，便会执行记录逻辑，这些逻辑只存在一个方法中，得到了复用。
- 除了记录调用操作，我们还可以实现请求队列，撤销/恢复，甚至在不同的时间指定请求(两个请求的执行间隔时间不能小于1s)。我们发现，即使请求者不存在了，但是命令对象可能是活动的（持久化）。
五.案例
案例一: 请求队列，Command实现类和Receiver参考上面的实现
package cn.zzf.command.simple;
import java.util.LinkedList;
/**
* 请求队列
*
* @author GaoFeng2017
* @date 2018-06-02 13:14:52
**/
public class QueueInvoker {
private LinkedList<Command> commands = new LinkedList<>();
public void addCommand(Command command) {
commands.add(command);
}
public void removeCommand(Command command) {
commands.remove(command);
}
public void action() {
for (Command command : commands) {
command.execute();
System.out.println("命令" + command + "已被记录");
}
}
}
package cn.zzf.command.simple;
/**
* 装配者，用于创建命令对象以及设置命令对象的接收者
*
* @author GaoFeng2017
* @date 2018-06-02 09:40:50
**/
public class Client {
public static void main(String[] args) {
Receiver receiver = new Receiver();
CopyCommand copyCommand = new CopyCommand(receiver);
PasteCommand pasteCommand = new PasteCommand(receiver);
DeleteCommand deleteCommand = new DeleteCommand(receiver);
// Invoker invoker = new Invoker(copyCommand,pasteCommand,deleteCommand);
QueueInvoker queueInvoker = new QueueInvoker();
queueInvoker.addCommand(new CopyCommand(receiver));
queueInvoker.addCommand(new PasteCommand(receiver));
queueInvoker.addCommand(new DeleteCommand(receiver));
queueInvoker.action();
}
}
运行结果
复制文件
命令cn.zzf.command.simple.CopyCommand@4554617c已被记录
粘贴文件
命令cn.zzf.command.simple.PasteCommand@74a14482已被记录
删除文件
命令cn.zzf.command.simple.DeleteCommand@1540e19d已被记录
案例二：撤销/重做操作，假设有一个画板，点击某个按钮在画板上画圆，画圆完成后，点击撤销按钮，可以撤销刚才画的圆，点击重做，可以把刚才的撤销的圆重新显示出来
package cn.zzf.command.undo;
/**
* @author GaoFeng2017
* @date 2018-06-02 16:01:09
**/
public interface Command {
void execute();
void cancel();
}
package cn.zzf.command.undo;
import java.util.UUID;
/**
* @author GaoFeng2017
* @date 2018-06-02 16:54:43
**/
public class DrawCircleCommand implements Command {
private String id = UUID.randomUUID().toString();
@Override
public void execute() {
//其他逻辑
System.out.println("画圆中....");
}
@Override
public void cancel() {
//其他逻辑
System.out.println("撤销圆...." + id);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
DrawCircleCommand that = (DrawCircleCommand) o;
return id != null ? id.equals(that.id) : that.id == null;
}
@Override
public int hashCode() {
return id != null ? id.hashCode() : 0;
}
}
package cn.zzf.command.undo;
import java.util.Stack;
/**
* @author GaoFeng2017
* @date 2018-06-02 17:06:55
**/
public class Invoker {
private Stack<Command> cancels = new Stack<>();
private Stack<Command> recovers = new Stack<>();
private int cancelCount = 0;
public Invoker() {
}
public void execute(Command command) {
//执行命令
command.execute();
//把执行完的命令放入可撤销栈中
cancels.push(command);
//如果撤销栈超出撤销次数的限制，则删除栈尾的撤销命令
if (cancelCount > 0 && cancels.size() > cancelCount) {
cancels.remove(cancels.size() - 1);
}
//执行新命令后，重做栈要被清空(重做栈是针对撤销栈的)
if (!recovers.isEmpty()) {
recovers.clear();
}
}
public void cancel() {
//撤销栈如果有撤销命令就执行栈顶的命令对象的撤销操作，并从撤销栈中删除，最后存入到重做栈中
if (!cancels.isEmpty()) {
Command command = cancels.pop();
command.cancel();
recovers.push(command);
}
}
public void redo() {
//重做栈如果有重做命令，则执行并删除栈顶的重做命令
if (!recovers.isEmpty()) {
recovers.pop().execute();
}
}
}
package cn.zzf.command.undo;
/**
* @author GaoFeng2017
* @date 2018-06-02 17:14:28
**/
public class Client {
public static void main(String[] args) {
Invoker invoker = new Invoker();
invoker.execute(new DrawCircleCommand());
invoker.execute(new DrawCircleCommand());
invoker.cancel();
invoker.cancel();
invoker.redo();
invoker.redo();
}
}
运行结果
画圆中....7c982650-8eea-483a-9d58-5aecca6bb384
画圆中....3176e910-43d9-4e53-a76c-57f35a6e5cf8
撤销圆....3176e910-43d9-4e53-a76c-57f35a6e5cf8
撤销圆....7c982650-8eea-483a-9d58-5aecca6bb384
画圆中....7c982650-8eea-483a-9d58-5aecca6bb384
画圆中....3176e910-43d9-4e53-a76c-57f35a6e5cf8
六.总结
- 命令模式实现了命令请求和命令执行之间的解耦，使其拥有不同的生命周期。并且将方法抽象为对象，通过单独的执行类来控制方法的调用，可以轻松的进行逻辑复用。
