定义:
封装一些作用于某种数据结构中的各元素的操作,它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。
这里先来说一下访问者模式的使用场景:
1、需要对一个对象结构中的对象进行很多不同且不相关的操作,而又不想让这些类变得异常繁杂。
2、一个对象包含很多的类对象,他们有不同的接口,而想对这些对象实施一些依赖于其具体类的操作,也就是用迭代器模式已经不能胜任的场景。
若所有的访问行为都在被访问的类中进行处理,如果不同的访问有很多的话,那么无疑会使代码一团糟,牵一发而动全身,所以就将这部分的功能给“抽”出来,在类外提供一个针对本类的各种访问的类,即Vistor类,这样就使得代码清晰,并且可扩展性非常的好。
在这里,举了一个对公司所有员工的报表和员工的工资统计的例子,先看一下类图:
对员工信息的报表和员工工资的总和是两个不同的访问者,他们都要访问Employee这个类,但是进行的操作却各不相同,各自不同的操作,在访问者的具体类中进行实现,在Employee类中,使用accept()方法,实现访问者对自己的访问。
其源代码如下:
public abstract class Employee {
public final static int MALE=0;//男性
public final static int FEMALE=1;//女性
//员工的基本信息
private String name;
private int salary;
private int sex;
public Employee(String name, int salary, int sex) {
this.name = name;
this.salary = salary;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
//允许访问者访问
public abstract void accept(IVistor vistor);
}
public class CommonEmployee extends Employee {
//普通员工的工作
private String job;
public CommonEmployee(String name, int salary, int sex) {
super(name, salary, sex);
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
//本类可以被访问者访问
@Override
public void accept(IVistor vistor) {
vistor.vistor(this);
}
}
public class ManagerEmployee extends Employee {
//管理者的业绩
private String performance;
public ManagerEmployee(String name, int salary, int sex) {
super(name, salary, sex);
}
public String getPerformance() {
return performance;
}
public void setPerformance(String performance) {
this.performance = performance;
}
//本类可以被访问者访问
@Override
public void accept(IVistor vistor) {
vistor.vistor(this);
}
}
/*
* 访问者的公共接口,可以访问普通员工和部门经理
*/
public interface IVistor {
public void vistor(CommonEmployee commonEmp);
public void vistor(ManagerEmployee managerEmp);
}
/*
* 产生报表的访问者接口
*/
public interface IShowVistor extends IVistor {
public void report();
}
/*
* 统计的访问者接口
*/
public interface ITotalVistor extends IVistor {
public void totalSalary();
}
/*
* 报表的具体访问者
*/
public class ShowVistor implements IShowVistor {
private String info="";
//访问普通员工
@Override
public void vistor(CommonEmployee commonEmp) {
this.info+=this.getBasicInfo(commonEmp)+"工作:"+commonEmp.getJob()+"\t\n";
}
//访问管理者
@Override
public void vistor(ManagerEmployee managerEmp) {
this.info+=this.getBasicInfo(managerEmp)+"业绩:"+managerEmp.getPerformance()+"\t\n";
}
//打印报表
@Override
public void report() {
System.out.println(this.info);
}
//获得基本信息
private String getBasicInfo(Employee employee){
String basicInfo="姓名:"+employee.getName()+"\t";
basicInfo+="性别:"+(employee.getSex()==Employee.MALE?"男":"女")+"\t\t";
basicInfo+="薪水:"+employee.getSalary()+"\t";
return basicInfo;
}
}
/*
* 计算工资总和的具体访问者
*/
public class TotalVistor implements ITotalVistor {
private int commonTotalSalary=0;//普通员工的工资总和
private int managerTotalSalary=0;//管理者的工资总和
//访问普通员工,计算普通员工工资总和
@Override
public void vistor(CommonEmployee commonEmp) {
commonTotalSalary+=commonEmp.getSalary();
}
//访问管理者,计算管理者工资总和
@Override
public void vistor(ManagerEmployee managerEmp) {
managerTotalSalary+=managerEmp.getSalary();
}
//打印本公司的总工资
@Override
public void totalSalary() {
System.out.println("公司的工资总额为:"+(managerTotalSalary+commonTotalSalary));
}
}
public class Client {
public static void main(String[] args) {
//产生数据
Vector<Employee> employee=mockEmployee();
//定义访问者
IShowVistor showVistor=new ShowVistor();
ITotalVistor totalVistor=new TotalVistor();
//对集合中的每个员工进行遍历,即让访问者访问每一个员工
for(Employee emp:employee){
emp.accept(showVistor);
emp.accept(totalVistor);
}
showVistor.report();
totalVistor.totalSalary();
}
public static Vector<Employee> mockEmployee(){
Vector<Employee> empList=new Vector<Employee>();
//三个员工
CommonEmployee suo=new CommonEmployee("suo",3000,Employee.MALE);
suo.setJob("coder");
CommonEmployee piao=new CommonEmployee("piao",4000,Employee.FEMALE);
piao.setJob("translator");
CommonEmployee datou=new CommonEmployee("datou",5000,Employee.FEMALE);
datou.setJob("hr");
//一个管理者
ManagerEmployee dai=new ManagerEmployee("dai",6000,Employee.FEMALE);
dai.setPerformance("good");
empList.add(suo);
empList.add(piao);
empList.add(datou);
empList.add(dai);
return empList;
}
}
执行结果如下:
姓名:suo 性别:男 薪水:3000 工作:coder
姓名:piao 性别:女 薪水:4000 工作:translator
姓名:datou 性别:女 薪水:5000 工作:hr
姓名:dai 性别:女 薪水:6000 业绩:good
公司的工资总额为:18000
访问者模式的优点:
1、符合单一职责原则
具体元素角色类和访问者类负责两个不同的职责,非常明确,耦合性很低。
2、扩展性很好。
访问者模式的缺点:
1、具体元素对访问者公布了细节,这不符合迪米特法则。
2、具体元素变更比较困难,比如增加了一个成员变量,那么相应的访问者类也要修改,如果有多个访问者类的话,那就有可能相当麻烦。
3、违背了依赖倒置原则,访问者依赖的是具体的元素,而不是抽象元素。