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

原文：http://blog.csdn.net/hackerain/article/details/7564520

定义：

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

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

1、需要对一个对象结构中的对象进行很多不同且不相关的操作，而又不想让这些类变得异常繁杂。

2、一个对象包含很多的类对象，他们有不同的接口，而想对这些对象实施一些依赖于其具体类的操作，也就是用迭代器模式已经不能胜任的场景。

若所有的访问行为都在被访问的类中进行处理，如果不同的访问有很多的话，那么无疑会使代码一团糟，牵一发而动全身，所以就将这部分的功能给“抽”出来，在类外提供一个针对本类的各种访问的类，即Vistor类，这样就使得代码清晰，并且可扩展性非常的好。

在这里，举了一个对公司所有员工的报表和员工的工资统计的例子，先看一下类图：

对员工信息的报表和员工工资的总和是两个不同的访问者，他们都要访问Employee这个类，但是进行的操作却各不相同，各自不同的操作，在访问者的具体类中进行实现，在Employee类中，使用accept()方法，实现访问者对自己的访问。

其源代码如下：

[java]  view plain copy

1. public abstract class Employee {  
2.     public final static int MALE=0;//男性  
3.     public final static int FEMALE=1;//女性  
4.       
5.     //员工的基本信息  
6.     private String name;  
7.     private int salary;  
8.     private int sex;  
9.       
10.     public Employee(String name, int salary, int sex) {  
11.         this.name = name;  
12.         this.salary = salary;  
13.         this.sex = sex;  
14.     }  
15.     public String getName() {  
16.         return name;  
17.     }  
18.     public void setName(String name) {  
19.         this.name = name;  
20.     }  
21.     public int getSalary() {  
22.         return salary;  
23.     }  
24.     public void setSalary(int salary) {  
25.         this.salary = salary;  
26.     }  
27.     public int getSex() {  
28.         return sex;  
29.     }  
30.     public void setSex(int sex) {  
31.         this.sex = sex;  
32.     }  
33.       
34.     //允许访问者访问  
35.     public abstract void accept(IVistor vistor);  
36. }  

[java]  view plain copy

1. public class CommonEmployee extends Employee {  
2.   
3.     //普通员工的工作  
4.     private String job;  
5.   
6.     public CommonEmployee(String name, int salary, int sex) {  
7.         super(name, salary, sex);  
8.     }  
9.       
10.     public String getJob() {  
11.         return job;  
12.     }  
13.     public void setJob(String job) {  
14.         this.job = job;  
15.     }  
16.   
17.     //本类可以被访问者访问  
18.     @Override  
19.     public void accept(IVistor vistor) {  
20.         vistor.vistor(this);  
21.     }  
22.   
23. }  

[java]  view plain copy

1. public class ManagerEmployee extends Employee {  
2.       
3.     //管理者的业绩  
4.     private String performance;  
5.       
6.     public ManagerEmployee(String name, int salary, int sex) {  
7.         super(name, salary, sex);  
8.     }  
9.       
10.     public String getPerformance() {  
11.         return performance;  
12.     }  
13.   
14.     public void setPerformance(String performance) {  
15.         this.performance = performance;  
16.     }  
17.   
18.     //本类可以被访问者访问  
19.     @Override  
20.     public void accept(IVistor vistor) {  
21.         vistor.vistor(this);  
22.     }  
23.   
24. }  

[java]  view plain copy

1. /* 
2.  * 访问者的公共接口，可以访问普通员工和部门经理 
3.  */  
4. public interface IVistor {  
5.     public void vistor(CommonEmployee commonEmp);  
6.     public void vistor(ManagerEmployee managerEmp);  
7. }  

[java]  view plain copy

1. /* 
2.  * 产生报表的访问者接口 
3.  */  
4. public interface IShowVistor extends IVistor {  
5.     public void report();  
6. }  

[java]  view plain copy

1. /* 
2.  * 统计的访问者接口 
3.  */  
4. public interface ITotalVistor extends IVistor {  
5.     public void totalSalary();  
6. }  

[java]  view plain copy

1. /* 
2.  * 报表的具体访问者 
3.  */  
4. public class ShowVistor implements IShowVistor {  
5.   
6.     private String info="";  
7.       
8.     //访问普通员工  
9.     @Override  
10.     public void vistor(CommonEmployee commonEmp) {  
11.         this.info+=this.getBasicInfo(commonEmp)+"工作："+commonEmp.getJob()+"\t\n";  
12.     }  
13.   
14.     //访问管理者  
15.     @Override  
16.     public void vistor(ManagerEmployee managerEmp) {  
17.         this.info+=this.getBasicInfo(managerEmp)+"业绩："+managerEmp.getPerformance()+"\t\n";  
18.     }  
19.   
20.     //打印报表  
21.     @Override  
22.     public void report() {  
23.         System.out.println(this.info);  
24.     }  
25.       
26.     //获得基本信息  
27.     private String getBasicInfo(Employee employee){  
28.         String basicInfo="姓名："+employee.getName()+"\t";  
29.         basicInfo+="性别："+(employee.getSex()==Employee.MALE?"男":"女")+"\t\t";  
30.         basicInfo+="薪水："+employee.getSalary()+"\t";  
31.         return basicInfo;  
32.     }  
33. }  

[java]  view plain copy

1. /* 
2.  * 计算工资总和的具体访问者 
3.  */  
4. public class TotalVistor implements ITotalVistor {  
5.       
6.     private int commonTotalSalary=0;//普通员工的工资总和  
7.     private int managerTotalSalary=0;//管理者的工资总和  
8.       
9.     //访问普通员工，计算普通员工工资总和  
10.     @Override  
11.     public void vistor(CommonEmployee commonEmp) {  
12.         commonTotalSalary+=commonEmp.getSalary();  
13.     }  
14.   
15.     //访问管理者，计算管理者工资总和  
16.     @Override  
17.     public void vistor(ManagerEmployee managerEmp) {  
18.         managerTotalSalary+=managerEmp.getSalary();  
19.     }  
20.   
21.     //打印本公司的总工资  
22.     @Override  
23.     public void totalSalary() {  
24.         System.out.println("公司的工资总额为："+(managerTotalSalary+commonTotalSalary));  
25.     }  
26. }  

[java]  view plain copy

1. public class Client {  
2.     public static void main(String[] args) {  
3.           
4.         //产生数据  
5.         Vector<Employee> employee=mockEmployee();  
6.           
7.         //定义访问者  
8.         IShowVistor showVistor=new ShowVistor();  
9.         ITotalVistor totalVistor=new TotalVistor();  
10.           
11.         //对集合中的每个员工进行遍历，即让访问者访问每一个员工  
12.         for(Employee emp:employee){  
13.             emp.accept(showVistor);  
14.             emp.accept(totalVistor);  
15.         }  
16.           
17.         showVistor.report();  
18.         totalVistor.totalSalary();  
19.     }  
20.       
21.     public static Vector<Employee> mockEmployee(){  
22.           
23.         Vector<Employee> empList=new Vector<Employee>();  
24.           
25.         //三个员工  
26.         CommonEmployee suo=new CommonEmployee("suo",3000,Employee.MALE);  
27.         suo.setJob("coder");  
28.           
29.         CommonEmployee piao=new CommonEmployee("piao",4000,Employee.FEMALE);  
30.         piao.setJob("translator");  
31.           
32.         CommonEmployee datou=new CommonEmployee("datou",5000,Employee.FEMALE);  
33.         datou.setJob("hr");  
34.           
35.         //一个管理者  
36.         ManagerEmployee dai=new ManagerEmployee("dai",6000,Employee.FEMALE);  
37.         dai.setPerformance("good");  
38.           
39.         empList.add(suo);  
40.         empList.add(piao);  
41.         empList.add(datou);  
42.         empList.add(dai);  
43.           
44.         return empList;  
45.     }  
46. }  

[java]  view plain copy

1. 执行结果如下：  
2.   
3. 姓名：suo  性别：男        薪水：3000 工作：coder      
4. 姓名：piao 性别：女        薪水：4000 工作：translator     
5. 姓名：datou    性别：女        薪水：5000 工作：hr     
6. 姓名：dai  性别：女        薪水：6000 业绩：good   
7.   
8. 公司的工资总额为：18000  

访问者模式的优点：

1、符合单一职责原则

具体元素角色类和访问者类负责两个不同的职责，非常明确，耦合性很低。

2、扩展性很好。

访问者模式的缺点：

1、具体元素对访问者公布了细节，这不符合迪米特法则。
2、具体元素变更比较困难，比如增加了一个成员变量，那么相应的访问者类也要修改，如果有多个访问者类的话，那就有可能相当麻烦。

3、违背了依赖倒置原则，访问者依赖的是具体的元素，而不是抽象元素。

访问者模式的使用场景：

1、一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体操作类的操作，也就是说用迭代器模式已经不能胜任的情景

2、需要对一个对象结构中的对象进行很多不同并且不相关的操作，而你想避免让这些操作“污染”这些对象的类

业务规则要求遍历多个不同的对象。这本身也是访问者模式出发点，迭代器模式只能访问同类或同接口的数据（当然，如果使用instanceof，能访问所有的数据，这没有争论），而访问者模式是对迭代器模式的扩充，可以遍历不同的对象，然后执行不同的操作，也就是针对访问的对象不同，执行不同的操作。访问者模式还有一个用途，就是充当拦截器角色。