原文:http://blog.csdn.net/hackerain/article/details/7564520
定义:
封装一些作用于某种数据结构中的各元素的操作,它可以在不改变数据结构的前提下定义作用于这些元素的新的操作。
这里先来说一下访问者模式的使用场景:
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、违背了依赖倒置原则,访问者依赖的是具体的元素,而不是抽象元素。
访问者模式的使用场景:
1、一个对象结构包含很多类对象,它们有不同的接口,而你想对这些对象实施一些依赖于其具体操作类的操作,也就是说用迭代器模式已经不能胜任的情景
2、需要对一个对象结构中的对象进行很多不同并且不相关的操作,而你想避免让这些操作“污染”这些对象的类
业务规则要求遍历多个不同的对象。这本身也是访问者模式出发点,迭代器模式只能访问同类或同接口的数据(当然,如果使用instanceof,能访问所有的数据,这没有争论),而访问者模式是对迭代器模式的扩充,可以遍历不同的对象,然后执行不同的操作,也就是针对访问的对象不同,执行不同的操作。访问者模式还有一个用途,就是充当拦截器角色。