今天天气不错，绝对是晴空万里，骄阳似火呀，好，我们今天来讲访问者模式，我们在前面讲了组合模式和迭代器模式，通过组合模式我们能够把一个公司的人员组织机构树搭建起来，给管理带来非常大的便利，通过迭代器模式我们可以把每一个员工都遍历一遍，看看是不是有“人去世了还在领退休金”， “拿高工资而不干活的尸位素餐”等情况，那我们今天的要讲访问者模式是做什么用的呢？
我们公司有七百多技术人员，分布在全国各地，组织架构你在组合模式中也看到了，很常见的家长领导型模式，每个技术人员的岗位都是固定的，你在组织机构的那棵树下，充当的是什么叶子节点都是非常明确的，每一个员工的信息比如名字、性别、薪水等都是记录在数据库中，现在有这样一个需求，我要把公司中的所有人员信息都打印汇报上去，很简单吧，我们来看类图：
这个类图还是比较简单的，使用了一个模版方法模式，把所要的信息都打印出来，我们先来看一下抽象类：
1 package com.pattern.visitor;
2
3 /**
4 * 在一个单位里谁都是员工，不管你是部门经理还是喜爱并
5 *
6 * @author http://www.cnblogs.com/initial-road/
7 *
8 */
9 public abstract class Employee {
10 public final static int MALE = 0; // 0代表男性
11 public final static int FEMALE = 1; // 1代表女性
12 // 不管是谁，都有名字
13 private String name;
14
15 // 只要是员工那就有薪水
16 private int salary;
17
18 // 性别很重要
19 private int sex;
20
21 public String getName() {
22 return name;
23 }
24
25 public void setName(String name) {
26 this.name = name;
27 }
28
29 public int getSalary() {
30 return salary;
31 }
32
33 public void setSalary(int salary) {
34 this.salary = salary;
35 }
36
37 public int getSex() {
38 return sex;
39 }
40
41 public void setSex(int sex) {
42 this.sex = sex;
43 }
44
45 // 打印出员工的信息
46 public final void report(){
47 String info = "姓名：" + this.name + "\t";
48 info = info + "性别：" + (this.sex == FEMALE?"女":"男") + "\t";
49 info = info + "薪水：" + this.salary + "\t";
50 info = info + this.getOtherInfo();
51 System.out.println(info);
52 }
53
54 // 拼装员工的其他信息
55 protected abstract String getOtherInfo();
56 }
再看小兵的实现类，越卑微的人物越能引起共鸣，因为我们有共同的经历、思维和苦难，呵呵，看实现类：
1 package com.pattern.visitor;
2
3 /**
4 * 普通员工，也就是最小的小兵
5 *
6 * @author http://www.cnblogs.com/initial-road/
7 *
8 */
9 public class CommonEmployee extends Employee {
10
11 // 工作内容，这个非常重要，以后的职业规划就是靠这个了
12 private String job;
13
14 public String getJob() {
15 return job;
16 }
17
18 public void setJob(String job) {
19 this.job = job;
20 }
21
22 protected String getOtherInfo() {
23 return "工作：" + this.job + "\t";
24 }
25
26 }
27
28 // 在来看领导阶层:
29
30 package com.pattern.visitor;
31
32 /**
33 * 经理级任务
34 * @author http://www.cnblogs.com/initial-road/
35 *
36 */
37 public class Manager extends Employee {
38
39 // 这类任务的职责非常明确：业绩
40 private String performance;
41
42 public String getPerformance() {
43 return performance;
44 }
45
46 public void setPerformance(String performance) {
47 this.performance = performance;
48 }
49
50 protected String getOtherInfo() {
51 return "业绩：" + this.performance + "\t";
52 }
53
54 }
Performance 这个单词在我们技术人员的眼里就是代表性能，在实际商务英语中可以有 SalesPerformance 销售业绩，performance evaluation 业绩评估等等。然后我们来看一下我们的 Client 类：
1 package com.pattern.visitor;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 public class Client {
7
8 public static void main(String[] args) {
9 for(Employee emp : mockEmployee()){
10 emp.report();
11 }
12 }
13
14 // 模拟出公司的人员情况，我们可以想象这个数据是通过持久层传递过来的
15 public static List<Employee> mockEmployee(){
16 List<Employee> empList = new ArrayList<Employee>();
17
18 // 产生张三这个员工
19 CommonEmployee zhangSan = new CommonEmployee();
20 zhangSan.setJob("编写Java程序，绝对的蓝领、苦工加搬运工");
21 zhangSan.setName("张三");
22 zhangSan.setSalary(1800);
23 zhangSan.setSex(Employee.MALE);
24 empList.add(zhangSan);
25
26 // 产生李四这个员工
27 CommonEmployee liSi = new CommonEmployee();
28 liSi.setJob("页面美工，审美素质太不流行了!");
29 liSi.setName("李四");
30 liSi.setSalary(1900);
31 liSi.setSex(Employee.FEMALE);
32 empList.add(liSi);
33
34 // 再产生一个经理
35 Manager wangWu = new Manager();
36 wangWu.setName("王五");
37 wangWu.setPerformance("基本上是负值，但是我会拍马屁呀！");
38 wangWu.setSalary(18750);
39 wangWu.setSex(Employee.MALE);
40 empList.add(wangWu);
41
42 return empList;
43 }
44 }
先通过 mockEmployee 来模拟出一个数组，当然了在实际项目中这个数组应该是从持久层产生过来的。
结果出来后非常正确。我们来想一想这个实际的情况，人力资源部门拿这这份表格会给谁看呢？那当然是大老板了，大老板关心的是什么？关心部门经理的业绩！小兵的情况不是他要了解的，就像二战的时候一位将军（巴顿？艾森豪威尔？记不清楚了）说的“我一想到我的士兵也有孩子、妻子、父母，我 就痛心疾首，…但是这是战场，我只能认为他们是一群机器…”，是呀，其实我们也一样呀，那问题就出来了：
大老板就看部门经理的报表，小兵的报表可看可不看；
多个大老板，“嗜好”是不同的，主管销售的，则主要关心的营销情况；主管会计的，则主要关心企业的整体财务运行状态；主管技术的，则主要看技术的研发情况；
综合成一句话，这个报表会有修改：数据的修改以及报表的展现修改，按照开闭原则，项目分析的时候已经考虑到这些可能引起变更的隐私，就需要在设计时考虑通过扩展来避开未来需求变更而引起的代码修改风险。我们来想一想，每个普通员工类和经理类都一个方法 report，那是否可以把这个方法提取到 另外一个类中来实现呢？原有的示意图如下：
这两个类都一个相同的方法 report()，但是要实现的内容不相同，而且还有可能会发生变动，那我们就让其他类来实现这个 report 方法，好，看示意图的变更：
两个类的 report 方法都不需要了，只有 Visitor 类来实现了 report 的方法，这个猛一看还真有点委托（intergration）的意味，我们实现下来你就知道这和委托有非常大的差距，我们来看类图：
在抽象类 Employee 中增加了 accept 方法，这个方法是定义我这个类可以允许被谁来访问，也就定义一类访问者，在具体的实现类中调用访问者的方法。我们先看访问者接口 IVisitor 程序：
1 package com.pattern.visitor.advance;
2
3 /**
4 * 访问者，要去访问人家的数据了
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public interface IVisitor {
9
10 // 首先定义我可以访问普通员工
11 public void visit(CommonEmployee commonEmployee);
12
13 // 其次定义，我还可以访问部门经理
14 public void visit(Manager manager);
15
16 }
17
18 // 如下是访问者的实现类：
19
20 package com.pattern.visitor.advance;
21
22 /**
23 * 观察者，查看人家的信息
24 * @author http://www.cnblogs.com/initial-road/
25 *
26 */
27 public class Visitor implements IVisitor {
28
29 // 访问普通员工，打印出报表
30 public void visit(CommonEmployee commonEmployee) {
31 System.out.println(this.getCommonEmployee(commonEmployee));
32 this.calCommonSalary(commonEmployee.getSalary());
33 }
34
35 // 访问部门经理，打印报表
36 public void visit(Manager manager) {
37 System.out.println(this.getManagerInfo(manager));
38 this.calManagerSalary(manager.getSalary());
39 }
40
41 // 组装出基本信息
42 private String getBasicInfo(Employee employee){
43 String info = "姓名：" + employee.getName() + "\t";
44 info = info + "性别：" + (employee.getSex() == Employee.FEMALE?"女":"男") + "\t";
45 info = info + "薪水：" + employee.getSalary() + "\t";
46 return info;
47 }
48
49 // 组装出部门经理的信息
50 private String getManagerInfo(Manager manager){
51 String basicInfo = this.getBasicInfo(manager);
52 String otherInfo = "业绩：" + manager.getPerformance() + "\t";
53 return basicInfo + otherInfo;
54 }
55
56 // 组装出普通员工信息
57 private String getCommonEmployee(CommonEmployee commonEmployee){
58 String basicInfo = this.getBasicInfo(commonEmployee);
59 String otherInfo = "工作：" + commonEmployee.getJob() + "\t";
60 return basicInfo + otherInfo;
61 }
62
63 }
在具体的实现类中，定义了两个私有方法，作用就是产生需要打印的数据和格式，然后在访问者访问相关的对象是，产生这个报表。继续看 Employee抽象类：
1 package com.pattern.visitor.advance;
2
3 /**
4 * 在一个单位里谁都是员工，不管你是部门经理还是小兵
5 *
6 * @author http://www.cnblogs.com/initial-road/
7 *
8 */
9 public abstract class Employee {
10 // 0代表是男性
11 public final static int MALE = 0;
12 // 1代表是女性
13 public final static int FEMALE = 1;
14 // 不管是谁，都有工资
15 private String name;
16 // 只要是员工那就有薪水
17 private int salary;
18 // 性别很重要
19 private int sex;
20
21 public String getName() {
22 return name;
23 }
24
25 public void setName(String name) {
26 this.name = name;
27 }
28
29 public int getSalary() {
30 return salary;
31 }
32
33 public void setSalary(int salary) {
34 this.salary = salary;
35 }
36
37 public int getSex() {
38 return sex;
39 }
40
41 public void setSex(int sex) {
42 this.sex = sex;
43 }
44
45 // 允许一个访问者过来访问
46 public abstract void accept(IVisitor visitor);
47
48 }
49
50 // 删除了 report 方法，增加了 accept 方法，需要实现类来实现。继续看实现类：
51
52 package com.pattern.visitor.advance;
53
54 /**
55 * 普通员工
56 * @author http://www.cnblogs.com/initial-road/
57 *
58 */
59 public class CommonEmployee extends Employee {
60
61 // 工作内容，这个非常重要，以后的职业规划就是靠这个了
62 private String job;
63
64 public String getJob() {
65 return job;
66 }
67
68 public void setJob(String job) {
69 this.job = job;
70 }
71
72 // 允许访问者过来访问
73 public void accept(IVisitor visitor) {
74 visitor.visit(this);
75 }
76
77 }
上面是普通员工的实现类，这个实现类的 accept 方法很简单，这个类就把自身传递过去，也就是让访问者访问本身这个对象。再看 Manager 类：
1 package com.pattern.visitor.advance;
2
3 /**
4 * 经理级人物
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public class Manager extends Employee {
9
10 // 这类人物的职责非常明确：业绩
11 private String performance;
12
13 public void setPerformance(String performance) {
14 this.performance = performance;
15 }
16
17 public String getPerformance() {
18 return performance;
19 }
20
21 // 部门经理允许访问者访问
22 public void accept(IVisitor visitor) {
23 visitor.visit(this);
24 }
25
26 }
所有的业务定义都已经完成，我们来看看怎么调用这个逻辑：
1 package com.pattern.visitor.advance;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 public class Client {
7
8 public static void main(String[] args) {
9 for(Employee emp : mockEmployee()){
10 emp.accept(new Visitor());
11 }
12 }
13
14 // 模拟出公司的人员情况
15 public static List<Employee> mockEmployee(){
16 List<Employee> empList = new ArrayList<Employee>();
17
18 // 产生这三这个员工
19 CommonEmployee zhangSan = new CommonEmployee();
20 zhangSan.setJob("编写Java程序，绝对的蓝领、苦工加搬运工");
21 zhangSan.setName("张三");
22 zhangSan.setSalary(1800);
23 zhangSan.setSex(Employee.MALE);
24 empList.add(zhangSan);
25
26 // 产生李四这个员工
27 CommonEmployee liSi = new CommonEmployee();
28 liSi.setJob("页面美工，审美素质太不流行了！");
29 liSi.setName("李四");
30 liSi.setSalary(1900);
31 liSi.setSex(Employee.FEMALE);
32 empList.add(liSi);
33
34 // 再产生一个经理
35 Manager wangWu = new Manager();
36 wangWu.setName("王五");
37 wangWu.setPerformance("基本上是负值，但是我会拍马屁呀！");
38 wangWu.setSalary(18750);
39 wangWu.setSex(Employee.MALE);
40 empList.add(wangWu);
41
42 return empList;
43 }
44 }
改动非常少，那回过头我们来看看这个程序是怎么实现的：
首先通过循环遍历所有元素；
其次，每个员工对象都定义了一个访问者；
再其次，员工对象把自己做为一个参数调用访问者 visit 方法；
然后，访问者调用自己内部的计算逻辑，计算出相应的数据和表格元素；
最后，访问者打印出报表和数据；
事情的经过就是这个样子滴~，那我们再来看看上面提到的数据和报表格式都会改变的情况，首先数据的改变，数据改那当然都要改，这个没跑，说不上两个方案有什么优劣；其次报表格式修改，这个方案绝对是有优势的，你看我只要再产生一个 Visitor 就可以产生一个新的报表格式，而其他的类都不用修改，再如果你是用 Spring 开发的话，那就更爽了，在 Spring 的配置文件中使用的是接口注入，我只要把配置文件<property name=”xxx” ref=””/>中的ref 修改一下就成，别的什么都不用修改了！
以上讲的就是访问者模式，这个模式的通用类图如下：
看了这个通用类图，大家可能要犯迷糊了，这里怎么有一个 ObjectStruture 这个类呢？你刚刚举得例子就没有呢？真没有嘛？我们不是定义了一个List 了吗？这就是一个 ObjectStruture， 我们来看这几个角色的职责：
抽象访问者（Visitor）：抽象类或者接口，声明访问者可以访问哪些元素，具体到程序中就是 visit方法的参数定义哪些对象是可以被访问的；
具体访问者（ConcreteVisitor）:访问者访问到一个类后要做什么事情；
抽象元素（Element）：接口或者抽象类，声明接受那一类型的访问者访问，程序上是通过 accept 方法中的参数来定义；
具体元素： （ConcreteElement）:实现 accept 方法，通常是 visitor.visit(this)，基本上都形成了一个套路了；
结构对象(ObjectStruture):容纳多个不同类、不同接口的容器，比如 List、Set、Map 等，在项目中，一般很少抽象出来这个角色；
大家可以这样理解访问者模式，我作为一个访客（Visitor）到朋友家（Visited Class）去拜访，朋友之间聊聊天，喝喝酒，再相互吹捧吹捧，炫耀炫耀，这都正常，聊天的时候，朋友告诉我，他今年加官进爵了，工资也涨了 30%，准备再买套房子，那我就在心里盘算（Visitor-self-method）“你个龟儿子，这么有钱，老子去年要借 10W 你都不借”，我根据被朋友的信息，执行了自己的一个方法。
接下来我们来思考一下，访问者可以用在什么地方。在这种地方你一定要考虑到使用访问者模式：业务规则要求遍历多个不同的对象。这本身也是访问者模式出发点，迭代器模式只能访问同类或同接口的数据， （当然了，你使用 instanceof 的话，能访问所有的数据，这个不争论），而访问者模式是对迭代器模式的扩充，可以遍历不同的对象，然后执行不同的操作，也就是针对访问的对象不同，执行不同的操作。访问者模式还有一个用途，就是充当拦截器（Interceptor）角色，这个我们在后边来讲。
访问者模式有哪些优点呢？首先是符合单一职责原则，具体元素角色也就是 Employee 这个类的两个子类负责数据的加载，而 Visitor 类则负责报表的展现，两个不同的职责非常明确的分离开来，各自演绎而变化；其次，由于职责分开，继续增加对数据的操作是非常快捷的，例如现在要增加一个给最大老板的一份报表，这份报表格式又有所不同，容易处理吧，直接在 Visitor 中增加一个方法，传递过来数据后进行整理打印；最后，数据汇总，就以刚刚我们说的Employee 的例子，如果我现在要统计所有员工的工资之和，怎么计算？把所有人的工资 for 循环加一遍？是个办法，那我再提个问题，员工工资*1.2，部门经理*1.4，总经理*1.8，然后把这些工资加起来，你怎么处理？1.2，1.4，1.8 是什么？我 K，你没看到领导不论什么时候都比你拿的多，工资奖金就不说了，就是过节发个慰问劵也比你多，就是这个系数在作祟。我们继续说你先怎么统计？使用 for 循环，然后使用 instanceof 来判断是员工还是经理？可以解决，但不是个好办法，好办法是通过访问者模式来实现，把数据扔给访问者，由访问者来进行统计计算。
访问者模式的缺点也很明显，访问者要访问一个类就必然要求这个类公布一些方法，也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的；还有一个缺点就是，具体角色的增加删除修改都是比较苦难的，就上面那个例子，你想想，你要是想增加一个成员变量，比如年龄 age，Visitor 就需要修改，如果 Visitor 是一个还好说，多个呢？业务逻辑再复杂点呢？访问者模式是有缺点的，是事物都有缺点，但是这仍然掩盖不了它的光芒，访问者模式结合其他模式比如模版方法模式、状态模式、解释器模式、代理模式等就会非常强大，这个我们放在模式混编中来讲解。
访问者模式是会经常用到的模式，虽然你不注意，有可能你起的名字也不是什么 Visitor，但是这个是非常容易使用到的，在这里我提出三个扩展的功能共大家参考。
统计功能。在访问者模式的使用中我也提到访问者的统计功能，汇总和报表是金融类企业非常常用的功能，基本上都是一堆的计算公式，然后出一个报表，很多项目是采用了数据库的存储过程来实现，这个我不是很推荐，除非海量数据处理，一个晚上要上亿、几十亿条的数据跑批处理，这个除了存储过程来处理没有其他办法的，你要是用应用服务器来处理，连接数据库的网络就是处于 100%占用状态，一个晚上也未必跑得完这批数据！除了这种海量数据外，我建议数据统计和报表的批处理通过访问者模式来理会比较简单。好，那我们来统计一下公司人员的工资，先看类图：
就在接口上增加了一个 getTotalSalary方法，在 Visitor 实现类中实现该方法，我们先看接口：
1 package com.pattern.visitor.advance;
2
3 /**
4 * 访问者，要去访问人家的数据了
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public interface IVisitor {
9
10 // 首先定义我可以访问普通员工
11 public void visit(CommonEmployee commonEmployee);
12
13 // 其次定义，我还可以访问部门经理
14 public void visit(Manager manager);
15
16 // 统计所有员工工资总和
17 public int getTotalSalary();
18
19 }
20
21 // 就多了一个 getTotalSalary 方法，我们再来看实现类：
22
23 package com.pattern.visitor.advance;
24
25 /**
26 * 观察者，查看人家的信息
27 * @author http://www.cnblogs.com/initial-road/
28 *
29 */
30 public class Visitor implements IVisitor {
31 // 部门经理的工资系数是5
32 private final static int MANAGER_COEFFICIENT = 5;
33
34 // 员工的工资系数是2
35 private final static int COMMONEMPLOYEE_COEFFICIENT = 2;
36
37 // 普通员工的工资总和
38 private int commonTotalSalary = 0;
39
40 // 部门经理的工资总和
41 private int managerTotalSalary = 0;
42
43 // 访问普通员工，打印出报表
44 public void visit(CommonEmployee commonEmployee) {
45 System.out.println(this.getCommonEmployee(commonEmployee));
46 this.calCommonSalary(commonEmployee.getSalary());
47 }
48
49 // 访问部门经理，打印报表
50 public void visit(Manager manager) {
51 System.out.println(this.getManagerInfo(manager));
52 this.calManagerSalary(manager.getSalary());
53 }
54
55 // 组装出基本信息
56 private String getBasicInfo(Employee employee){
57 String info = "姓名：" + employee.getName() + "\t";
58 info = info + "性别：" + (employee.getSex() == Employee.FEMALE?"女":"男") + "\t";
59 info = info + "薪水：" + employee.getSalary() + "\t";
60 return info;
61 }
62
63 // 组装出部门经理的信息
64 private String getManagerInfo(Manager manager){
65 String basicInfo = this.getBasicInfo(manager);
66 String otherInfo = "业绩：" + manager.getPerformance() + "\t";
67 return basicInfo + otherInfo;
68 }
69
70 // 组装出普通员工信息
71 private String getCommonEmployee(CommonEmployee commonEmployee){
72 String basicInfo = this.getBasicInfo(commonEmployee);
73 String otherInfo = "工作：" + commonEmployee.getJob() + "\t";
74 return basicInfo + otherInfo;
75 }
76
77 // 计算部门经理的工资总和
78 private void calManagerSalary(int salary){
79 this.managerTotalSalary = this.managerTotalSalary + salary * MANAGER_COEFFICIENT;
80 }
81
82 // 计算普通员工的工资总和
83 private void calCommonSalary(int salary){
84 this.commonTotalSalary = this.commonTotalSalary + salary * COMMONEMPLOYEE_COEFFICIENT;
85 }
86
87 // 获得所有员工的工资总和
88 public int getTotalSalary() {
89 return this.commonTotalSalary + this.managerTotalSalary;
90 }
91 }
程序比较长，但是还是比较简单的，分别计算普通员工和经理级员工的工资总和，然后加起来。注意我们在实现时已经考虑员工工资和经理工资的系数不同。
我们再来看 Client 类的调用：
1 package com.pattern.visitor.advance;
2
3 public class Client {
4
5 public static void main(String[] args) {
6 IVisitor visitor = new Visitor();
7 for(Employee emp : mockEmployee()){
8 emp.accept(visitor);
9 }
10 System.out.println("本公司的月工资总额是：" + visitor.getTotalSalary());
11 }
12 }
其中 mockEmployee 静态方法没有任何改动，就没有拷贝上去。
然后你想修改工资的系数，没有问题！想换个展示格式，也没有问题！自己练习一下吧
多个访问者。在实际的项目中，一个对象，多个访问者的情况非常多。其实我们上面例子就应该是两个访问者，为什么呢？报表分两种，一种是展示表，通过数据库查询，把结果展示出来，这个就类似于我们的那个列表；第二种是汇总表，这个是需要通过模型或者公式计算出来的，一般都是批处理结果，这个类似于我们计算工资总额，这两种报表格式是对同一堆数据的两种处理方式，从程序上看，一个类就有个不同的访问者了，那我们修改一下类图：
类图看着挺恐怖，其实也没啥复杂的，多了两个接口和两个实现类，分别负责展示表和汇总表的业务处理，我们先看 IVisitor 接口程序：
1 package com.pattern.visitor.extend;
2
3 /**
4 * 访问者，要去访问人家的数据了
5 * @author http://www.cnblogs.com/initial-road/
6 *
7 */
8 public interface IVisitor {
9
10 // 首先定义我可以访问普通员工
11 public void visit(CommonEmployee commonEmployee);
12
13 // 其次定义，我还可以访问部门经理
14 public void visit(Manager manager);
15
16 }
17
18 // 该接口定义其下的实现类能够访问哪些类 ，子接口定义了具体访问者的任务和责任，先看ITotalVisitor接口：
19
20 package com.pattern.visitor.extend;
21
22 /**
23 * 负责统计报表的产生
24 * @author http://www.cnblogs.com/initial-road/
25 *
26 */
27 public interface ITotalVisitor extends IVisitor {
28
29 // 统计所有员工工资总和
30 public void totalSalary();
31
32 }
33
34 // 就一句话，非常简单，我们再来看展示表：
35
36 package com.pattern.visitor.extend;
37
38 /**
39 * 负责展示报表的产生
40 * @author http://www.cnblogs.com/initial-road/
41 *
42 */
43 public interface IShowVisitor extends IVisitor {
44
45 // 展示报表
46 public void report();
47
48 }
49
50 // 也是就一句话，我们展示表访问者的实现类：
51
52 package com.pattern.visitor.extend;
53
54 /**
55 * 展示报表，该访问者的工作就是看到什么数据展示什么数据
56 * @author http://www.cnblogs.com/initial-road/
57 *
58 */
59 public class ShowVisitor implements IShowVisitor {
60 private String info = "";
61
62 // 打印出报表
63 public void report() {
64 System.out.println(this.info);
65 }
66
67 // 访问普通员工，组装信息
68 public void visit(CommonEmployee commonEmployee) {
69 this.info = this.info + this.getBasicInfo(commonEmployee) + "\t";
70 this.info = this.info + commonEmployee.getJob() + "\t\n";
71 }
72
73 // 访问经理，然后组装信息
74 public void visit(Manager manager) {
75 this.info = this.info + this.getBasicInfo(manager);
76 this.info = this.info + "业绩：" + manager.getPerformance() + "\t\n";
77 }
78
79 // 组装出基本信息
80 private String getBasicInfo(Employee employee){
81 String info = "姓名：" + employee.getName() + "\t";
82 info = info + "性别：" + (employee.getSex() == Employee.FEMALE?"女":"男") + "\t";
83 info = info + "薪水：" + employee.getSalary() + "\t";
84 return info;
85 }
86
87 }
88
89 // 下面是汇总表访问者：
90
91 package com.pattern.visitor.extend;
92
93 /**
94 * 汇总表，该访问者起汇作用，把容器中的数据一个一个遍历，然后汇总
95 * @author http://www.cnblogs.com/initial-road/
96 *
97 */
98 public class TotalVisitor implements ITotalVisitor {
99 // 部门经理的工资系数是5
100 private static final int MANAGER_COEFFICIENT = 5;
101 // 员工的工资系数是2
102 private static final int COMMONEMPLOYEE_COEFFICIENT = 2;
103 // 普通员工的工资总和
104 private int commonTotalSalary = 0;
105 // 部门经理的工资总和
106 private int managerTotalSalary = 0;
107
108 public void totalSalary() {
109 System.out.println("本公司的月工资总额是：" + (this.commonTotalSalary + this.managerTotalSalary));
110 }
111
112 // 访问普通员工，计算工资总额
113 public void visit(CommonEmployee commonEmployee) {
114 this.commonTotalSalary = this.commonTotalSalary + commonEmployee.getSalary() * COMMONEMPLOYEE_COEFFICIENT;
115 }
116
117 // 访问部门经理，计算工资总额
118 public void visit(Manager manager) {
119 this.managerTotalSalary = this.managerTotalSalary + manager.getSalary() * MANAGER_COEFFICIENT;
120 }
121
122 }
123
124 // 然后看 Client 类的修改：
125
126 package com.pattern.visitor.extend;
127
128 import java.util.ArrayList;
129 import java.util.List;
130
131 public class Client {
132
133 public static void main(String[] args) {
134 // 展示报表访问者
135 IShowVisitor showVisitor = new ShowVisitor();
136 // 汇总报表的访问者
137 ITotalVisitor totalVisitor = new TotalVisitor();
138
139 for(Employee emp : mockEmployee()){
140 // 接收展示报表访问者
141 emp.accept(showVisitor);
142 // 接收汇总表访问者
143 emp.accept(totalVisitor);
144 }
145 // 展示报表
146 showVisitor.report();
147 // 汇总报表
148 totalVisitor.totalSalary();
149 }
150
151 // 模拟出公司的人员情况，我们可以想象这个数据是通过持久层传递过来的
152 public static List<Employee> mockEmployee(){
153 List<Employee> empList = new ArrayList<Employee>();
154
155 // 产生张三这个员工
156 CommonEmployee zhangSan = new CommonEmployee();
157 zhangSan.setJob("编写Java程序，绝对的蓝领、苦工加搬运工");
158 zhangSan.setName("张三");
159 zhangSan.setSalary(1800);
160 zhangSan.setSex(Employee.MALE);
161 empList.add(zhangSan);
162
163 // 产生李四这个员工
164 CommonEmployee liSi = new CommonEmployee();
165 liSi.setJob("页面美工，审美素质太不流行了!");
166 liSi.setName("李四");
167 liSi.setSalary(1900);
168 liSi.setSex(Employee.FEMALE);
169 empList.add(liSi);
170
171 // 再产生一个经理
172 Manager wangWu = new Manager();
173 wangWu.setName("王五");
174 wangWu.setPerformance("基本上是负值，但是我会拍马屁呀！");
175 wangWu.setSalary(18750);
176 wangWu.setSex(Employee.MALE);
177 empList.add(wangWu);
178
179 return empList;
180 }
181 }
大家可以再深入的想象，一堆数据从几个角度来分析，那是什么？数据挖掘（Data Mining），数据的上切、下钻等等处理，大家有兴趣看可以翻看数据挖掘或者商业智能（BI）的书。
拦截器。你如果用过 Struts2，对拦截器绝对不会陌生，我们先想一下拦截器有什么作用，拦截器的核心作用是“围墙”作用，拦截器对被拦截的对象进行检查，符合规则的对象则开门放进去，继续执行下一个逻辑，不符合规则的则弹回（其实这也是过滤器的作用）；拦截器还有一个作用是修改数据，对于符合规则数据可以进行修改，以便继续后序的逻辑。具备了这两个功能，拦截器的雏形就有了，访问者模式就可以实现简单的拦截器角色，我们来看类图：
看着是不是和访问者模式的通用类图很类似？两个 accept 方法，其中参数为 List 类型的则实现了拦截器栈的作用，DynamicProxy 类使用了动态代理和反射模式。计划在混编模式中一起探讨。