侧边栏壁纸
博主头像
孔子说JAVA博主等级

成功只是一只沦落在鸡窝里的鹰,成功永远属于自信且有毅力的人!

  • 累计撰写 285 篇文章
  • 累计创建 125 个标签
  • 累计收到 4 条评论

目 录CONTENT

文章目录

JAVA设计模式之命令模式

孔子说JAVA
2019-12-02 / 0 评论 / 0 点赞 / 103 阅读 / 9,904 字 / 正在检测是否收录...

1、命令模式(Command)的定义

命令模式(Command Pattern)是一种数据驱动的设计模式,它属于行为型模式。其别名为动作(Action)模式或事务(Transaction)模式。请求以命令的形式包裹在对象中,并传给调用对象。调用对象寻找可以处理该命令的合适的对象,并把该命令传给相应的对象,该对象执行命令。(将一个请求封装成一个对象,从而使您可以用不同的请求对客户进行参数化。)

  • 命令模式的本质是对请求进行封装,一个请求对应于一个命令,将发出命令的责任和执行命令的责任分割开。每一个命令都是一个操作:请求的一方发出请求要求执行一个操作;接收的一方收到请求,并执行相应的操作。
  • 命令模式允许请求的一方和接收的一方独立开来,使得请求的一方不必知道接收请求的一方的接口,更不必知道请求如何被接收、操作是否被执行、何时被执行,以及是怎么被执行的。

2、模式(Command)优缺点

命令模式是一种行为型设计模式,其主要优缺点如下:

优点:

  1. 请求发送者和接收者完全解耦,发送者与接收者之间没有直接引用关系,降低了系统耦合度。
  2. 新的命令可以很容易添加到系统中去。由于增加新的具体命令类不会影响到其他类,因此增加新的具体命令类很容易,无须修改原有系统源代码,甚至客户类代码,满足“开闭原则”的要求。
  3. 可以比较容易地设计一个命令队列或宏命令(组合命令)。
  4. 为请求的撤销(Undo)和恢复(Redo)操作提供了一种设计和实现方案。

缺点:

  1. 使用命令模式可能会导致某些系统有过多的具体命令类。

3、模式(Command)适用环境

  1. 系统需要在不同的时间指定请求、将请求排队和执行请求。一个命令对象和请求的初始调用者可以有不同的生命期,换言之,最初的请求发出者可能已经不在了,而命令对象本身仍然是活动的,可以通过该命令对象去调用请求接收者,而无须关心请求调用者的存在性,可以通过请求日志文件等机制来具体实现。
  2. 系统需要将请求调用者和请求接收者解耦,使得调用者和接收者不直接交互。请求调用者无须知道接收者的存在,也无须知道接收者是谁,接收者也无须关心何时被调用。
  3. 系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作
  4. 系统需要将一组操作组合在一起形成宏命令。认为是命令的地方都可以使用命令模式,比如: GUI 中每一个按钮都是一条命令。

4、模式(Command)的结构

image-1649477647266

在命令模式结构图中包含如下几个角色:

  • Command(抽象命令类): 抽象命令类一般是一个抽象类或接口,在其中声明了用于执行请求的execute()等方法,通过这些方法可以调用请求接收者的相关操作。
  • ConcreteCommand(具体命令类): 具体命令类是抽象命令类的子类,实现了在抽象命令类中声明的方法,它对应具体的接收者对象,将接收者对象的动作绑定其中。在实现execute()方法时,将调用接收者对象的相关操作(Action)。
  • Invoker(调用者): 调用者即请求发送者,它通过命令对象来执行请求。一个调用者并不需要在设计时确定其接收者,因此它只与抽象命令类之间存在关联关系。在程序运行时可以将一个具体命令对象注入其中,再调用具体命令对象的execute()方法,从而实现间接调用请求接收者的相关操作。
  • Receiver(接收者): 接收者执行与请求相关的操作,它具体实现对请求的业务处理。

命令模式的关键在于引入了抽象命令类,请求发送者针对抽象命令类编程,只有实现了抽象命令类的具体命令才与请求接收者相关联。在最简单的抽象命令类中只包含了一个抽象的execute()方法,每个具体命令类将一个Receiver类型的对象作为一个实例变量进行存储,从而具体指定一个请求的接收者,不同的具体命令类提供了execute()方法的不同实现,并调用不同接收者的请求处理方法。

5、模式(Command)的应用实例

抽象命令类和具体命令类代码,具体命令类继承了抽象命令类,它与请求接收者相关联,实现了在抽象命令类中声明的execute()方法,并在实现时调用接收者的请求响应方法action()。

假设有一个遥控器,作为请求发送者,一个电灯泡,作为请求接受者,还有请求类和电灯泡请求类。

请求接受者,灯泡Bubble

public class Bubble {
	public void on(){
		System.out.println("bubble on");
	}
}

抽象命令类Command

public abstract class Command {
	public abstract void execute();
}

电灯泡请求类(具体命令) ,BubbleCommand,其中有一个Bubble的引用,通过构造器注入,execute方法里,调用bubble的on方法

public class BubbleCommand extends Command {
	Bubble bubble=null;
	public BubbleCommand(Bubble bubble) {
		this.bubble=bubble;
	}
		
	public void setBubble(Bubble bubble) {
		this.bubble = bubble;
	}
 
	@Override
	public void execute() {
		bubble.on();
	}
}

请求发送类(遥控器)RemoteControl ,其中有请求的引用,构造器注入,action方法调用command的execute方法

public class RemoteControl {
	Command command=null;
	public RemoteControl(Command command) {
		this.command=command;
	}
	
	public void action() {
		command.execute();
	}
}

测试类代码

public class Client {
 	public static void main(String[] args) {
		BubbleCommand command=new BubbleCommand(new Bubble());
		RemoteControl remoteControl=new RemoteControl(command);
		remoteControl.action();
	}
}

如果需要修改遥控器按键的功能,例如某个功能键可以实现开启电风扇,只需要对应增加一个新的具体命令类,在该命令类与电风扇之间创建一个关联关系,然后将该具体命令类的对象通过注入到遥控器中即可,原有代码无须修改,符合“开闭原则”。在此过程中,每一个具体命令类对应一个请求的处理者(接收者),通过向请求发送者注入不同的具体命令对象可以使得相同的发送者对应不同的接收者,从而实现“将一个请求封装为一个对象,用不同的请求对客户进行参数化”,客户端只需要将具体命令对象作为参数注入请求发送者,无须直接操作请求的接收者。

6、模式(Command)的撤销

在命令模式中,我们可以通过调用一个命令对象的execute()方法来实现对请求的处理,如果需要撤销(Undo)请求,可通过在命令类中增加一个逆向操作来实现。

  • 除了通过一个逆向操作来实现撤销(Undo)外,还可以通过保存对象的历史状态来实现撤销,后者可使用备忘录模式(Memento Pattern)来实现。

如上面的灯泡例子所示,现在给execute方法增加参数,false为灯泡关闭,true为灯泡打开

public class Bubble {
	public void on(){
		System.out.println("bubble on");
	}
	
	public void off(){
		System.out.println("bubble off");
	}
}

给command的execute加上boolean参数isOn,当true就打开灯,false就关上。给command加上undo方法,撤销上一步操作。

public abstract class Command {
	public abstract void execute(boolean isOn);
	public abstract void undo();
}

给BubbleCommand,加上lastStatus变量,存放最近一次操作的isOn参数的值,在execute方法内设置它。undo方法内,根据lastStatus,来反转上一步的操作。

public class BubbleCommand extends Command {
 
	Bubble bubble=null;
	boolean lastStatus;
	public BubbleCommand(Bubble bubble) {
		this.bubble=bubble;
	}
		
	public void setBubble(Bubble bubble) {
		this.bubble = bubble;
	}
	
	@Override
	public void execute(boolean isOn) {
		this.lastStatus=isOn;
		if(isOn){
			bubble.on();
		}
		else{
			bubble.off();
		}		
	}
	
	@Override
	public void undo(){
		if(lastStatus){
			bubble.off();
		}
		else{
			bubble.on();
		}	
	}
}

remoteControl内设置undo方法,用来调用command的undo方法

public class RemoteControl {
	Command command=null;
	public RemoteControl(Command command) {
		this.command=command;
	}
	
	public void action(boolean isOn) {
		command.execute(isOn);
	}
	
	public void undo(){
		command.undo();
	}
}

测试类

public class Client {
	public static void main(String[] args) {
		BubbleCommand command=new BubbleCommand(new Bubble());
		RemoteControl remoteControl=new RemoteControl(command);
		remoteControl.action(true);
		remoteControl.action(false);
		remoteControl.undo();
	}
}

/**
bubble on
bubble off
bubble on
*/

撤销off操作,灯又被打开了。

需要注意的是在本实例中只能实现一步撤销操作,因为没有保存命令对象的历史状态,可以通过引入一个命令集合或其他方式来存储每一次操作时命令的状态,从而实现多次撤销操作。除了Undo操作外,还可以采用类似的方式实现恢复(Redo)操作,即恢复所撤销的操作(或称为二次撤销)。

命令模式的命令队列

有时候我们需要将多个请求排队,当一个请求发送者发送一个请求时,将不止一个请求接收者产生响应,这些请求接收者将逐个执行业务方法,完成对请求的处理。此时,我们可以通过命令队列来实现。

  • 命令队列的实现方法有多种形式,其中最常用、灵活性最好的一种方式是增加一个CommandQueue类,由该类来负责存储多个命令对象,而不同的命令对象可以对应不同的请求接收者,CommandQueue类的典型代码如下所示:
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();  
        }  
    }  
}

在增加了命令队列类CommandQueue以后,请求发送者类Invoker将针对CommandQueue编程,代码修改如下:

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();  
    }  
}

命令队列与我们常说的“批处理”有点类似。批处理,顾名思义,可以对一组对象(命令)进行批量处理,当一个发送者发送请求后,将有一系列接收者对请求作出响应,命令队列可以用于设计批处理应用程序,如果请求接收者的接收次序没有严格的先后次序,我们还可以使用多线程技术来并发调用命令对象的execute()方法,从而提高程序的执行效率。

命令模式的请求日志

请求日志就是将请求的历史记录保存下来,通常以日志文件(Log File)的形式永久存储在计算机中。很多系统都提供了日志文件,例如Windows日志文件、Oracle日志文件等,日志文件可以记录用户对系统的一些操作(例如对数据的更改)。请求日志文件可以实现很多功能,常用功能如下:

  • (1) “天有不测风云”,一旦系统发生故障,日志文件可以为系统提供一种恢复机制,在请求日志文件中可以记录用户对系统的每一步操作,从而让系统能够顺利恢复到某一个特定的状态;
  • (2) 请求日志也可以用于实现批处理,在一个请求日志文件中可以存储一系列命令对象,例如一个命令队列;
  • (3) 可以将命令队列中的所有命令对象都存储在一个日志文件中,每执行一个命令则从日志文件中删除一个对应的命令对象,防止因为断电或者系统重启等原因造成请求丢失,而且可以避免重新发送全部请求时造成某些命令的重复执行,只需读取请求日志文件,再继续执行文件中剩余的命令即可。

在实现请求日志时,我们可以将命令对象通过序列化写到日志文件中,此时命令类必须实现Java.io.Serializable接口。

本实例完整代码如下所示:

可以看到command里面有args和name变量,当重新调用execute方法,就用里面的args。

在请求发送者里面有一个arraylist,放置所有用到的command,将他们写到文件,再读取出来,调用其中的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);  
    }  
}  
 
//省略了删除命令类DeleteCommand  
 
//配置文件操作类:请求接收者。由于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);  
    }  
}  
 
//配置文件设置窗口类:请求发送者  
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;      
            }         
    }  
}

编写如下客户端测试代码:

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();    
    }  
}
/**
增加新节点:网站首页
增加新节点:端口号
修改节点:网站首页
修改节点:端口号
----------------------------
保存配置
----------------------------
恢复配置
----------------------------
增加新节点:网站首页
增加新节点:端口号
修改节点:网站首页
修改节点:端口号
*/
0

评论区