设计模式学习笔记——访问者模式

定义：

封装一些作用于某种数据结构中的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。

这里先来说一下访问者模式的使用场景：

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、违背了依赖倒置原则，访问者依赖的是具体的元素，而不是抽象元素。