设计模式完结（14）-- 命令模式 --- 请求发送者与接收者解耦

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

            class
             Invoker {  
    
            private
             Command command;  

    
            //
            构造注入  
            public
             Invoker(Command command) {  
        
            this.command = command;  
    }  

    //设值注入  publicvoid setCommand(Command command) {  
        this.command = command;  
    }  

    //业务方法，用于调用命令类的execute()方法  publicvoid call() {  
        command.execute();  
    }  
}

class ConcreteCommand extends Command {  
    private Receiver receiver; //维持一个对请求接收者对象的引用  publicvoid execute() {  
        receiver.action(); //调用请求接收者的业务处理方法action()      }  
}


class Receiver {  
    publicvoid action() {  
        //具体操作      }  
}

            import java.util.*;  

//功能键设置窗口类  class FBSettingWindow {  
    private String title; //窗口标题  
    //定义一个ArrayList来存储所有功能键  private ArrayList<FunctionButton> functionButtons = new ArrayList<FunctionButton>();  

    public FBSettingWindow(String title) {  
        this.title = title;  
    }  

    publicvoid setTitle(String title) {  
        this.title = title;  
    }  

    public String getTitle() {  
        returnthis.title;  
    }  

    publicvoid addFunctionButton(FunctionButton fb) {  
        functionButtons.add(fb);  
    }  

    publicvoid removeFunctionButton(FunctionButton fb) {  
        functionButtons.remove(fb);  
    }  

    //显示窗口及功能键  publicvoid 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() {  
        returnthis.name;  
    }  

    //为功能键注入命令  publicvoid setCommand(Command command) {  
        this.command = command;  
    }  

    //发送请求的方法  publicvoid onClick() {  
        System.out.print("点击功能键：");  
        command.execute();  
    }  
}  

//抽象命令类  abstractclass Command {  
    publicabstractvoid execute();  
}  

//帮助命令类：具体命令类  class HelpCommand extends Command {  
    private HelpHandler hhObj; //维持对请求接收者的引用  public HelpCommand() {  
        hhObj = new HelpHandler();  
    }  

    //命令执行方法，将调用请求接收者的业务方法  publicvoid execute() {  
        hhObj.display();  
    }  
}  

//最小化命令类：具体命令类  class MinimizeCommand extends Command {  
    private WindowHanlder whObj; //维持对请求接收者的引用  public MinimizeCommand() {  
        whObj = new WindowHanlder();  
    }  

//命令执行方法，将调用请求接收者的业务方法  publicvoid execute() {  
        whObj.minimize();  
    }  
}  

//窗口处理类：请求接收者  class WindowHanlder {  
    publicvoid minimize() {  
        System.out.println("将窗口最小化至托盘！");  
    }  
}  

//帮助文档处理类：请求接收者  class HelpHandler {  
    publicvoid display() {  
        System.out.println("显示帮助文档！");  
    }  
}
为了提高系统的灵活性和可扩展性，我们将具体命令类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：
import javax.xml.parsers.*;  
import org.w3c.dom.*;  
import org.xml.sax.SAXException;  
import java.io.*;  

publicclass XMLUtil {  
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象，可以通过参数的不同返回不同类名节点所对应的实例  publicstatic Object getBean(int i) {  
        try {  
            //创建文档对象  
            DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();  
            DocumentBuilder builder = dFactory.newDocumentBuilder();  
            Document doc;                             
            doc = builder.parse(new File("config.xml"));   

            //获取包含类名的文本节点  
            NodeList nl = doc.getElementsByTagName("className");  
            Node classNode = null;  
            if (0 == i) {  
                classNode = nl.item(0).getFirstChild();  
            }  
            else {  
                classNode = nl.item(1).getFirstChild();  
            }   

            String cName = classNode.getNodeValue();  

            //通过类名生成实例对象并将其返回  
            Class c = Class.forName(cName);  
            Object obj = c.newInstance();  
            return obj;  
        }     
        catch(Exception e){  
            e.printStackTrace();  
            returnnull;  
        }  
    }  
}
配置文件config.xml中存储了具体建造者类的类名，代码如下所示：
<?xml version="1.0"?>  
<config>  
    <className>HelpCommand</className>  
    <className>MinimizeCommand</className>  
</config>  
       编写如下客户端测试代码：
[java] view plain copy
class Client {  
    publicstaticvoid main(String args[]) {  
        FBSettingWindow fbsw = new FBSettingWindow("功能键设置");  

        FunctionButton fb1,fb2;  
        fb1 = new FunctionButton("功能键1");  
        fb2 = new FunctionButton("功能键1");  

        Command command1,command2;  
        //通过读取配置文件和反射生成具体命令对象  
        command1 = (Command)XMLUtil.getBean(0);  
        command2 = (Command)XMLUtil.getBean(1);  

        //将命令对象注入功能键          fb1.setCommand(command1);  
        fb2.setCommand(command2);  

        fbsw.addFunctionButton(fb1);  
        fbsw.addFunctionButton(fb2);  
        fbsw.display();  

        //调用功能键的业务方法          fb1.onClick();  
        fb2.onClick();  
    }  
}
编译并运行程序，输出结果如下：
显示窗口：功能键设置
显示功能键：
功能键1
功能键1
------------------------------
点击功能键：显示帮助文档！
点击功能键：将窗口最小化至托盘！

            import java.util.*;  

class CommandQueue {  
    //定义一个ArrayList来存储命令队列  private ArrayList<Command> commands = new ArrayList<Command>();  

    publicvoid addCommand(Command command) {  
        commands.add(command);  
    }  

    publicvoid removeCommand(Command command) {  
        commands.remove(command);  
    }  

    //循环调用每一个命令对象的execute()方法  publicvoid execute() {  
        for (Object command : commands) {  
            ((Command)command).execute();  
        }  
    }  
}
class Invoker {  
    private CommandQueue commandQueue; //维持一个CommandQueue对象的引用  

    //构造注入  public Invoker(CommandQueue commandQueue) {  
        this. commandQueue = commandQueue;  
    }  

    //设值注入  publicvoid setCommandQueue(CommandQueue commandQueue) {  
        this.commandQueue = commandQueue;  
    }  

    //调用CommandQueue类的execute()方法  publicvoid call() {  
        commandQueue.execute();  
    }  
}

            import java.io.*;  
import java.util.*;  

//抽象命令类，由于需要将命令对象写入文件，因此它实现了Serializable接口  abstractclass Command implements Serializable {  
    protected String name; //命令名称  protected String args; //命令参数  protected ConfigOperator configOperator; //维持对接收者对象的引用  public Command(String name) {  
        this.name = name;  
    }  

    public String getName() {  
        returnthis.name;  
    }  

    publicvoid setName(String name) {  
        this.name = name;  
    }  

    publicvoid setConfigOperator(ConfigOperator configOperator) {  
        this.configOperator = configOperator;  
    }  

    //声明两个抽象的执行方法execute()  publicabstractvoid execute(String args);  
    publicabstractvoid execute();  
}  

//增加命令类：具体命令  class InsertCommand extends Command {  
    public InsertCommand(String name) {  
        super(name);  
    }  

    publicvoid execute(String args) {  
        this.args = args;  
        configOperator.insert(args);  
    }  

    publicvoid execute() {  
        configOperator.insert(this.args);  
    }  
}  

//修改命令类：具体命令  class ModifyCommand extends Command {  
    public ModifyCommand(String name) {  
        super(name);  
    }  

    publicvoid execute(String args) {  
        this.args = args;  
        configOperator.modify(args);  
    }  

    publicvoid execute() {  
        configOperator.modify(this.args);  
    }  
}  

//省略了删除命令类DeleteCommand  

//配置文件操作类：请求接收者。由于ConfigOperator类的对象是Command的成员对象，它也将随Command对象一起写入文件，因此ConfigOperator也需要实现Serializable接口  class ConfigOperator implements Serializable {  
    publicvoid insert(String args) {  
        System.out.println("增加新节点：" + args);  
    }  

    publicvoid modify(String args) {  
        System.out.println("修改节点：" + args);  
    }  

    publicvoid delete(String args) {  
        System.out.println("删除节点：" + args);  
    }  
}  

//配置文件设置窗口类：请求发送者  class ConfigSettingWindow {  
    //定义一个集合来存储每一次操作时的命令对象  private ArrayList<Command> commands = new ArrayList<Command>();  
    private Command command;   

    //注入具体命令对象  publicvoid setCommand(Command command) {  
        this.command = command;  
    }  

    //执行配置文件修改命令，同时将命令对象添加到命令集合中  publicvoid call(String args) {  
        command.execute(args);  
        commands.add(command);  
    }  

    //记录请求日志，生成日志文件，将命令集合写入日志文件  publicvoid save() {  
        FileUtil.writeCommands(commands);  
    }  

    //从日志文件中提取命令集合，并循环调用每一个命令对象的execute()方法来实现配置文件的重新设置  publicvoid recover() {  
        ArrayList list;  
        list = FileUtil.readCommands();  

        for (Object obj : list) {  
            ((Command)obj).execute();  
        }  
    }  
}  

//工具类：文件操作类  class FileUtil {  
    //将命令集合写入日志文件  publicstaticvoid 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();  
            }  
    }  

    //从日志文件中提取命令集合  publicstatic 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();  
                returnnull;      
            }         
    }  
}
编写如下客户端测试代码：
class Client {  
    publicstaticvoid 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();    
    }  
}
编译并运行程序，输出结果如下：
增加新节点：网站首页
增加新节点：端口号
修改节点：网站首页
修改节点：端口号
----------------------------
保存配置
----------------------------
恢复配置
----------------------------
增加新节点：网站首页
增加新节点：端口号
修改节点：网站首页
修改节点：端口号