# 操作复杂对象结构——访问者模式（三）
26.3 完整解决方案
Sunny软件公司开发人员使用访问者模式对OA系统中员工数据汇总模块进行重构，使得系统可以很方便地增加新类型的访问者，更加符合“单一职责原则”和“开闭原则”，重构后的基本结构如图26-3所示：
在图26-3中，FADepartment表示财务部，HRDepartment表示人力资源部，它们充当具体访问者角色，其抽象父类Department充当抽象访问者角色；EmployeeList充当对象结构，用于存储员工列表；FulltimeEmployee表示正式员工，ParttimeEmployee表示临时工，它们充当具体元素角色，其父接口Employee充当抽象元素角色。完整代码如下所示：
```
import java.util.*;
//员工类：抽象元素类
interface Employee
{
public void accept(Department handler); //接受一个抽象访问者访问
}
//全职员工类：具体元素类
class FulltimeEmployee implements Employee
{
private String name;
private double weeklyWage;
private int workTime;
public FulltimeEmployee(String name,double weeklyWage,int workTime)
{
this.name = name;
this.weeklyWage = weeklyWage;
this.workTime = workTime;
}
public void setName(String name)
{
this.name = name;
}
public void setWeeklyWage(double weeklyWage)
{
this.weeklyWage = weeklyWage;
}
public void setWorkTime(int workTime)
{
this.workTime = workTime;
}
public String getName()
{
return (this.name);
}
public double getWeeklyWage()
{
return (this.weeklyWage);
}
public int getWorkTime()
{
return (this.workTime);
}
public void accept(Department handler)
{
handler.visit(this); //调用访问者的访问方法
}
}
//兼职员工类：具体元素类
class ParttimeEmployee implements Employee
{
private String name;
private double hourWage;
private int workTime;
public ParttimeEmployee(String name,double hourWage,int workTime)
{
this.name = name;
this.hourWage = hourWage;
this.workTime = workTime;
}
public void setName(String name)
{
this.name = name;
}
public void setHourWage(double hourWage)
{
this.hourWage = hourWage;
}
public void setWorkTime(int workTime)
{
this.workTime = workTime;
}
public String getName()
{
return (this.name);
}
public double getHourWage()
{
return (this.hourWage);
}
public int getWorkTime()
{
return (this.workTime);
}
public void accept(Department handler)
{
handler.visit(this); //调用访问者的访问方法
}
}
//部门类：抽象访问者类
abstract class Department
{
//声明一组重载的访问方法，用于访问不同类型的具体元素
public abstract void visit(FulltimeEmployee employee);
public abstract void visit(ParttimeEmployee employee);
}
//财务部类：具体访问者类
class FADepartment extends Department
{
//实现财务部对全职员工的访问
public void visit(FulltimeEmployee employee)
{
int workTime = employee.getWorkTime();
double weekWage = employee.getWeeklyWage();
if(workTime > 40)
{
weekWage = weekWage + (workTime - 40) * 100;
}
else if(workTime < 40)
{
weekWage = weekWage - (40 - workTime) * 80;
if(weekWage < 0)
{
weekWage = 0;
}
}
System.out.println("正式员工" + employee.getName() + "实际工资为：" + weekWage + "元。");
}
//实现财务部对兼职员工的访问
public void visit(ParttimeEmployee employee)
{
int workTime = employee.getWorkTime();
double hourWage = employee.getHourWage();
System.out.println("临时工" + employee.getName() + "实际工资为：" + workTime * hourWage + "元。");
}
}
//人力资源部类：具体访问者类
class HRDepartment extends Department
{
//实现人力资源部对全职员工的访问
public void visit(FulltimeEmployee employee)
{
int workTime = employee.getWorkTime();
System.out.println("正式员工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");
if(workTime > 40)
{
System.out.println("正式员工" + employee.getName() + "加班时间为：" + (workTime - 40) + "小时。");
}
else if(workTime < 40)
{
System.out.println("正式员工" + employee.getName() + "请假时间为：" + (40 - workTime) + "小时。");
}
}
//实现人力资源部对兼职员工的访问
public void visit(ParttimeEmployee employee)
{
int workTime = employee.getWorkTime();
System.out.println("临时工" + employee.getName() + "实际工作时间为：" + workTime + "小时。");
}
}
//员工列表类：对象结构
class EmployeeList
{
//定义一个集合用于存储员工对象
private ArrayList<Employee> list = new ArrayList<Employee>();
public void addEmployee(Employee employee)
{
list.add(employee);
}
//遍历访问员工集合中的每一个员工对象
public void accept(Department handler)
{
for(Object obj : list)
{
((Employee)obj).accept(handler);
}
}
}
```
为了提高系统的灵活性和可扩展性，我们将具体访问者类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：
```
import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
class XMLUtil
{
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
public static Object getBean()
{
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=nl.item(0).getFirstChild();
String cName=classNode.getNodeValue();
//通过类名生成实例对象并将其返回
Class c=Class.forName(cName);
Object obj=c.newInstance();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}
```
配置文件config.xml中存储了具体访问者类的类名，代码如下所示：
```
<?xml version="1.0"?>
<config>
<className>FADepartment</className>
</config>
```
编写如下客户端测试代码：
```
class Client
{
public static void main(String args[])
{
EmployeeList list = new EmployeeList();
Employee fte1,fte2,fte3,pte1,pte2;
fte1 = new FulltimeEmployee("张无忌",3200.00,45);
fte2 = new FulltimeEmployee("杨过",2000.00,40);
fte3 = new FulltimeEmployee("段誉",2400.00,38);
pte1 = new ParttimeEmployee("洪七公",80.00,20);
pte2 = new ParttimeEmployee("郭靖",60.00,18);
list.addEmployee(fte1);
list.addEmployee(fte2);
list.addEmployee(fte3);
list.addEmployee(pte1);
list.addEmployee(pte2);
Department dep;
dep = (Department)XMLUtil.getBean();
list.accept(dep);
}
}
```
编译并运行程序，输出结果如下：
```
正式员工张无忌实际工资为：3700.0元。
正式员工杨过实际工资为：2000.0元。
正式员工段誉实际工资为：2240.0元。
临时工洪七公实际工资为：1600.0元。
临时工郭靖实际工资为：1080.0元。
```
如果需要更换具体访问者类，无须修改源代码，只需修改配置文件，例如将访问者类由财务部改为人力资源部，只需将存储在配置文件中的具体访问者类FADepartment改为HRDepartment，如下代码所示：
```
<?xml version="1.0"?>
<config>
<className>HRDepartment</className>
</config>
```
重新运行客户端程序，输出结果如下：
```
正式员工张无忌实际工作时间为：45小时。
正式员工张无忌加班时间为：5小时。
正式员工杨过实际工作时间为：40小时。
正式员工段誉实际工作时间为：38小时。
正式员工段誉请假时间为：2小时。
临时工洪七公实际工作时间为：20小时。
临时工郭靖实际工作时间为：18小时。
```
如果要在系统中增加一种新的访问者，无须修改源代码，只要增加一个新的具体访问者类即可，在该具体访问者中封装了新的操作元素对象的方法。从增加新的访问者的角度来看，访问者模式符合“开闭原则”。
如果要在系统中增加一种新的具体元素，例如增加一种新的员工类型为“退休人员”，由于原有系统并未提供相应的访问接口（在抽象访问者中没有声明任何访问“退休人员”的方法），因此必须对原有系统进行修改，在原有的抽象访问者类和具体访问者类中增加相应的访问方法。从增加新的元素的角度来看，访问者模式违背了“开闭原则”。
综上所述，访问者模式与抽象工厂模式类似，对“开闭原则”的支持具有倾斜性，可以很方便地添加新的访问者，但是添加新的元素较为麻烦。
- Introduction
- 基础知识
- 设计模式概述
- 从招式与内功谈起——设计模式概述（一）
- 从招式与内功谈起——设计模式概述（二）
- 从招式与内功谈起——设计模式概述（三）
- 面向对象设计原则
- 面向对象设计原则之单一职责原则
- 面向对象设计原则之开闭原则
- 面向对象设计原则之里氏代换原则
- 面向对象设计原则之依赖倒转原则
- 面向对象设计原则之接口隔离原则
- 面向对象设计原则之合成复用原则
- 面向对象设计原则之迪米特法则
- 六个创建型模式
- 简单工厂模式-Simple Factory Pattern
- 工厂三兄弟之简单工厂模式（一）
- 工厂三兄弟之简单工厂模式（二）
- 工厂三兄弟之简单工厂模式（三）
- 工厂三兄弟之简单工厂模式（四）
- 工厂方法模式-Factory Method Pattern
- 工厂三兄弟之工厂方法模式（一）
- 工厂三兄弟之工厂方法模式（二）
- 工厂三兄弟之工厂方法模式（三）
- 工厂三兄弟之工厂方法模式（四）
- 抽象工厂模式-Abstract Factory Pattern
- 工厂三兄弟之抽象工厂模式（一）
- 工厂三兄弟之抽象工厂模式（二）
- 工厂三兄弟之抽象工厂模式（三）
- 工厂三兄弟之抽象工厂模式（四）
- 工厂三兄弟之抽象工厂模式（五）
- 单例模式-Singleton Pattern
- 确保对象的唯一性——单例模式 （一）
- 确保对象的唯一性——单例模式 （二）
- 确保对象的唯一性——单例模式 （三）
- 确保对象的唯一性——单例模式 （四）
- 确保对象的唯一性——单例模式 （五）
- 原型模式-Prototype Pattern
- 对象的克隆——原型模式（一）
- 对象的克隆——原型模式（二）
- 对象的克隆——原型模式（三）
- 对象的克隆——原型模式（四）
- 建造者模式-Builder Pattern
- 复杂对象的组装与创建——建造者模式（一）
- 复杂对象的组装与创建——建造者模式（二）
- 复杂对象的组装与创建——建造者模式（三）
- 七个结构型模式
- 适配器模式-Adapter Pattern
- 不兼容结构的协调——适配器模式（一）
- 不兼容结构的协调——适配器模式（二）
- 不兼容结构的协调——适配器模式（三）
- 不兼容结构的协调——适配器模式（四）
- 桥接模式-Bridge Pattern
- 处理多维度变化——桥接模式（一）
- 处理多维度变化——桥接模式（二）
- 处理多维度变化——桥接模式（三）
- 处理多维度变化——桥接模式（四）
- 组合模式-Composite Pattern
- 树形结构的处理——组合模式（一）
- 树形结构的处理——组合模式（二）
- 树形结构的处理——组合模式（三）
- 树形结构的处理——组合模式（四）
- 树形结构的处理——组合模式（五）
- 装饰模式-Decorator Pattern
- 扩展系统功能——装饰模式（一）
- 扩展系统功能——装饰模式（二）
- 扩展系统功能——装饰模式（三）
- 扩展系统功能——装饰模式（四）
- 外观模式-Facade Pattern
- 深入浅出外观模式（一）
- 深入浅出外观模式（二）
- 深入浅出外观模式（三）
- 享元模式-Flyweight Pattern
- 实现对象的复用——享元模式（一）
- 实现对象的复用——享元模式（二）
- 实现对象的复用——享元模式（三）
- 实现对象的复用——享元模式（四）
- 实现对象的复用——享元模式（五）
- 代理模式-Proxy Pattern
- 设计模式之代理模式（一）
- 设计模式之代理模式（二）
- 设计模式之代理模式（三）
- 设计模式之代理模式（四）
- 十一个行为型模式
- 职责链模式-Chain of Responsibility Pattern
- 请求的链式处理——职责链模式（一）
- 请求的链式处理——职责链模式（二）
- 请求的链式处理——职责链模式（三）
- 请求的链式处理——职责链模式（四）
- 命令模式-Command Pattern
- 请求发送者与接收者解耦——命令模式（一）
- 请求发送者与接收者解耦——命令模式（二）
- 请求发送者与接收者解耦——命令模式（三）
- 请求发送者与接收者解耦——命令模式（四）
- 请求发送者与接收者解耦——命令模式（五）
- 请求发送者与接收者解耦——命令模式（六）
- 解释器模式-Interpreter Pattern
- 自定义语言的实现——解释器模式（一）
- 自定义语言的实现——解释器模式（二）
- 自定义语言的实现——解释器模式（三）
- 自定义语言的实现——解释器模式（四）
- 自定义语言的实现——解释器模式（五）
- 自定义语言的实现——解释器模式（六）
- 迭代器模式-Iterator Pattern
- 遍历聚合对象中的元素——迭代器模式（一）
- 遍历聚合对象中的元素——迭代器模式（二）
- 遍历聚合对象中的元素——迭代器模式（三）
- 遍历聚合对象中的元素——迭代器模式（四）
- 遍历聚合对象中的元素——迭代器模式（五）
- 遍历聚合对象中的元素——迭代器模式（六）
- 中介者模式-Mediator Pattern
- 协调多个对象之间的交互——中介者模式（一）
- 协调多个对象之间的交互——中介者模式（二）
- 协调多个对象之间的交互——中介者模式（三）
- 协调多个对象之间的交互——中介者模式（四）
- 协调多个对象之间的交互——中介者模式（五）
- 备忘录模式-Memento Pattern
- 撤销功能的实现——备忘录模式（一）
- 撤销功能的实现——备忘录模式（二）
- 撤销功能的实现——备忘录模式（三）
- 撤销功能的实现——备忘录模式（四）
- 撤销功能的实现——备忘录模式（五）
- 观察者模式-Observer Pattern
- 对象间的联动——观察者模式（一）
- 对象间的联动——观察者模式（二）
- 对象间的联动——观察者模式（三）
- 对象间的联动——观察者模式（四）
- 对象间的联动——观察者模式（五）
- 对象间的联动——观察者模式（六）
- 状态模式-State Pattern
- 处理对象的多种状态及其相互转换——状态模式（一）
- 处理对象的多种状态及其相互转换——状态模式（二）
- 处理对象的多种状态及其相互转换——状态模式（三）
- 处理对象的多种状态及其相互转换——状态模式（四）
- 处理对象的多种状态及其相互转换——状态模式（五）
- 处理对象的多种状态及其相互转换——状态模式（六）
- 策略模式-Strategy Pattern
- 算法的封装与切换——策略模式（一）
- 算法的封装与切换——策略模式（二）
- 算法的封装与切换——策略模式（三）
- 算法的封装与切换——策略模式（四）
- 模板方法模式-Template Method Pattern
- 模板方法模式深度解析（一）
- 模板方法模式深度解析（二）
- 模板方法模式深度解析（三）
- 访问者模式-Visitor Pattern
- 操作复杂对象结构——访问者模式（一）
- 操作复杂对象结构——访问者模式（二）
- 操作复杂对象结构——访问者模式（三）
- 操作复杂对象结构——访问者模式（四）
- 设计模式趣味学习（复习）
- 设计模式与足球（一）
- 设计模式与足球（二）
- 设计模式与足球（三）
- 设计模式与足球（四）
- 设计模式综合应用实例
- 多人联机射击游戏
- 多人联机射击游戏中的设计模式应用（一）
- 多人联机射击游戏中的设计模式应用（二）
- 数据库同步系统
- 设计模式综合实例分析之数据库同步系统（一）
- 设计模式综合实例分析之数据库同步系统（二）
- 设计模式综合实例分析之数据库同步系统（三）