概述
访问者模式是一种较为复杂的行为型设计模式，它包含访问者和被访问元素两个主要组成部分，这些被访问的元素通常具有不同的类型，且不同的访问者可以对他们进行不同的访问操作。访问者模式使得用户可以在不修改现有系统的情况下扩展系统的功能，为这些类型的元素增加新的操作。
在使用访问者模式时，被访问元素通常不是单独存在的，他们存在一个集合中，这个集合称之为‘对象结构’，访问者通过遍历对象结构实现对其中存储的元素的逐个操做。
定义
访问者模式（Visitor Pattern）：提供一个作用于某对象结构中的各元素的操作表示，它使得可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式
示意图
Visitor(抽象访问者)：抽象访问者为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素的类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作
ConcreteVisitor(具体访问者)：具体访问者实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型的元素。
Element(抽象元素)：抽象元素一般是抽象类或接口，它定义一个accept()方法，该方法通常以一个抽象访问者作为参数。
ConcreteElement(具体元素)：具体元素实现了accept()方法,在accept()方法中调用访问者的访问方法以便完成对一个元素的操作。
ObjectStructure(对象结构)：对象结构是一个元素的集合，它用于存放元素对象，并提供了遍历其内部元素的方法，它可以结合组合模式来实现，也是一个简单的集合对象，例如一个List对象或一个Set对象
访问者模式中对象结构存储了不同类型的元素对象，以供不同访问者访问。访问者模式包括两个层次结构：一个是访问者层次结构，提供了抽象访问者和具体访问者；另一个是元素层次结构，提供抽象元素和具体元素。相同的访问者可以以不同的方式访问不同的元素，相同的元素可以接受不同访问者以不同访问方式访问。在访问者模式中，增加新的访问者无需修改原有系统，系统具有较好的可扩展性。
在访问者模式中，抽象访问者定义了访问元素对象的方法，通常为每一种类型的元素对象都提供一个访问方法，而具体访问者可以实现这些访问方法，这些方法访问方法的命名一般有两种方法：一种是直接在方法名中标明待访问元素对象的具体类型，例如visitElementA(ElementA elementA); 另有一种是统一取名为visit(),通过参数类型的不同来定义一系列重载的visit()方法。当然，如果所有的访问者对某一类型的元素的访问操作都相同，则可以将操作代码移到抽象访问者类中，其经典代码如下：
public abstract class Visitor {
public abstract void visit(ConcreteElementA elementA);
public abstract void visit(ConcreteElementB elementB);
public void visit(ConcreteElementC elementC){
//元素ConcreteElementC操作代码
}
}
在这里使用了重载visit()方法的方式来定义实现多个方法，用于操作不同类型的元素对象。在抽象访问者Visitor类的子类ConcreteVisitor中实现了抽象的访问方法，用于定义对不同类型元素对象的操作，具体访问者经典代码如下：
public class ConcreteVisitor extends Visitor {
public abstract void visit(ConcreteElementA elementA){
//元素ConcreteElementA操作代码
}
public abstract void visit(ConcreteElementB elementB){
//元素ConcreteElementB操作代码
}
}
对于元素类而言，在其中一般定义了一个accept()方法，用于接受访问者的访问，典型的抽象元素类代码如下：
interface Element{
public void accept(Visitor visitor);
}
在抽象元素Element的子类中实现了accept()方法，用于接受访问者的访问，在具体元素类中还可以定义不同类型的元素所特有的业务方法，其经典代码如下：
class ConcreteElementA implements Element{
public void accept(Visitor visitor){
visitor.visit(this);
}
public void operationA(){
}
}
在具体元素类ConcreteElementA 的accept()方法中，通过调用Visitor类的visit()方法实现对元素的方法，并以当前对象作为visit()方法的参数，其具体执行过程如下：
调用具体元素类的accept(Visitor visitor) 方法，并将Visitor子类对象作为其参数
在具体元素类accept(Visitor visitor)方法内部调用传入的Visitor对象的visit()方法，例如visit(ConcreteElementA elementA)，将当前具体元素对象(this)作为参数，例如visitor.visit(this);
执行Visitor对象的visitor()方法，在其中还可以调用元素对象的业务方法。
这种调用机制也称为**'双重分派'**
在访问者模式中，对象结构是一个集合，用于存储元素对象并接受访问者的访问，其典型代码如下：
class ObjectStructrue{
//定义一个集合用于存储元素对象
private ArrayList<Element> list = new ArrayList<Element>();
//接受访问者的访问操作
public void accept(Visitor visitor) {
Iterator i = list.iterator();
while(i.hasNext()) {
((Element)i.next()).accept(visitor); //遍历访问集合中的每一个元素
}
}
public void addElement(Element element) {
list.add(element);
}
public void removeElement(Element element) {
list.remove(element);
}
}
在对象结构中可以使用迭代器对存储在集合中的元素对象进行遍历，并逐个调用每一个对象的accept()方法，实现对元素对象的访问操作。
实例：设计OA系统中员工数据汇总模块
该系统员工包括正式员工和正式员工，每周人力资源部门和财务部门对每个员工数据进行汇总，使用访问者模式进行系统设计，使得系统可以很方便增加新类型的访问者，更加符合单一职责原则和开闭原则。
设计结构图
在图中FADepartment表示财务部门，HRDepartment表示人力资源部，它们充当具体访问者角色，其抽象父类Department充当抽象访问者角色;EmployeeList充当对象结构，用于存储员工列表;FulltimeEmployee表示正式员工，ParttimeEmployee表示临时工，它们充当具体元素角色，其父接口Employee充当抽象元素角色
实现代码
员工类：抽象元素
package com.zzk.visitorpattern;
public interface Employee {
public void accept(Department handler); // 接受一个抽象访问者访问
}
正式员工类：具体元素类
package com.zzk.visitorpattern;
public 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 String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getWeeklyWage() {
return weeklyWage;
}
public void setWeeklyWage(double weeklyWage) {
this.weeklyWage = weeklyWage;
}
public int getWorkTime() {
return workTime;
}
public void setWorkTime(int workTime) {
this.workTime = workTime;
}
@Override
public void accept(Department handler) {
handler.visit(this); //调用访问者的访问方法
}
}
兼职员工类：具体元素类
package com.zzk.visitorpattern;
public 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 String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getHourWage() {
return hourWage;
}
public void setHourWage(double hourWage) {
this.hourWage = hourWage;
}
public int getWorkTime() {
return workTime;
}
public void setWorkTime(int workTime) {
this.workTime = workTime;
}
@Override
public void accept(Department handler) {
handler.visit(this); //调用访问者的访问方法
}
}
部门类：抽象访问者
package com.zzk.visitorpattern;
public abstract class Department {
//声明一组重载的访问方法，用于访问不同类型的具体元素
public abstract void visit(FulltimeEmployee employee);
public abstract void visit(ParttimeEmployee employee);
}
财务部类：具体访问者类
package com.zzk.visitorpattern;
public 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 weeTime = employee.getWorkTime();
double hourWage = employee.getHourWage();
System.out.println("临时工" + employee.getName() + "实际工资为 " + weeTime * hourWage + "元");
}
}
人力资源部类：具体访问者类
package com.zzk.visitorpattern;
public 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 + "小时");
}
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 + "小时");
}
}
**员工列表类：对象结构 **
package com.zzk.visitorpattern;
import java.util.ArrayList;
public 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);
}
}
}
为了提高系统的灵活性和可扩展性，将具体访问者类的类名存储在配置文件config.xml中，并通过工具类XMLUtil类读取配置文件并反射生成对象。XMLUtil类的代码如下：
package com.zzk.visitorpattern;
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public 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>
客户端测试代码
package com.zzk.visitorpattern;
public 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, 49);
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);
}
}
如果要是在系统中增加一种新的访问者，无需修改源代码，只要增加一个新的具体访问者类即可，在该具体访问者中封装了新的操作元素对象的方法，从增加新的访问者的角度来看，访问者模式符合开闭原则。
如果要在系统中增加一种新的具体元素，例如增加一种新的员工类型如‘退休人员’，由于原有系统并未提供相应的访问接口（在抽象访问者中没有声明任何访问‘退休人员’的方法），因此必须对原有的系统进行修改，在原有的抽闲访问者类和具体访问者类中增加相应的访问方法。从增加新的元素的角度来看，访问者模式违背了开闭原则。
综上所述，访问者模式与抽象工厂模式类似，对开闭原则的支持具有倾斜性，可以很方便地添加新的访问者，但是添加新的元素较为麻烦。
访问者模式与组合模式联用
在访问者模式中，包含一个用于存储元素对象集合的对象结构，通常可以使用迭代器来遍历对象结构，同时具体元素之间可以存在整体与部分关系，有些元素作为容器对象，有些元素作为成员对象，可以使用组合模式来组织元素。引入组合模式后的访问者模式结构图如下
主要优点
增加新的访问操作很方便。使用访问者模式，增加新的访问模式操作意味着增加一个新的具体访问者类，实现简单，无需修改源代码，符合开闭原则。
将有关元素对象的访问行为集中到一个访问者对象中，而不是分散在一个个的元素类中，类的职责更加清晰，有利于对象结构中元素对象的复用，相同的对象结构可以供多个访问者访问。
让用户能够在不修改现有元素类层次结构的情况下，定义作用于该层次结构的操作。
主要缺点
增加新的元素很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，这违背了开闭原则的要求
需要对一个对象结构中的对象进行很多不同的并且不相关的操作，并且需要避免让这些操作‘污染’这些对象的类，也不希望在增加新操作时修改这些类。访问者模式将相关的访问操作集中起来定义在访问者类中，对象结构可以被多个不同的访问者类所使用，将对象本身与对象的访问操作分离
对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作