行为型：设计模式之访问者模式（二十三）

 想必大家都去过医院，虽然没有人喜欢去医院（爱岗敬业的医务工作人员除外，

）。在医生开具处方单（药单）后，很多医院都存在如下处理流程：划价人员拿到处方单之后根据药品名称和数量计算总价，药房工作人员根据药品名称和数量准备药品，如图1所示：

1中，我们可以将处方单看成一个药品信息的集合，里面包含了一种或多种不同类型的药品信息，不同类型的工作人员（如划价人员和药房工作人员）在操作同一个药品信息集合时将提供不同的处理方式，而且可能还会增加新类型的工作人员来操作处方单。

在软件开发中，有时候我们也需要处理像处方单这样的集合对象结构，在该对象结构中存储了多个不同类型的对象信息，而且对同一对象结构中的元素的操作方式并不唯一，可能需要提供多种不同的处理方式，还有可能增加新的处理方式。在设计模式中，有一种模式可以满足上述要求，其模式动机就是以不同的方式操作复杂对象结构，该模式就是我们本章将要介绍的访问者模式。

1 OA系统中员工数据汇总

       Sunny软件公司开发人员针对上述需求，提出了一个初始解决方案，其核心代码如下所示：

1. import java.util.*;  
2.   
3. class EmployeeList  {  
4. private ArrayList<Employee> list = new ArrayList<Employee>(); //员工集合  
5.   
6. //增加员工  
7. public void addEmployee(Employee employee){  
8.         list.add(employee);  
9.     }  
10.       
11. //处理员工数据  
12. public void handle(String departmentName){  
13. if(departmentName.equalsIgnoreCase("财务部")) //财务部处理员工数据  
14.         {  
15. for(Object obj : list)  {  
16. if(obj.getClass().getName().equalsIgnoreCase("FulltimeEmployee")) {  
17. "财务部处理全职员工数据！");           
18.                 }  
19. else  {  
20. "财务部处理兼职员工数据！");  
21.                 }  
22.             }  
23.         }  
24. else if(departmentName.equalsIgnoreCase("人力资源部")) //人力资源部处理员工数据  
25.         {  
26. for(Object obj : list){  
27. if(obj.getClass().getName().equalsIgnoreCase("FulltimeEmployee")){  
28. "人力资源部处理全职员工数据！");                     
29.                 }  
30. else {  
31. "人力资源部处理兼职员工数据！");  
32.                 }  
33.             }             
34.         }  
35.     }  
36. }  

EmployeeList类的handle()方法中，通过对部门名称和员工类型进行判断，不同部门对不同类型的员工进行了不同的处理，满足了员工数据汇总的要求。但是该解决方案存在如下几个问题：

      (1) EmployeeList类非常庞大，它将各个部门处理各类员工数据的代码集中在一个类中，在具体实现时，代码将相当冗长，EmployeeList类承担了过多的职责，既不方便代码的复用，也不利于系统的扩展，违背了“单一职责原则”。

      (2)在代码中包含大量的“if…else…”条件判断语句，既需要对不同部门进行判断，又需要对不同类型的员工进行判断，还将出现嵌套的条件判断语句，导致测试和维护难度增大。

      (3)如果要增加一个新的部门来操作员工集合，不得不修改EmployeeList类的源代码，在handle()方法中增加一个新的条件判断语句和一些业务处理代码来实现新部门的访问操作。这违背了“开闭原则”，系统的灵活性和可扩展性有待提高。

      (4)如果要增加一种新类型的员工，同样需要修改EmployeeList类的源代码，在不同部门的处理代码中增加对新类型员工的处理逻辑，这也违背了“开闭原则”。

      如何解决上述问题？如何为同一集合对象中的元素提供多种不同的操作方式？访问者模式就是一个值得考虑的解决方案，它可以在一定程度上解决上述问题（解决大部分问题）。访问者模式可以为为不同类型的元素提供多种访问操作方式，而且可以在不修改原有系统的情况下增加新的操作方式。

2 访问者模式概述

      访问者模式是一种较为复杂的行为型设计模式，它包含访问者和被访问元素两个主要组成部分，这些被访问的元素通常具有不同的类型，且不同的访问者可以对它们进行不同的访问操作。例如处方单中的各种药品信息就是被访问的元素，而划价人员和药房工作人员就是访问者。访问者模式使得用户可以在不修改现有系统的情况下扩展系统的功能，为这些不同类型的元素增加新的操作。

      在使用访问者模式时，被访问元素通常不是单独存在的，它们存储在一个集合中，这个集合被称为“对象结构”，访问者通过遍历对象结构实现对其中存储的元素的逐个操作。

      访问者模式定义如下：

2所示：

      在访问者模式结构图中包含如下几个角色：

Vistor（抽象访问者）：抽象访问者为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素的类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作。

ConcreteVisitor（具体访问者）：具体访问者实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型的元素。

Element（抽象元素）：抽象元素一般是抽象类或者接口，它定义一个accept()方法，该方法通常以一个抽象访问者作为参数。【稍后将介绍为什么要这样设计。】

ConcreteElement（具体元素）：具体元素实现了accept()方法，在accept()方法中调用访问者的访问方法以便完成对一个元素的操作。

 ObjectStructure（对象结构）：对象结构是一个元素的集合，它用于存放元素对象，并且提供了遍历其内部元素的方法。它可以结合组合模式来实现，也可以是一个简单的集合对象，如一个List对象或一个Set对象。

      访问者模式中对象结构存储了不同类型的元素对象，以供不同访问者访问。访问者模式包括两个层次结构，一个是访问者层次结构，提供了抽象访问者和具体访问者，一个是元素层次结构，提供了抽象元素和具体元素。相同的访问者可以以不同的方式访问不同的元素，相同的元素可以接受不同访问者以不同访问方式访问。在访问者模式中，增加新的访问者无须修改原有系统，系统具有较好的可扩展性。

visitElementA(ElementA elementA)，还有一种是统一取名为visit()，通过参数类型的不同来定义一系列重载的visit()方法。当然，如果所有的访问者对某一类型的元素的访问操作都相同，则可以将操作代码移到抽象访问者类中，其典型代码如下所示：

1. public abstract class Visitor  {  
2. public abstract void visit(ConcreteElementA elementA);  
3. public abstract void visit(ConcreteElementB elementB);  
4. public void visit(ConcreteElementC elementC){  
5. //元素ConcreteElementC操作代码  
6.     }  
7. }  

visit()方法的方式来定义多个方法用于操作不同类型的元素对象。在抽象访问者Visitor类的子类ConcreteVisitor中实现了抽象的访问方法，用于定义对不同类型元素对象的操作，具体访问者类典型代码如下所示：

1. class ConcreteVisitor extends Visitor  {  
2. public void visit(ConcreteElementA elementA){  
3. //元素ConcreteElementA操作代码  
4.     }  
5. public void visit(ConcreteElementB elementB){  
6. //元素ConcreteElementB操作代码  
7.     }  
8. }  

accept()方法，用于接受访问者的访问，典型的抽象元素类代码如下所示：

1. interface Element{  
2. public void accept(Visitor visitor);  
3. }  

Visitor类型的参数，即针对抽象访问者进行编程，而不是具体访问者，在程序运行时再确定具体访问者的类型，并调用具体访问者对象的visit()方法实现对元素对象的操作。在抽象元素类Element的子类中实现了accept()方法，用于接受访问者的访问，在具体元素类中还可以定义不同类型的元素所特有的业务方法，其典型代码如下所示：

1. class ConcreteElementA implements Element{  
2. public void accept(Visitor visitor){  
3. this);  
4.     }  
5.       
6. public void operationA(){  
7. //业务方法  
8.     }  
9. }  

ConcreteElementA的accept()方法中，通过调用Visitor类的visit()方法实现对元素的访问，并以当前对象作为visit()方法的参数。其具体执行过程如下：

      (1) 调用具体元素类的accept(Visitor visitor)方法，并将Visitor子类对象作为其参数；

      (2) 在具体元素类accept(Visitor visitor)方法内部调用传入的Visitor对象的visit()方法，如visit(ConcreteElementA elementA)，将当前具体元素类对象(this)作为参数，如visitor.visit(this)；

      (3) 执行Visitor对象的visit()方法，在其中还可以调用具体元素对象的业务方法。

      这种调用机制也称为“双重分派”，正因为使用了双重分派机制，使得增加新的访问者无须修改现有类库代码，只需将新的访问者对象作为参数传入具体元素对象的accept()方法，程序运行时将回调在新增Visitor类中定义的visit()方法，从而增加新的元素访问方式。

      在访问者模式中，对象结构是一个集合，它用于存储元素对象并接受访问者的访问，其典型代码如下所示：

1. public class ObjectStructure  {  
2. private ArrayList<Element> list = new ArrayList<Element>(); //定义一个集合用于存储元素对象  
3.   
4. public void accept(Visitor visitor){  
5.         Iterator i=list.iterator();  
6.           
7. while(i.hasNext()){  
8. //遍历访问集合中的每一个元素  
9.         }  
10.     }  
11.   
12. public void addElement(Element element){  
13.         list.add(element);  
14.     }  
15.   
16. public void removeElement(Element element){  
17.         list.remove(element);  
18.     }  
19. }  

accept()方法，实现对元素对象的访问操作。

3 完整解决方案

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

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

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

XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：

1. public class XMLUtil {  
2. //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象    
3. public static Object getBean() throws Exception {  
4. new SAXReader();  
5. class.getClassLoader().  
6. "com/somnus/designPatterns/visitor/config.xml").getPath();  
7. new File(path));  
8. "/config/className").getText();  
9. //通过类名生成实例对象并将其返回    
10.         Class<?> c = Class.forName(cName);    
11.         Object obj = c.newInstance();    
12. return obj;    
13.     }    
14. }  

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

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <config>    
3. <className>com.somnus.designPatterns.visitor.FADepartment</className>    
4. </config>  

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

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

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

FADepartment改为HRDepartment，如下代码所示：

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

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

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

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

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

4 访问者模式与组合模式联用

4所示：

需要注意的是，在图26-4所示结构中，由于叶子元素的遍历操作已经在容器元素中完成，因此要防止单独将已增加到容器元素中的叶子元素再次加入对象结构中，对象结构中只保存容器元素和孤立的叶子元素。

5 访问者模式总结

XML文档解析、编译器的设计、复杂集合对象的处理等领域访问者模式得到了一定的应用。

1.主要优点

      访问者模式的主要优点如下：

(1) 增加新的访问操作很方便。使用访问者模式，增加新的访问操作就意味着增加一个新的具体访问者类，实现简单，无须修改源代码，符合“开闭原则”。

(2) 将有关元素对象的访问行为集中到一个访问者对象中，而不是分散在一个个的元素类中。类的职责更加清晰，有利于对象结构中元素对象的复用，相同的对象结构可以供多个不同的访问者访问。

(3) 让用户能够在不修改现有元素类层次结构的情况下，定义作用于该层次结构的操作。

2.主要缺点

      访问者模式的主要缺点如下：

(1) 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”的要求。

(2) 破坏封装。访问者模式要求访问者对象访问并调用每一个元素对象的操作，这意味着元素对象有时候必须暴露一些自己的内部操作和内部状态，否则无法供访问者访问。

3.适用场景

      在以下情况下可以考虑使用访问者模式：

(1) 一个对象结构包含多个类型的对象，希望对这些对象实施一些依赖其具体类型的操作。在访问者中针对每一种具体的类型都提供了一个访问操作，不同类型的对象可以有不同的访问操作。

(2) 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。访问者模式使得我们可以将相关的访问操作集中起来定义在访问者类中，对象结构可以被多个不同的访问者类所使用，将对象本身与对象的访问操作分离。

(3) 对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。