操作复杂对象结构——访问者模式（三）

26.3 完整解决方案

Sunny软件公司开发人员使用访问者模式对OA系统中员工数据汇总模块进行重构，使得系统可以很方便地增加新类型的访问者，更加符合“单一职责原则”和“开闭原则”，重构后的基本结构如图26-3所示：

操作复杂对象结构——访问者模式（三） - 图1

在图26-3中，FADepartment表示财务部，HRDepartment表示人力资源部，它们充当具体访问者角色，其抽象父类Department充当抽象访问者角色；EmployeeList充当对象结构，用于存储员工列表；FulltimeEmployee表示正式员工，ParttimeEmployee表示临时工，它们充当具体元素角色，其父接口Employee充当抽象元素角色。完整代码如下所示：

  1. import java.util.*;  
  3. //员工类：抽象元素类  
  4. interface Employee  
  5. {  
  6.     public void accept(Department handler); //接受一个抽象访问者访问  
  7. }  
  9. //全职员工类：具体元素类  
  10. class FulltimeEmployee implements Employee  
  11. {  
  12.     private String name;  
  13.     private double weeklyWage;  
  14.     private int workTime;  
  16.     public FulltimeEmployee(String name,double weeklyWage,int workTime)  
  17.     {  
  18.         this.name = name;  
  19.         this.weeklyWage = weeklyWage;  
  20.         this.workTime = workTime;  
  21.     }     
  23.     public void setName(String name)   
  24.     {  
  25.         this.name = name;   
  26.     }  
  28.     public void setWeeklyWage(double weeklyWage)   
  29.     {  
  30.         this.weeklyWage = weeklyWage;   
  31.     }  
  33.     public void setWorkTime(int workTime)   
  34.     {  
  35.         this.workTime = workTime;   
  36.     }  
  38.     public String getName()   
  39.     {  
  40.         return (this.name);   
  41.     }  
  43.     public double getWeeklyWage()   
  44.     {  
  45.         return (this.weeklyWage);   
  46.     }  
  48.     public int getWorkTime()   
  49.     {  
  50.         return (this.workTime);   
  51.     }  
  53.     public void accept(Department handler)  
  54.     {  
  55.         handler.visit(this); //调用访问者的访问方法  
  56.     }  
  57. }  
  59. //兼职员工类：具体元素类  
  60. class ParttimeEmployee implements Employee  
  61. {  
  62.     private String name;  
  63.     private double hourWage;  
  64.     private int workTime;  
  66.     public ParttimeEmployee(String name,double hourWage,int workTime)  
  67.     {  
  68.         this.name = name;  
  69.         this.hourWage = hourWage;  
  70.         this.workTime = workTime;  
  71.     }     
  73.     public void setName(String name)   
  74.     {  
  75.         this.name = name;   
  76.     }  
  78.     public void setHourWage(double hourWage)   
  79.     {  
  80.         this.hourWage = hourWage;   
  81.     }  
  83.     public void setWorkTime(int workTime)   
  84.     {  
  85.         this.workTime = workTime;   
  86.     }  
  88.     public String getName()   
  89.     {  
  90.         return (this.name);   
  91.     }  
  93.     public double getHourWage()   
  94.     {  
  95.         return (this.hourWage);   
  96.     }  
  98.     public int getWorkTime()   
  99.     {  
  100.         return (this.workTime);   
  101.     }  
  103.     public void accept(Department handler)  
  104.     {  
  105.         handler.visit(this); //调用访问者的访问方法  
  106.     }  
  107. }  
  109. //部门类：抽象访问者类  
  110. abstract class Department  
  111. {  
  112.     //声明一组重载的访问方法，用于访问不同类型的具体元素  
  113.     public abstract void visit(FulltimeEmployee employee);  
  114.     public abstract void visit(ParttimeEmployee employee);    
  115. }  
  117. //财务部类：具体访问者类  
  118. class FADepartment extends Department  
  119. {  
  120.     //实现财务部对全职员工的访问  
  121.     public void visit(FulltimeEmployee employee)  
  122.     {  
  123.         int workTime = employee.getWorkTime();  
  124.         double weekWage = employee.getWeeklyWage();  
  125.         if(workTime > 40)  
  126.         {  
  127.             weekWage = weekWage + (workTime - 40) * 100;  
  128.         }  
  129.         else if(workTime < 40)  
  130.         {  
  131.             weekWage = weekWage - (40 - workTime) * 80;  
  132.             if(weekWage < 0)  
  133.             {  
  134.                 weekWage = 0;  
  135.             }  
  136.         }  
  137.         System.out.println("正式员工" + employee.getName() + "实际工资为：" + weekWage + "元。");             
  138.     }  
  140.     //实现财务部对兼职员工的访问  
  141.     public void visit(ParttimeEmployee employee)  
  142.     {  
  143.         int workTime = employee.getWorkTime();  
  144.         double hourWage = employee.getHourWage();  
  145.         System.out.println("临时工" + employee.getName() + "实际工资为：" + workTime * hourWage + "元。");       
  146.     }         
  147. }  
  149. //人力资源部类：具体访问者类  
  150. class HRDepartment extends Department  
  151. {  
  152.     //实现人力资源部对全职员工的访问  
  153.     public void visit(FulltimeEmployee employee)  
  154.     {  
  155.         int workTime = employee.getWorkTime();  
  156.         System.out.println("正式员工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");  
  157.         if(workTime > 40)  
  158.         {  
  159.             System.out.println("正式员工" + employee.getName() + "加班时间为：" + (workTime - 40) + "小时。");  
  160.         }  
  161.         else if(workTime < 40)  
  162.         {  
  163.             System.out.println("正式员工" + employee.getName() + "请假时间为：" + (40 - workTime) + "小时。");  
  164.         }                         
  165.     }  
  167.     //实现人力资源部对兼职员工的访问  
  168.     public void visit(ParttimeEmployee employee)  
  169.     {  
  170.         int workTime = employee.getWorkTime();  
  171.         System.out.println("临时工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");  
  172.     }         
  173. }  
  175. //员工列表类：对象结构  
  176. class EmployeeList  
  177. {  
  178.     //定义一个集合用于存储员工对象  
  179.     private ArrayList<Employee> list = new ArrayList<Employee>();  
  181.     public void addEmployee(Employee employee)  
  182.     {  
  183.         list.add(employee);  
  184.     }  
  186.     //遍历访问员工集合中的每一个员工对象  
  187.     public void accept(Department handler)  
  188.     {  
  189.         for(Object obj : list)  
  190.         {  
  191.             ((Employee)obj).accept(handler);  
  192.         }  
  193.     }  
  194. }

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

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

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

  1. <?xml version="1.0"?>  
  2. <config>  
  3.     <className>FADepartment</className>  
  4. </config>

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

  1. class Client  
  2. {  
  3.     public static void main(String args[])  
  4.     {  
  5.         EmployeeList list = new EmployeeList();  
  6.         Employee fte1,fte2,fte3,pte1,pte2;  
  8.         fte1 = new FulltimeEmployee("张无忌",3200.00,45);  
  9.         fte2 = new FulltimeEmployee("杨过",2000.00,40);  
  10.         fte3 = new FulltimeEmployee("段誉",2400.00,38);  
  11.         pte1 = new ParttimeEmployee("洪七公",80.00,20);  
  12.         pte2 = new ParttimeEmployee("郭靖",60.00,18);  
  14.         list.addEmployee(fte1);  
  15.         list.addEmployee(fte2);  
  16.         list.addEmployee(fte3);  
  17.         list.addEmployee(pte1);  
  18.         list.addEmployee(pte2);  
  20.         Department dep;  
  21.         dep = (Department)XMLUtil.getBean();  
  22.         list.accept(dep);  
  23.     }  
  24. }

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

  1. 正式员工张无忌实际工资为：3700.0元。
  2. 正式员工杨过实际工资为：2000.0元。
  3. 正式员工段誉实际工资为：2240.0元。
  4. 临时工洪七公实际工资为：1600.0元。
  5. 临时工郭靖实际工资为：1080.0元。

如果需要更换具体访问者类，无须修改源代码，只需修改配置文件，例如将访问者类由财务部改为人力资源部，只需将存储在配置文件中的具体访问者类FADepartment改为HRDepartment，如下代码所示：

  1. <?xml version="1.0"?>  
  2. <config>  
  3.     <className>HRDepartment</className>  
  4. </config>

重新运行客户端程序，输出结果如下：

  1. 正式员工张无忌实际工作时间为：45小时。
  2. 正式员工张无忌加班时间为：5小时。
  3. 正式员工杨过实际工作时间为：40小时。
  4. 正式员工段誉实际工作时间为：38小时。
  5. 正式员工段誉请假时间为：2小时。
  6. 临时工洪七公实际工作时间为：20小时。
  7. 临时工郭靖实际工作时间为：18小时。

如果要在系统中增加一种新的访问者，无须修改源代码，只要增加一个新的具体访问者类即可，在该具体访问者中封装了新的操作元素对象的方法。从增加新的访问者的角度来看，访问者模式符合“开闭原则”。

如果要在系统中增加一种新的具体元素，例如增加一种新的员工类型为“退休人员”，由于原有系统并未提供相应的访问接口（在抽象访问者中没有声明任何访问“退休人员”的方法），因此必须对原有系统进行修改，在原有的抽象访问者类和具体访问者类中增加相应的访问方法。从增加新的元素的角度来看，访问者模式违背了“开闭原则”。

综上所述，访问者模式与抽象工厂模式类似，对“开闭原则”的支持具有倾斜性，可以很方便地添加新的访问者，但是添加新的元素较为麻烦。