定义
访问者模式(Visitor Pattern):提供一个作用于某对象结构中的各元素的操作表示，它使我们可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式是一种对象行为型模式。
- 被访问元素通常不是单独存在的，它们存储在一个集合中，这个集合被称为“对象结构”
结构图
要素：
- Vistor（抽象访问者）：抽象访问者为对象结构中每一个具体元素类ConcreteElement声明一个访问操作，从这个操作的名称或参数类型可以清楚知道需要访问的具体元素的类型，具体访问者需要实现这些操作方法，定义对这些元素的访问操作。
- ConcreteVisitor（具体访问者）：具体访问者实现了每个由抽象访问者声明的操作，每一个操作用于访问对象结构中一种类型的元素。
- Element（抽象元素）：抽象元素一般是抽象类或者接口，它定义一个accept()方法，该方法通常以一个抽象访问者作为参数。
- ConcreteElement（具体元素）：具体元素实现了accept()方法，在accept()方法中调用访问者的访问方法以便完成对一个元素的操作。
- ObjectStructure（对象结构）：对象结构是一个元素的集合，它用于存放元素对象，并且提供了遍历其内部元素的方法。它可以结合组合模式来实现，也可以是一个简单的集合对象，如一个List对象或一个Set对象。
扩展：
访问者模式包括两个层次结构，一个是访问者层次结构，提供了抽象访问者和具体访问者，一个是元素层次结构，提供了抽象元素和具体元素。
abstract class Visitor
{
public abstract void visit(ConcreteElementA elementA);
public abstract void visit(ConcreteElementB elementB);
public void visit(ConcreteElementC elementC)
{
//元素ConcreteElementC操作代码
}
}
class ConcreteVisitor extends Visitor
{
public void visit(ConcreteElementA elementA)
{
//元素ConcreteElementA操作代码
}
public void visit(ConcreteElementB elementB)
{
//元素ConcreteElementB操作代码
}
}
interface Element
{
public void accept(Visitor visitor);
}
class ConcreteElementA implements Element
{
public void accept(Visitor visitor)
{
visitor.visit(this);
}
public void operationA()
{
//业务方法
}
}
class ObjectStructure
{
private ArrayList list = new ArrayList(); //定义一个集合用于存储元素对象
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);
}
}
示例
Sunny软件公司欲为某银行开发一套OA系统，在该OA系统中包含一个员工信息管理子系统，该银行员工包括正式员工和临时工，每周人力资源部和财务部等部门需要对员工数据进行汇总，汇总数据包括员工工作时间、员工工资等。该公司基本制度如下：
(1) 正式员工(Full time Employee)每周工作时间为40小时，不同级别、不同部门的员工每周基本工资不同；如果超过40小时，超出部分按照100元/小时作为加班费；如果少于40小时，所缺时间按照请假处理，请假所扣工资以80元/小时计算，直到基本工资扣除到零为止。除了记录实际工作时间外，人力资源部需记录加班时长或请假时长，作为员工平时表现的一项依据。
(2) 临时工(Part time Employee)每周工作时间不固定，基本工资按小时计算，不同岗位的临时工小时工资不同。人力资源部只需记录实际工作时间。
人力资源部和财务部工作人员可以根据各自的需要对员工数据进行汇总处理，人力资源部负责汇总每周员工工作时间，而财务部负责计算每周员工工资。
import java.util.*;
class EmployeeList
{
private ArrayList list = new ArrayList(); //员工集合
//增加员工
public void addEmployee(Employee employee)
{
list.add(employee);
}
//处理员工数据
public void handle(String departmentName)
{
if(departmentName.equalsIgnoreCase("财务部")) //财务部处理员工数据
{
for(Object obj : list)
{
if(obj.getClass().getName().equalsIgnoreCase("FulltimeEmployee"))
{
System.out.println("财务部处理全职员工数据！");
}
else
{
System.out.println("财务部处理兼职员工数据！");
}
}
}
else if(departmentName.equalsIgnoreCase("人力资源部")) //人力资源部处理员工数据
{
for(Object obj : list)
{
if(obj.getClass().getName().equalsIgnoreCase("FulltimeEmployee"))
{
System.out.println("人力资源部处理全职员工数据！");
}
else
{
System.out.println("人力资源部处理兼职员工数据！");
}
}
}
}
}
解决方案
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 list = new ArrayList();
public void addEmployee(Employee employee)
{
list.add(employee);
}
//遍历访问员工集合中的每一个员工对象
public void accept(Department handler)
{
for(Object obj : list)
{
((Employee)obj).accept(handler);
}
}
}
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);
}
}
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;
}
}
}
FADepartment
引申话题：具体元素之间若存在整体与部分关系，有些元素作为容器对象，有些元素作为成员对象，则可以使用组合模式来组织元素
总结
主要优点如下：
(1) 增加新的访问操作很方便。使用访问者模式，增加新的访问操作就意味着增加一个新的具体访问者类，实现简单，无须修改源代码，符合“开闭原则”。
(2) 将有关元素对象的访问行为集中到一个访问者对象中，而不是分散在一个个的元素类中。类的职责更加清晰，有利于对象结构中元素对象的复用，相同的对象结构可以供多个不同的访问者访问。
(3) 让用户能够在不修改现有元素类层次结构的情况下，定义作用于该层次结构的操作。主要缺点如下：
(1) 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类都意味着要在抽象访问者角色中增加一个新的抽象操作，并在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”的要求。
(2) 破坏封装。访问者模式要求访问者对象访问并调用每一个元素对象的操作，这意味着元素对象有时候必须暴露一些自己的内部操作和内部状态，否则无法供访问者访问。
适用场景
(1) 一个对象结构包含多个类型的对象，希望对这些对象实施一些依赖其具体类型的操作。在访问者中针对每一种具体的类型都提供了一个访问操作，不同类型的对象可以有不同的访问操作。
(2) 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。访问者模式使得我们可以将相关的访问操作集中起来定义在访问者类中，对象结构可以被多个不同的访问者类所使用，将对象本身与对象的访问操作分离。
(3) 对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。