请求发送者与接收者解耦——命令模式（二）

3 完整解决方案

为了降低功能键与功能处理类之间的耦合度，让用户可以自定义每一个功能键的功能，Sunny软件公司开发人员使用命令模式来设计“自定义功能键”模块，其核心结构如图4所示：

请求发送者与接收者解耦——命令模式（二） - 图1

图4 自定义功能键核心结构图

在图4中，FBSettingWindow是“功能键设置”界面类，FunctionButton充当请求调用者，Command充当抽象命令类，MinimizeCommand和HelpCommand充当具体命令类，WindowHanlder和HelpHandler充当请求接收者。完整代码如下所示：

  1. import java.util.*;  
  3. //功能键设置窗口类  
  4. class FBSettingWindow {  
  5.     private String title; //窗口标题  
  6.     //定义一个ArrayList来存储所有功能键  
  7.     private ArrayList<FunctionButton> functionButtons = new ArrayList<FunctionButton>();  
  9.     public FBSettingWindow(String title) {  
  10.         this.title = title;  
  11.     }  
  13.     public void setTitle(String title) {  
  14.         this.title = title;  
  15.     }  
  17.     public String getTitle() {  
  18.         return this.title;  
  19.     }  
  21.     public void addFunctionButton(FunctionButton fb) {  
  22.         functionButtons.add(fb);  
  23.     }  
  25.     public void removeFunctionButton(FunctionButton fb) {  
  26.         functionButtons.remove(fb);  
  27.     }  
  29.     //显示窗口及功能键  
  30.     public void display() {  
  31.         System.out.println("显示窗口：" + this.title);  
  32.         System.out.println("显示功能键：");  
  33.         for (Object obj : functionButtons) {  
  34.             System.out.println(((FunctionButton)obj).getName());  
  35.         }  
  36.         System.out.println("------------------------------");  
  37.     }     
  38. }  
  40. //功能键类：请求发送者  
  41. class FunctionButton {  
  42.     private String name; //功能键名称  
  43.     private Command command; //维持一个抽象命令对象的引用  
  45.     public FunctionButton(String name) {  
  46.         this.name = name;  
  47.     }  
  49.     public String getName() {  
  50.         return this.name;  
  51.     }  
  53.     //为功能键注入命令  
  54.     public void setCommand(Command command) {  
  55.         this.command = command;  
  56.     }  
  58.     //发送请求的方法  
  59.     public void onClick() {  
  60.         System.out.print("点击功能键：");  
  61.         command.execute();  
  62.     }  
  63. }  
  65. //抽象命令类  
  66. abstract class Command {  
  67.     public abstract void execute();  
  68. }  
  70. //帮助命令类：具体命令类  
  71. class HelpCommand extends Command {  
  72.     private HelpHandler hhObj; //维持对请求接收者的引用  
  74.     public HelpCommand() {  
  75.         hhObj = new HelpHandler();  
  76.     }  
  78.     //命令执行方法，将调用请求接收者的业务方法  
  79.     public void execute() {  
  80.         hhObj.display();  
  81.     }  
  82. }  
  84. //最小化命令类：具体命令类  
  85. class MinimizeCommand extends Command {  
  86.     private WindowHanlder whObj; //维持对请求接收者的引用  
  88.     public MinimizeCommand() {  
  89.         whObj = new WindowHanlder();  
  90.     }  
  92. //命令执行方法，将调用请求接收者的业务方法  
  93.     public void execute() {  
  94.         whObj.minimize();  
  95.     }  
  96. }  
  98. //窗口处理类：请求接收者  
  99. class WindowHanlder {  
  100.     public void minimize() {  
  101.         System.out.println("将窗口最小化至托盘！");  
  102.     }  
  103. }  
  105. //帮助文档处理类：请求接收者  
  106. class HelpHandler {  
  107.     public void display() {  
  108.         System.out.println("显示帮助文档！");  
  109.     }  
  110. }

为了提高系统的灵活性和可扩展性，我们将具体命令类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：

  1. import javax.xml.parsers.*;  
  2. import org.w3c.dom.*;  
  3. import org.xml.sax.SAXException;  
  4. import java.io.*;  
  6. public class XMLUtil {  
  7. //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象，可以通过参数的不同返回不同类名节点所对应的实例  
  8.     public static Object getBean(int i) {  
  9.         try {  
  10.             //创建文档对象  
  11.             DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();  
  12.             DocumentBuilder builder = dFactory.newDocumentBuilder();  
  13.             Document doc;                             
  14.             doc = builder.parse(new File("config.xml"));   
  16.             //获取包含类名的文本节点  
  17.             NodeList nl = doc.getElementsByTagName("className");  
  18.             Node classNode = null;  
  19.             if (0 == i) {  
  20.                 classNode = nl.item(0).getFirstChild();  
  21.             }  
  22.             else {  
  23.                 classNode = nl.item(1).getFirstChild();  
  24.             }   
  26.             String cName = classNode.getNodeValue();  
  28.             //通过类名生成实例对象并将其返回  
  29.             Class c = Class.forName(cName);  
  30.             Object obj = c.newInstance();  
  31.             return obj;  
  32.         }     
  33.         catch(Exception e){  
  34.             e.printStackTrace();  
  35.             return null;  
  36.         }  
  37.     }  
  38. }

配置文件config.xml中存储了具体建造者类的类名，代码如下所示：

  1. <?xml version="1.0"?>  
  2. <config>  
  3.     <className>HelpCommand</className>  
  4.     <className>MinimizeCommand</className>  
  5. </config>  
  6.        编写如下客户端测试代码：
  7. [java] view plain copy
  8. class Client {  
  9.     public static void main(String args[]) {  
  10.         FBSettingWindow fbsw = new FBSettingWindow("功能键设置");  
  12.         FunctionButton fb1,fb2;  
  13.         fb1 = new FunctionButton("功能键1");  
  14.         fb2 = new FunctionButton("功能键1");  
  16.         Command command1,command2;  
  17.         //通过读取配置文件和反射生成具体命令对象  
  18.         command1 = (Command)XMLUtil.getBean(0);  
  19.         command2 = (Command)XMLUtil.getBean(1);  
  21.         //将命令对象注入功能键  
  22.         fb1.setCommand(command1);  
  23.         fb2.setCommand(command2);  
  25.         fbsw.addFunctionButton(fb1);  
  26.         fbsw.addFunctionButton(fb2);  
  27.         fbsw.display();  
  29.         //调用功能键的业务方法  
  30.         fb1.onClick();  
  31.         fb2.onClick();  
  32.     }  
  33. }

编译并运行程序，输出结果如下：

  1. 显示窗口：功能键设置
  2. 显示功能键：
  3. 功能键1
  4. 功能键1
  5. ------------------------------
  6. 点击功能键：显示帮助文档！
  7. 点击功能键：将窗口最小化至托盘！

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