今天来讲访问者模式，现在有这么一个需求，我要把公司中的所有人员信息都打印汇报上去，我们来看类图：
这个类图还是比较简单的，使用了一个模版方法模式，要把所有的信息都打印出来，我们先来看一下抽象类：
package com.example.xpeng.myapplication;
import android.util.Log;
/**
* Created by xpeng on 2018/6/18.
* 在一个单位里谁都是员工，甭管你是部门经理还是小兵
*/
public abstract class Employee {
public final static int MALE = 0;//0代表男性
public final static int FEMALE = 1;//1代表男性
//甭管是谁，都有名字
private String name;
//薪水
private int salary;
//性别
private int 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 final void report(){
String info = "姓名："+this.name+"\t";
info = info+"性别："+(this.sex == FEMALE?"女":"男"+"\t");
info = info+"薪水："+this.salary+"\t";
//获得员工的其他信息
info = info+this.getOtherInfo();
Log.e("xyz"," info ==== "+info);
}
//拼装员工的额其他信息
protected abstract String getOtherInfo();
}
再来看小兵的实现类：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 普通员工
*/
public class CommonEmployee extends Employee {
//工作内容
private String job;
public String getJob(){
return job;
}
public void setJob(String job){
this.job = job;
}
@Override
protected String getOtherInfo() {
return "工作："+this.job+"\t";
}
}
再来看领导层：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 经理级人物
*/
public class Manager extends Employee {
//这类人物的职责非常明确：业绩
private String performance;
public String getPerformance(){
return performance;
}
public void setPerformance(String performance){
this.performance = performance;
}
@Override
protected String getOtherInfo() {
return "业绩："+this.performance+"\t";
}
}
最后看一下最终实现类：
private void Client() {
IVisitor visitor = new Visitor();
for (Employee emp:mockEmployee()
) {
// emp.report();
emp.accept(new Visitor());
}
Log.e("xyz"," 本公司的月工资总额是： "+visitor);
}
//模拟出公司的人员情况，我们可以想象这个数据是通过持久层传递过来的
public static List<Employee> mockEmployee(){
List<Employee> employeeList = new ArrayList<Employee>();
//产生张三这个员工
CommonEmployee zhangsan = new CommonEmployee();
zhangsan.setJob("编写Java程序，绝对的蓝领");
zhangsan.setName("张三");
zhangsan.setSalary(18000);
zhangsan.setSex(Employee.MALE);
employeeList.add(zhangsan);
//产生李四这个员工
CommonEmployee lisi = new CommonEmployee();
lisi.setJob("页面美工");
lisi.setName("李四");
lisi.setSalary(15000);
lisi.setSex(Employee.FEMALE);
employeeList.add(lisi);
//产生一个经理
Manager wangwu = new Manager();
wangwu.setPerformance("拍马屁");
wangwu.setName("王五");
wangwu.setSalary(38000);
wangwu.setSex(Employee.MALE);
employeeList.add(lisi);
return employeeList;
}嗯，结果出来了，也非常正确。那么问题来了：
1.大老板就看部门经理的报表，小兵的根本不看
2.多个大老板关注的点也不一样，销售的，会计的，技术的等等
综合成一句话，这个报表会有修改：数据的修改以及报表的展现修改，按照开闭原则，项目分析的时候已经考虑到这些可能引起变更的隐私。我们来想想，每个普通员工类和经理类都有一个方法report,那是否可以把这个方法提取到另一个类中来实现呢？原有的示意图如下：
这两个类都有一个相同的方法report()，但是要实现的内容不相同，而且还有可能会发生变动，那我们就让其他类来实现这个report方法，好，看示意图的变更：
两个类的report方法都不需要了，只有Visitor类来实现了report的方法，这个猛一看还真有点委托的意味，我们实现下来你就知道这和委托有非常大的差距，我们来看类图：
在抽象类Employee中增加了accept方法，这个方法是定义我这个类可以允许被谁来访问，也就定义一类访问者，在具体的实现类中调用访问者的方法。我们先看访问者IVisitor程序：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 访问者，我要去访问人家的数据了
*/
public interface IVisitor {
//首先定义我可以访问普通员工
public void visit(CommonEmployee commonEmployee);
//其次定义，我还可以访问部门经理
public void visit(Manager manager);
//统计所有员工工资组合
public int getTotalSalary();
}
如下是访问者的实现类：
package com.example.xpeng.myapplication;
import android.util.Log;
/**
* Created by xpeng on 2018/6/18.
*/
public class Visitor implements IVisitor {
//访问普通员工，打印出报表
@Override
public void visit(CommonEmployee commonEmployee) {
Log.e("xyz"," commonEmployee === "+this.getCommonEmployee(commonEmployee));
}
@Override
public void visit(Manager manager) {
Log.e("xyz"," manager === "+this.getManagerInfo(manager));
}
//组装出基本信息
private String getBasicInfo(Employee employee){
String info = "姓名："+employee.getName()+"\t";
info = info+"性别："+(employee.getSex() == Employee.FEMALE?"女":"男"+"\t");
info = info+"薪水："+employee.getSalary()+"\t";
return info;
}
//组装出部门经理的信息
private String getManagerInfo(Manager manager){
String basicInfo = this.getBasicInfo(manager);
String otherInfo = "业绩："+manager.getPerformance()+"\t";
return basicInfo+otherInfo;
}
//组装出普通员工的信息
private String getCommonEmployee(CommonEmployee commonEmployee){
String basicInfo = this.getBasicInfo(commonEmployee);
String otherInfo = "工作："+commonEmployee.getJob()+"\t";
return basicInfo+otherInfo;
}
}
在具体实现类中，定义了两个私有方法，作用就是产生需要打印的数据和格式，然后在访问者访问相关的对象时，产生这个报表。继续看Employee抽象类：
package com.example.xpeng.myapplication;
import android.util.Log;
/**
* Created by xpeng on 2018/6/18.
* 在一个单位里谁都是员工，甭管你是部门经理还是小兵
*/
public abstract class Employee {
public final static int MALE = 0;//0代表男性
public final static int FEMALE = 1;//1代表男性
//甭管是谁，都有名字
private String name;
//薪水
private int salary;
//性别
private int 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 final void report(){
// String info = "姓名："+this.name+"\t";
// info = info+"性别："+(this.sex == FEMALE?"女":"男"+"\t");
// info = info+"薪水："+this.salary+"\t";
// //获得员工的其他信息
// info = info+this.getOtherInfo();
// Log.e("xyz"," info ==== "+info);
//
//
// }
// //拼装员工的额其他信息
// protected abstract String getOtherInfo();
//我允许一个访问者过来访问
public abstract void accept(IVisitor visitor);
}
删除了report方法，增加了accept方法，需要实现类来实现，继续看实现类:
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 普通员工
*/
public class CommonEmployee extends Employee {
//工作内容
private String job;
public String getJob(){
return job;
}
public void setJob(String job){
this.job = job;
}
@Override
public void accept(IVisitor visitor) {
visitor.visit(this);
}
// @Override
// protected String getOtherInfo() {
// return "工作："+this.job+"\t";
// }
}
上面是普通员工类，这个实现类的accpt方法很简单，这个类就把自身传递过去，也就是访问者访问本身这个对象。再看Manager类：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 经理级人物
*/
public class Manager extends Employee {
//这类人物的职责非常明确：业绩
private String performance;
public String getPerformance(){
return performance;
}
public void setPerformance(String performance){
this.performance = performance;
}
@Override
public void accept(IVisitor visitor) {
visitor.visit(this);
}
// @Override
// protected String getOtherInfo() {
// return "业绩："+this.performance+"\t";
// }
}
所有业务定义都已经完成，我们来看看怎么调用这个逻辑：
private void ClientChange() {
//展示报表访问
IShowVisitor showVisitor = new ShowVisitor();
//汇总报表的访问者
ITotalVisitor totalVisitor = new TotalVisitor();
for (Employee emp:mockEmployee()
) {
// emp.report();
emp.accept(new Visitor())；
}
}
//模拟出公司的人员情况，我们可以想象这个数据是通过持久层传递过来的
public static List<Employee> mockEmployee(){
List<Employee> employeeList = new ArrayList<Employee>();
//产生张三这个员工
CommonEmployee zhangsan = new CommonEmployee();
zhangsan.setJob("编写Java程序，绝对的蓝领");
zhangsan.setName("张三");
zhangsan.setSalary(18000);
zhangsan.setSex(Employee.MALE);
employeeList.add(zhangsan);
//产生李四这个员工
CommonEmployee lisi = new CommonEmployee();
lisi.setJob("页面美工");
lisi.setName("李四");
lisi.setSalary(15000);
lisi.setSex(Employee.FEMALE);
employeeList.add(lisi);
//产生一个经理
Manager wangwu = new Manager();
wangwu.setPerformance("拍马屁");
wangwu.setName("王五");
wangwu.setSalary(38000);
wangwu.setSex(Employee.MALE);
employeeList.add(lisi);
return employeeList;
}改动非常少，运行结果一样。
那回头我们来看看这个程序是怎么实现的：
1.首先通过循环遍历所有元素
2.其次，每个员工都定义了一个访问者
3.在其次，员工对象把自己作为一个参数调用访问者visit方法；
4.然后，访问者调用自己内部的计算逻辑，计算出相应的数据和表格元素
5.最后，访问者打印出报表和数据
以上讲的就是访问者模式，这个模式的通用类图如下：
看到这个通用类图，大家可能要犯迷糊，这里怎么有一个ObjectStruture这个类呢？我们上面的例子中不是定义了一个list了吗？这就是一个ObjectStruture，我们来砍这几个角色的职责:
抽象访问者（Visitor）：抽象类或者接口，声明访问者可以访问哪些元素，具体到程序中就是visit方法的参数定义哪些对象是可以被访问的；
具体访问者（ConcreateVisitor）：访问者访问到一个类后该怎么干。要做什么事情；
抽象元素（Element）：接口或者抽象类，声明接受哪一类型的访问者访问，程序上是通过accept方法中的参数来定义；
具体元素（ConcreateElement）：实现accept方法，通常visitor.visit(this),基本上都形成了一个套路了
结构对象（ObjectStruture）:容纳多个不同类、不同接口的容器，比如List、Set、Map等，在项目中，一般很少抽象出这个角色
接下来我们来考虑一下，访问者可以用在什么地方。在这种地方你一定要考虑到使用访问者模式；业务规则要求遍历多个不同的对象。这本身也是访问者模式出发点，迭代器模式只能访问同类或同接口的数据，而访问者模式是对迭代器模式的扩充，可以遍历不同的对象，然后执行不同的操作，也就是针对访问的对象不同，执行不同的操作。访问者模式还有一个用途，就是充当拦截器（Interceptor）角色，这个我们后面讲。
访问者模式有哪些优点呢？首先符合单一职责原则，具体元素角色也就是Employee这个类的两个负责数据的加载，而Visitor类则负责报表的展现，两个不同职责非常明确的分离开来。其次，由于职责分开，继续增加对数据的操作是非常快捷的。最后，数据汇总。
访问者模式的缺点也很明显，访问者要访问一个类就必然要求这个类公布一些方法，也就是说访问者关注了其他类的内部细节，这是迪米特法则所不建议的；还有一个缺点，具体角色的增加删除修改都是比较痛苦的，就上面的例子，你想想，你要是想增加一个成员变量，比如年龄age,Visitor就需要修改，如果Visitor是一个还好，多个呢？访问者模式是有缺点的，但是掩盖不了它的光芒，访问者模式结合其他模式比如模版方法模式、状态模式、解释器模式、代理模式等就会非常强大，这个以后再讲。
访问者模式是会经常用到的模式，这里提出三个扩展的功能大家参考：
1.统计功能
好，我们来统计一下公司人员的工资，先看类图：
就是接口上增加了一个getTotalSalary方法，在Visitor实现类中实现该方法，我们先看接口：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 访问者，我要去访问人家的数据了
*/
public interface IVisitor {
//首先定义我可以访问普通员工
public void visit(CommonEmployee commonEmployee);
//其次定义，我还可以访问部门经理
public void visit(Manager manager);
//统计所有员工工资组合
public int getTotalSalary();
}
就多了一个getTotalSalary方法，我们再来看实现类：
package com.example.xpeng.myapplication;
import android.util.Log;
/**
* Created by xpeng on 2018/6/18.
*/
public class Visitor implements IVisitor {
//部门经理的工资系数是5
private final static int MANAGER_COEFFICIENT = 5;
//员工的工资系数是2
private final static int COMMONEMPLOYEE_COEFFICIENT = 2;
//普通员工的工资总和
private int commonTotalSalary = 0;
//部门经理的工资总和
private int managerTotalSalary = 0;
//访问普通员工，打印出报表
@Override
public void visit(CommonEmployee commonEmployee) {
Log.e("xyz"," commonEmployee === "+this.getCommonEmployee(commonEmployee));
}
@Override
public void visit(Manager manager) {
Log.e("xyz"," manager === "+this.getManagerInfo(manager));
}
@Override
public int getTotalSalary() {
return this.commonTotalSalary+this.managerTotalSalary;
}
//组装出基本信息
private String getBasicInfo(Employee employee){
String info = "姓名："+employee.getName()+"\t";
info = info+"性别："+(employee.getSex() == Employee.FEMALE?"女":"男"+"\t");
info = info+"薪水："+employee.getSalary()+"\t";
return info;
}
//组装出部门经理的信息
private String getManagerInfo(Manager manager){
String basicInfo = this.getBasicInfo(manager);
String otherInfo = "业绩："+manager.getPerformance()+"\t";
return basicInfo+otherInfo;
}
//组装出普通员工的信息
private String getCommonEmployee(CommonEmployee commonEmployee){
String basicInfo = this.getBasicInfo(commonEmployee);
String otherInfo = "工作："+commonEmployee.getJob()+"\t";
return basicInfo+otherInfo;
}
//计算部门经理的工资总和
private void calManagerSalary(int salary){
this.managerTotalSalary = this.managerTotalSalary+salary*MANAGER_COEFFICIENT;
}
//计算普通员工的工资总和
public int getTotalSalary(){
}
}
程序比较长，但是还是比较简单的，分别计算普通员工和经理级员工，然后加起来。注意我们在实现时已经考虑员工工资和经理工资的系数不同。
我们再来看ClientChange类的调用：
private void ClientChange() {
IVisitor visitor = new Visitor();
for (Employee emp:mockEmployee()
) {
// emp.report();
emp.accept(visitor);
}
}2.多个访问者
在实际项目中，一个对象，多个访问者的情况非常多。
从程序上看，一个类就有多个不同的访问者，那我们修改一下类图：
类图看着挺恐怖的，其实也没啥复杂的，多了两个接口和两个实现类。分别负责展示表和汇总表的业务处理，我们先看IVisitor接口程序：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 访问者，我要去访问人家的数据了
*/
public interface IVisitor {
//首先定义我可以访问普通员工
public void visit(CommonEmployee commonEmployee);
//其次定义，我还可以访问部门经理
public void visit(Manager manager);
//统计所有员工工资组合
public int getTotalSalary();
}
该接口定义其下的实现类能够访问哪些类，子接口定义了具体访问者的任务和责任，先看ITotalVisitor接口：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 负责统计报表的产生
*/
public interface ITotalVisitor extends IVisitor {
//统计所有员工工资总和
public void totalSalary();
}
就一句话，非常简单，我们再来看展示表：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/18.
* 负责展示报表的产生
*/
public interface IShowVisitor extends IVisitor {
//展示报表
public void report();
}
也是一句话，我们展示表访问者的实现类：
package com.example.xpeng.myapplication;
import android.util.Log;
/**
* Created by xpeng on 2018/6/18.
* 展示报表，该访问者的工作就是看到什么数据展示什么数据
*/
public class ShowVisitor implements IShowVisitor {
private String info = "";
@Override
public void visit(CommonEmployee commonEmployee) {
this.info = this.info+this.getBasicInfo(commonEmployee)+"工作："+commonEmployee.getJob()+"\t\n";
}
@Override
public void visit(Manager manager) {
this.info = this.info+this.getBasicInfo(manager)+"业绩："+manager.getPerformance()+"\t\n";
}
@Override
public int getTotalSalary() {
return 0;
}
//打印出报表
@Override
public void report() {
Log.e("xyz"," this.info === "+this.info);
}
//组装出基本信息
private String getBasicInfo(Employee employee){
String info = "姓名："+employee.getName()+"\t";
info = info +"性别:"+(employee.getSex()== Employee.FEMALE?"女":"男")+"\t";
info = info + "薪水："+employee.getSalary()+"\t";
return info;
}
}
下面是汇总表访问者：
package com.example.xpeng.myapplication;
import android.util.Log;
/**
* Created by xpeng on 2018/6/18.
* 汇总表，该访问者起汇总作用，把容器中的数据一个一个遍历，然后汇总
*/
public class TotalVisitor implements ITotalVisitor {
//部门经理的工资系数是5
private final static int MANAGER_COEFFICIENT = 5;
//员工的工资系数是2
private final static int COMMONEMPLOYEE_COEFFICIENT = 2;
//普通员工的工资总和
private int commonTotalSalary = 0;
//部门经理的工资总和
private int managerTotalSalary = 0;
//访问普通员工，计算工资总额
@Override
public void visit(CommonEmployee commonEmployee) {
this.commonTotalSalary = this.commonTotalSalary+commonEmployee.getSalary()*COMMONEMPLOYEE_COEFFICIENT;
}
//访问部门经理，计算工资总额
@Override
public void visit(Manager manager) {
this.managerTotalSalary = this.managerTotalSalary+manager.getSalary()*MANAGER_COEFFICIENT;
}
@Override
public int getTotalSalary() {
return 0;
}
@Override
public void totalSalary() {
Log.e("xyz"," 本公司的月工资总额是 "+(this.commonTotalSalary+this.managerTotalSalary));
}
}
最后看ClientChange类的修改：
private void ClientChange() {
//展示报表访问
IShowVisitor showVisitor = new ShowVisitor();
//汇总报表的访问者
ITotalVisitor totalVisitor = new TotalVisitor();
for (Employee emp:mockEmployee()
) {
// emp.report();
emp.accept(showVisitor);//接受展示报表访问者
emp.accept(totalVisitor);//接受汇总表访问者
}
//展示报表
showVisitor.report();
//汇总报表
totalVisitor.totalSalary();
}大家可以再深入的想象，一堆数据从几个角度来分析，那是什么？数据挖掘，数据的上切、下钻等等处理
3.拦截器
拦截器只要两个作用，拦截器对被拦截的对象进行检查，符合规则的对象则看门放进去，继续执行下一个逻辑，不符合规则的则弹回；拦截器可以修改数据，对于符合规则数据可以进行修改，以便继续后续的逻辑。具备这两个功能，拦截器的雏形就有了，访问者模式就可以实现简单的拦截器角色，我们来看类图：
看着是不是和访问者模式的通用类图很相似？两个accpt方法，其中参数为List类型的则实现了拦截器的作用，DynamicProxy类使用了动态代理和反射模式。烂机器实现起来也不麻烦，今天就不实现了。
扫一扫
259
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
