设计模式(14)--Command(命令模式)--行为型

最新推荐文章于 2021-01-09 21:11:53 发布

buyaoxx

最新推荐文章于 2021-01-09 21:11:53 发布

阅读量316

点赞数

作者QQ：1095737364 QQ群：123300273 欢迎加入！

1.模式定义:

　命令模式属于对象的行为模式。命令模式又称为行动(Action)模式或交易(Transaction)模式。

　命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化，对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。

2.模式特点:

在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计，使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活。

　　(1)命令模式的本质是对命令进行封装，将发出命令的责任和执行命令的责任分割开。

　　(2)每一个命令都是一个操作：请求的一方发出请求，要求执行一个操作；接收的一方收到请求，并执行操作

　　(3)命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。

　　(4)命令模式使请求本身成为一个对象，这个对象和其他对象一样可以被存储和传递。

　　(5)命令模式的关键在于引入了抽象命令接口，且发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。

3.使用场景:

认为是命令的地方都可以使用命令模式，比如： 1、GUI 中每一个按钮都是一条命令。 2、模拟 CMD。

　　　(1)希望将行为请求者和行为实现者解耦，不直接打交道；

　　　(2)希望分离掉行为请求者一部分的责任，行为请求者只需要将命令发给调用者，不再主动的去让行为实现者产生行为，符合单一职责原则；

　　　(3)希望可以控制执行的命令列表，方便记录,撤销/重做以及事务等功能；

　　　(4)期待可以将请求排队，有序执行；

　　　(5)希望可以将请求组合使用，即支持宏命令；

4.模式实现:

　　　命令模式是对命令的封装。命令模式把发出命令的责任和执行命令的责任分割开，委派给不同的对象。

　　　每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。

下面以一个示意性的系统，说明命令模式的结构:

命令模式涉及到五个角色，它们分别是：

　　(1)客户端(Client)角色：

　　创建一个具体命令(ConcreteCommand)对象并确定其接收者。

public class Client {
    public static void main(String[] args) {
        //创建接收者
        Receiver receiver = new Receiver();
        //创建命令对象，设定它的接收者
        Command command = new ConcreteCommand(receiver);
        //创建请求者，把命令对象设置进去
        Invoker invoker = new Invoker(command);
        //执行方法
        invoker.action();
    }
}

　　(2)命令(Command)角色：

　　声明了一个给所有具体命令类的抽象接口。

public interface Command {
    /**
     * 执行方法
     */
    void execute();
}

　　(3)具体命令(ConcreteCommand)角色：

　　定义一个接收者和行为之间的弱耦合；实现execute()方法，负责调用接收者的相应操作。execute()方法通常叫做执行方法。

public class ConcreteCommand implements Command {
    //持有相应的接收者对象
    private Receiver receiver = null;
    /**
     * 构造方法
     */
    public ConcreteCommand(Receiver receiver){
        this.receiver = receiver;
    }
    @Override
    public void execute() {
        //通常会转调接收者对象的相应方法，让接收者来真正执行功能
        receiver.action();
    }
}

　　(4)请求者(Invoker)角色：

　　负责调用命令对象执行请求，相关的方法叫做行动方法。

public class Invoker {
    /**
     * 持有命令对象
     */
    private Command command = null;
    /**
     * 构造方法
     */
    public Invoker(Command command){
        this.command = command;
    }
    /**
     * 行动方法
     */
    public void action(){    
        command.execute();
    }
}

　　(5)接收者(Receiver)角色：

　　负责具体实施和执行一个请求。任何一个类都可以成为接收者，实施和执行请求的方法叫做行动方法。

public class Receiver {
    /**
     * 真正执行命令相应的操作
     */
    public void action(){
        System.out.println("执行操作");
    }
}

AudioPlayer系统

　　　　小女孩茱丽(Julia)有一个盒式录音机，此录音机有播音(Play)、倒带(Rewind)和停止(Stop)功能，录音机的键盘便是请求者(Invoker)角色；茱丽(Julia)是客户端角色，而录音机便是接收者角色。Command类扮演抽象命令角色，而PlayCommand、StopCommand和RewindCommand便是具体命令类。茱丽(Julia)不需要知道播音(play)、倒带(rewind)和停止(stop)功能是怎么具体执行的，这些命令执行的细节全都由键盘(Keypad)具体实施。茱丽(Julia)只需要在键盘上按下相应的键便可以了。

　　　　录音机是典型的命令模式。录音机按键把客户端与录音机的操作细节分割开来。

　　(1)接收者角色，由录音机类扮演

public class AudioPlayer {    
    public void play(){
        System.out.println("播放...");
    }    
    public void rewind(){
        System.out.println("倒带...");
    }    
    public void stop(){
        System.out.println("停止...");
    }
}

　　(2)抽象命令角色类

public interface Command {
    /**
     * 执行方法
     */
    public void execute();
}

　　(3)具体命令角色类

public class PlayCommand implements Command {
    private AudioPlayer myAudio;    
    public PlayCommand(AudioPlayer audioPlayer){
        myAudio = audioPlayer;
    }
    /**
     * 执行方法
     */
    @Override
    public void execute() {
        myAudio.play();
    }
}
public class RewindCommand implements Command {
    private AudioPlayer myAudio;
    
    public RewindCommand(AudioPlayer audioPlayer){
        myAudio = audioPlayer;
    }
    @Override
    public void execute() {
        myAudio.rewind();
    }
}
public class StopCommand implements Command {
    private AudioPlayer myAudio;    
    public StopCommand(AudioPlayer audioPlayer){
        myAudio = audioPlayer;
    }
    @Override
    public void execute() {
        myAudio.stop();
    }
}

　　(4)请求者角色，由键盘类扮演

public class Keypad {
    private Command playCommand;
    private Command rewindCommand;
    private Command stopCommand;    
    public void setPlayCommand(Command playCommand) {
        this.playCommand = playCommand;
    }
    public void setRewindCommand(Command rewindCommand) {
        this.rewindCommand = rewindCommand;
    }
    public void setStopCommand(Command stopCommand) {
        this.stopCommand = stopCommand;
    }
    /**
     * 执行播放方法
     */
    public void play(){
        playCommand.execute();
    }
    /**
     * 执行倒带方法
     */
    public void rewind(){
        rewindCommand.execute();
    }
    /**
     * 执行播放方法
     */
    public void stop(){
        stopCommand.execute();
    }
}

　　(5)客户端角色，由茱丽小女孩扮演

public class Julia {
    public static void main(String[]args){
        //创建接收者对象
        AudioPlayer audioPlayer = new AudioPlayer();
        //创建命令对象
        Command playCommand = new PlayCommand(audioPlayer);
        Command rewindCommand = new RewindCommand(audioPlayer);
        Command stopCommand = new StopCommand(audioPlayer);
        //创建请求者对象
        Keypad keypad = new Keypad();
        keypad.setPlayCommand(playCommand);
        keypad.setRewindCommand(rewindCommand);
        keypad.setStopCommand(stopCommand);
        //测试
        keypad.play();
        keypad.rewind();
        keypad.stop();
        keypad.play();
        keypad.stop();
    }
}

运行结果如下：

5.优缺点:

　　(1)命令模式的优点：

　　[1]命令模式使新的命令很容易地被加入到系统里。

　　[2]允许接收请求的一方决定是否要否决请求。

　　[3]能较容易地设计一个命令队列。

　　[4]可以容易地实现对请求的撤销和恢复。

　　[5]在需要的情况下，可以较容易地将命令记入日志。

　　[6]将行为调用者和各种行为分隔开,降低程序的耦合，便于程序扩展；

　　[7]将行为的具体实现封装起来，客户端无需关心行为的具体实现；

　　[9]可为多种行为提供统一的调用入口,便于程序对行为的管理和控制；

　　(2)命令模式的缺点：

　　　　[1]使用命令模式的话，不用管命令多简单，都需要写一个命令类来封装，使用命令模式可能会导致系统有过多的具体命令类；

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

　　　　[3]使用命令模式可能会导致某些系统有过多的具体命令类。因为针对每一个命令都需要设计一个具体命令类，因此某些系统可能需要大量具体命令类，这将影响命令模式的使用。

6.宏命令

　　所谓宏命令简单点说就是包含多个命令的命令，是一个命令的组合。

　　设想茱丽的录音机有一个记录功能，可以把一个一个的命令记录下来，再在任何需要的时候重新把这些记录下来的命令一次性执行，这就是所谓的宏命令集功能。因此，茱丽的录音机系统现在有四个键，分别为播音、倒带、停止和宏命令功能。此时系统的设计与前面的设计相比有所增强，主要体现在Julia类现在有了一个新方法，用以操作宏命令键。

　　(1)系统需要一个代表宏命令的接口，以定义出具体宏命令所需要的接口。

public interface MacroCommand extends Command {
    /**
     * 宏命令聚集的管理方法
     * 可以添加一个成员命令
     */
    public void add(Command cmd);
    /**
     * 宏命令聚集的管理方法
     * 可以删除一个成员命令
     */
    public void remove(Command cmd);
}

　　(2)具体的宏命令MacroAudioCommand类负责把个别的命令合成宏命令。

public class MacroAudioCommand implements MacroCommand {
    private List<Command> commandList = new ArrayList<Command>();
    /**
     * 宏命令聚集管理方法
     */
    @Override
    public void add(Command cmd) {
        commandList.add(cmd);
    }
    /**
     * 宏命令聚集管理方法
     */
    @Override
    public void remove(Command cmd) {
        commandList.remove(cmd);
    }
    /**
     * 执行方法
     */
    @Override
    public void execute() {
        for(Command cmd : commandList){
            cmd.execute();
        }
    }
}

　　(3)客户端类Julia

public class Julia {    
    public static void main(String[]args){
        //创建接收者对象
        AudioPlayer audioPlayer = new AudioPlayer();
        //创建命令对象
        Command playCommand = new PlayCommand(audioPlayer);
        Command rewindCommand = new RewindCommand(audioPlayer);
        Command stopCommand = new StopCommand(audioPlayer);        
        MacroCommand marco = new MacroAudioCommand();       
        marco.add(playCommand);
        marco.add(rewindCommand);
        marco.add(stopCommand);
        marco.execute();
    }
}

运行结果如下：

7.撤销命令

有两种基本的思路来实现可撤销的操作：

　　　　 (1)逆向操作实现：比如被撤销的操作是添加功能，那撤消的实现就变成删除功能；同理被撤销的操作是删除功能，那么撤销的实现就变成添加功能；

　　　　 (2)存储恢复实现，意思就是把操作前的状态记录下来，然后要撤销操作的时候就直接恢复回去就可以了，可使用备忘录模式(Memento Pattern)来实现（稍后会讲到备忘录模式）;

这里主要讲解通过逆向操作来实现撤销(undo)：

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

　　实例说明：

/**
 * 包含撤销命令的接口
 * @author 
*/
public interface Command {
    //执行方法
    void execute();
    //撤销方法
    void undo();
}
/**
 * 具体命令 -- 创建目录
 * @author
*/
public class CreateDirCommand implements Command {
    private String dirName;
    MakeDir makeDir;
    public CreateDirCommand(MakeDir makeDir,String dirName) {
        this.makeDir = makeDir;
        this.dirName = dirName;
    }
    @Override
    public void execute() {
        makeDir.createDir(dirName);
    }
    
    @Override
    public void undo() {
        makeDir.deleteDir(dirName);
    }
}
/**
 * 命令接受者
 * 包含两个命令：创建目录、删除目录
 * @author 
*/
public class MakeDir {
    //创建目录
    public void createDir(String name){
        File dir = new File(name);
        if (dir.exists()) {  
            System.out.println("创建目录 " + name + " 失败，目标目录已经存在");  
        }else{
            //创建目录  
            if (dir.mkdirs()) {
                System.out.println("创建目录 " + name + " 成功");  
            } else {  
                System.out.println("创建目录 " + name + " 失败");  
            }  
        } 
    }
    //删除目录
    public void deleteDir(String name){
        File dir = new File(name);
        if(dir.exists()) {  
            if(dir.delete()){
                System.out.println("删除目录 " + name + " 成功");
            }else{
                System.out.println("删除目录 " + name + " 失败");
            }
        }else{
            System.out.println("删除目录 " + name + " 失败，目标目录不存在");
        }
    }
}
/**
 * 请求者
 * @author
*/
public class RequestMakeDir {
    Command createCommand;
    public void setCreateCommand(Command command) {
        this.createCommand = command;
    }
    public void executeCreateCommand(){
        createCommand.execute();
    }    
    public void undoCreateCommand(){
        createCommand.undo();
    }
}

测试：

/**
 * 测试
 * @author 
*/
public class Client {
    public static void main(String[] args) {
        String dir = "E:\\command2017";
        
        //创建接收者
        MakeDir makeDir = new MakeDir(); 
        //创建具体命令并且指定接收者
        Command create_command = new CreateDirCommand(makeDir,dir);
        //创建请求者
        RequestMakeDir request = new RequestMakeDir();
        //设置命令
        request.setCreateCommand(create_command);
        /***********创建目录及撤销**************/
        //创建目录
        request.executeCreateCommand();
        //撤销
        request.undoCreateCommand();
    }
}

结果：

创建目录 E:\command2017 成功
删除目录 E:\command2017 成功

8.多次撤销

　　我们在使用文本编辑器的时候，经常会遇到撤销的操作，这是就按一下组合键（Ctrl + Z），就会回到上次修改，至于代码要如何实现？

　　首先还是要先实现各个命令的undo行为（执行与execute相反顺序的操作即可），另外我们还需要一个栈来记录已经被执行过的操作，以支持撤销到初始状态；

　　下面来改造一下实例：

/**
 * 包含撤销命令的接口
 * @author 
*/
public interface Command {
    //执行方法
    void execute(String dirName);
    //撤销方法
    void undo();
}
/**
 * 具体命令 -- 创建目录
 * @author 
*/
public class CreateDirCommand implements Command {
    private ArrayList<String> dirNameList; //记录 这里用list实现
    private MakeDir makeDir;
    public CreateDirCommand(MakeDir makeDir) {
        dirNameList = new ArrayList<String>();
        this.makeDir = makeDir;
    }
    
    @Override
    public void execute(String dirName) {
        makeDir.createDir(dirName);
        dirNameList.add(dirName);
    }
    
    @Override
    public void undo() {
        if(dirNameList.size()>0){
            makeDir.deleteDir(dirNameList.get(dirNameList.size()-1));
            dirNameList.remove(dirNameList.size()-1);
        }else{
             System.out.println("没有需要撤销的操作！");
        }
    }
}
/**
 * 命令接受者
 * 包含两个命令：创建目录、删除目录
 * @author 
*/
public class MakeDir {
    //创建目录
    public void createDir(String name){
        File dir = new File(name);
        if (dir.exists()) {  
            System.out.println("创建目录 " + name + " 失败，目标目录已经存在");  
        }else{
            //创建目录  
            if (dir.mkdirs()) {
                System.out.println("创建目录 " + name + " 成功");  
            } else {  
                System.out.println("创建目录 " + name + " 失败");  
            }  
        } 
    }
    //删除目录
    public void deleteDir(String name){
        File dir = new File(name);
        if(dir.exists()) {  
            if(dir.delete()){
                System.out.println("删除目录 " + name + " 成功");
            }else{
                System.out.println("删除目录 " + name + " 失败");
            }
        }else{
            System.out.println("删除目录 " + name + " 失败，目标目录不存在");
        }
    }
}
/**
 * 请求者
 * @author 
*/
public class RequestMakeDir {
    Command createCommand;
    public void setCreateCommand(Command command) {
        this.createCommand = command;
    }
    public void executeCreateCommand(String dirName){
        createCommand.execute(dirName);
    }
    public void undoCreateCommand(){
        createCommand.undo();
    }
}

测试：

/**
 * 测试
 * @author 
*/
public class Client {
    public static void main(String[] args) {
        //创建接收者
        MakeDir makeDir = new MakeDir(); 
        //创建具体命令并且指定接收者
        Command create_command = new CreateDirCommand(makeDir);
        //创建请求者
        RequestMakeDir request = new RequestMakeDir();
        //设置命令
        request.setCreateCommand(create_command);
        /***********创建目录及撤销**************/
        //创建目录
        request.executeCreateCommand("E:\\command\\2017");
        request.executeCreateCommand("E:\\command\\2018");
        request.executeCreateCommand("E:\\command\\2019");
        request.executeCreateCommand("E:\\command\\2020");
        //多次撤销
        request.undoCreateCommand();
        request.undoCreateCommand();
        request.undoCreateCommand();
        request.undoCreateCommand();
        request.undoCreateCommand();
    }
}

结果：

创建目录 E:\command\2017 成功
创建目录 E:\command\2018 成功
创建目录 E:\command\2019 成功
创建目录 E:\command\2020 成功
删除目录 E:\command\2020 成功
删除目录 E:\command\2019 成功
删除目录 E:\command\2018 成功
删除目录 E:\command\2017 成功
没有需要撤销的操作！

上面的例子存在瑕疵：不知道大家有没有看出来：

　　我们没有保存命令对象的历史状态（执行情况，比如成功、失败），可以通过引入一个命令集合或其他方式来存储每一次操作时命令的状态，这样实现多次撤销操作就完美了

9.命令队列

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

　　命令队列的实现方法有多种形式，其中最常用、灵活性最好的一种方式是增加一个CommandQueue类，由该类来负责存储多个命令对象，而不同的命令对象可以对应不同的请求接收者；

下面实例讲解：

/**
 * 抽象命令角色类
 * @author 
*/
public interface Command {
     /**
     * 执行方法
     */
    void execute();
}
/**
 * 接收者角色类 - Java工程师
 * @author 
*/
public class JavaCoder {
     /**
     * 真正执行命令相应的操作
     */
    public void work(String task){
        System.out.println("java工程师要完成【"+task+"】");
    }
}
/**
 * 接收者角色类 - H5工程师
 * @author 
*/
public class H5Coder {
    /**
     * 真正执行命令相应的操作
     */
    public void work(String task){
        System.out.println("H5工程师要完成【"+task+"】");
    }
}
/**
 * 具体命令 -- Java工程师执行任务
 * @author 
*/
public class JavaCommand implements Command{
    //持有相应的接收者对象
    private JavaCoder javaCoder;
    //具体任务
    private String task;
    /**
     * 构造方法
     */
    public JavaCommand(JavaCoder javaCoder,String task){
        this.javaCoder = javaCoder;
        this.task = task;
    }
    
    @Override
    public void execute() {
        //通常会转调接收者对象的相应方法，让接收者来真正执行功能
        javaCoder.work(this.task);
    }
}
/**
 * 具体命令 -- H5工程师执行任务
 * @author 
*/
public class H5Command implements Command{
    //持有相应的接收者对象
    private H5Coder h5Coder;
    //具体任务
    private String task;
    /**
     * 构造方法
     */
    public H5Command(H5Coder h5Coder,String task){
        this.h5Coder = h5Coder;
        this.task = task;
    }
    
    @Override
    public void execute() {
        //通常会转调接收者对象的相应方法，让接收者来真正执行功能
        h5Coder.work(this.task);
    }
}
/**
 * CommandQueue命令队列类
 * @author 
*/
public 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(Command command : commands) {    
            command.execute();    
        }    
    }    
}
/**
 * 请求发送者类Manager针对CommandQueue编程
 * @author 
*/
public class Manager {
    private CommandQueue commandQueue; //维持一个CommandQueue对象的引用    
     
    //构造注入    
    public Manager(CommandQueue commandQueue) {
        this. commandQueue = commandQueue;    
    }    
        
    //设值注入    
    public void setCommandQueue(CommandQueue commandQueue) {    
        this.commandQueue = commandQueue;    
    }    
        
    //调用CommandQueue类的execute()方法    
    public void call() {    
        commandQueue.execute();    
    }    
}

测试：

/**
 * 
 * @author 
*/
public class Client {
    public static void main(String[] args) {
        //创建接收者
        JavaCoder javaCoder = new JavaCoder();
        H5Coder h5Coder = new H5Coder();
         //创建命令对象
        JavaCommand javaCommand = new JavaCommand(javaCoder,"登录模块的后台代码");
        H5Command h5Command = new H5Command(h5Coder,"登录模块的前台代码");
        //创建命令对象队列
        CommandQueue commandqueue = new CommandQueue();
        commandqueue.addCommand(javaCommand);
        commandqueue.addCommand(h5Command);
        //创建请求者，把命令对象设置进去
        Manager manager = new Manager(commandqueue);
        //执行方法
        manager.call();
    }
}

结果：

java工程师要完成【登录模块的后台代码】
H5工程师要完成【登录模块的前台代码】

上面简单只是实现，旨在了解命令队列的结构：

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

10.请求日志

　　概念：将所有的动作都记录在日志中，并能在系统死机后，重新调用这些动作恢复到之前的状态。当我们执行命令的时候，将历时记录存储在磁盘中。一旦系统死机，我们就可以将命令对象重新加载，并依次调用这些对象的execute()方法。

　　实现方法：利用对象的序列化把对象保存起来（记录日志），在需要的时候反序列化（恢复事务）。

请求日志文件可以实现很多功能，常用功能如下：

　　　　(1)什么事情都存在意外，如一旦系统发生故障，日志文件可以为系统提供一种恢复机制，在请求日志文件中可以记录用户对系统的每一步操作，从而让系统能够顺利恢复到某一个特定的状态；

　　　　(2)请求日志也可以用于实现批处理，在一个请求日志文件中可以存储一系列命令对象，例如一个命令队列；

　　　　(3)可以将命令队列中的所有命令对象都存储在一个日志文件中，每执行一个命令则从日志文件中删除一个对应的命令对象，防止因为断电或者系统重启等原因造成请求丢失，而且可以避免重新发送全部请求时造成某些命令的重复执行，只需读取请求日志文件，再继续执行文件中剩余的命令即可。

　　模拟场景（未必真实，领会实质即可）：

　　　　假如数据库被DBA误操作了，数据全删除了，因为两小时备份了一次数据库，所以现在只能恢复到两小时前的数据；这岂不是很悲剧；要被开除的节奏；还要赔偿公司经济损失；瞬间感觉要死的节奏；

　　　　要是在程序里加上请求日志，这个算个鸟，分分钟恢复；

　　　　我们把程序执行的所有sql记录下来，这里假设sql都是在这两小时执行的（比较理想，具体情境具体解决）；

　　 代码来了：

/**
 * 抽象命令类，由于需要将命令对象写入文件，因此它实现了Serializable接口  
 * @author 
*/
public abstract class Command implements Serializable {
    private static final long serialVersionUID = 1L;
    
    protected String name; //命令名称 
    protected String args; //命令参数  
    protected Operator operator; //接收者对象
    public Command(String name) {  
        this.name = name;
    }        
    public String getName() {  
        return this.name;  
    }       
    public void setName(String name) {  
        this.name = name;  
    }        
    public void setOperator(Operator operator) {  
        this.operator = operator;  
    }      
    //声明两个抽象的执行方法execute()  
      public abstract void execute(String args);  
      public abstract void execute();
}
/**
 * 请求接收者 -- 由于Operator类的对象是Command的成员对象，它也将随Command对象一起写入文件，因此Operator也需要实现Serializable接口  
 * @author 
*/
public class Operator implements Serializable{
    private static final long serialVersionUID = 1L;

    public void insert(String args) {  
        System.out.println("新增数据：" + args);  
    }  
      
    public void update(String args) {  
        System.out.println("修改数据：" + args);  
    }  
      
    public void delete(String args) {  
        System.out.println("删除数据：" + args);  
    }  
}
/**
 * 具体命令角色类 -- 插入命令
 * @author 
*/
public class InsertCommand extends Command{
    public InsertCommand(String name) {
        super(name);
    }

    public void execute(String args) {  
        this.args = args;  
        operator.insert(args);  
    }  
      
    public void execute() {  
        operator.insert(this.args);  
    }  
}
/**
 * 具体命令角色类 -- 修改命令
 * @author 
*/
public class UpdateCommand extends Command{
    public UpdateCommand(String name) {
        super(name);
    }

    public void execute(String args) {  
        this.args = args;  
        operator.update(args);  
    }  
      
    public void execute() {  
        operator.update(this.args);  
    }  
}
/**
 * 具体命令角色类 -- 删除命令
 * @author 
*/
public class DeleteCommand extends Command{
    public DeleteCommand(String name) {
        super(name);
    }

    public void execute(String args) {  
        this.args = args;  
        operator.delete(args);  
    }  
      
    public void execute() {  
        operator.delete(this.args);  
    }  
}
import com.designpattern.utils.FileUtil;
/**
 * 请求发送者
 * @author 
*/
public class SqlExecuteTool {
     //定义一个集合来存储每一次操作时的命令对象  
    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 = FileUtil.readCommands();  
        for (Object obj : list) {  
            ((Command)obj).execute();  
        }  
    }  
}

测试：

package com.designpattern.Command.extend.RequestLog;
/**
 * 测试
 * @author 
*/
public class Client {
    public static void main(String[] args) {
        SqlExecuteTool tool = new SqlExecuteTool(); //定义请求发送者  
        Operator operator = new Operator(); //定义请求接收者  
          
        Command command;
        
        //执行了很多次SQL
        command = new InsertCommand("增加");  
        command.setOperator(operator);   
        tool.setCommand(command);  
        tool.call("insert xxx");  
          
        command = new InsertCommand("增加");  
        command.setOperator(operator);  
        tool.setCommand(command);  
        tool.call("insert xxx");  
          
        command = new UpdateCommand("修改"); 
        command.setOperator(operator); 
        tool.setCommand(command);  
        tool.call("update xxx");  
          
        command = new DeleteCommand("删除");
        command.setOperator(operator);  
        tool.setCommand(command);          
        tool.call("delete xxx");  
          
        System.out.println("-------------------------------------");
        System.out.println("保存执行的sql");  
        tool.save();
        System.out.println("-------------------------------------");
        System.out.println("恢复执行的sql");  
        System.out.println("-------------------------------------");
        tool.recover(); 
    }
}

结果：

新增数据：insert xxx
新增数据：insert xxx
修改数据：update xxx
删除数据：delete xxx
-------------------------------------
保存执行的sql
-------------------------------------
恢复执行的sql
-------------------------------------
新增数据：insert xxx
新增数据：insert xxx
修改数据：update xxx
删除数据：delete xxx

这里把这两小时的sql又执行了一遍，是不是相当于数据全部恢复了？