本文深入解析访问者模式，包括其定义、UML模型、代码实现、应用场景及优缺点。通过实例展示如何使用访问者模式处理对象结构中的元素，实现灵活且可扩展的操作。
细说访问者模式
提示：
博主：章飞 _906285288的博客
博客地址：http://blog.youkuaiyun.com/qq_29924041
细说访问者模式
访问者模式: 首先明确下什么叫访问者，举个例子，你考研的时候，复习了一大堆资料，但是真正到最后的时候，又要从这些资料中总结一些重点出来吧，那可不可以认为你在这个中就是访问者呐，你不可能改变本来复习资料中固定下来的相关知识点吧，但是你又要去精炼总结这些知识点。你就是访问者。再举个例子。你公司里面肯定有所有职员的数据统计表吧。但是cto查看的是技术相关人员信息，cfo查看的肯定是财务人员递交的相关报表信息。ceo肯定是该看的都会看。但是数据信息的采集方式都是不变的啊。那在这个过程中你的老板们是不是就是访问者？？
定义
访问者模式（Visitor Pattern）是GoF提出的23种设计模式中的一种，属于行为模式。
定义（源于GoF《Design Pattern》）：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。
UML模型
1.Visitor 抽象访问者角色，为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色，这样访问者就可以通过该元素角色的特定接口直接访问它。
2.ConcreteVisitor.具体访问者角色，实现Visitor声明的接口。
3.Element 定义一个接受访问操作(accept())，它以一个访问者(Visitor)作为参数。
4.ConcreteElement 具体元素，实现了抽象元素(Element)所定义的接受操作接口。
5.ObjectStructure 结构对象角色，这是使用访问者模式必备的角色。它具备以下特性：能枚举它的元素；可以提供一个高层接口以允许访问者访问它的元素；如有需要，可以设计成一个复合对象或者一个聚集（如一个列表或无序集合）。
基于UML的代码
package src.com.zzf.designpattern.visitorpattern.uml;
public abstract class Element {
/**
* 定义业务逻辑
*/
public abstract void doSomething();
/**
* 允许谁来访问,接受谁来访问
* @param e
*/
public abstract void accept(IVisitor e);
}
package src.com.zzf.designpattern.visitorpattern.uml;
public interface IVisitor {
/**
* 访问者能够访问的具体对象
* @param concreteElement1
*/
void visit(ConcreteElement1 concreteElement1);
/**
* 访问者能够访问的具体对象
* @param concreteElement2
*/
void visit(ConcreteElement2 concreteElement2);
}
package src.com.zzf.designpattern.visitorpattern.uml;
public class ConcreteElement1 extends Element{
@Override
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("ConcreteElement1 doSomething");
}
@Override
public void accept(IVisitor e) {
// TODO Auto-generated method stub
e.visit(this);
}
}
package src.com.zzf.designpattern.visitorpattern.uml;
public class ConcreteElement2 extends Element{
@Override
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("ConcreteElement2 doSomething");
}
@Override
public void accept(IVisitor e) {
// TODO Auto-generated method stub
e.visit(this);
}
}
package src.com.zzf.designpattern.visitorpattern.uml;
import java.util.Random;
public class ObjectStruture {
//创建元素
public static Element createElement() {
Random rand = new Random();
if (rand.nextInt(100) > 50) {
return new ConcreteElement1();
} else {
return new ConcreteElement2();
}
}
}
package src.com.zzf.designpattern.visitorpattern.uml;
public class Visitor implements IVisitor{
/**
* 具体访问的对象1
*/
@Override
public void visit(ConcreteElement1 concreteElement1) {
// TODO Auto-generated method stub
concreteElement1.doSomething();
}
/**
* 具体访问的对象2
*/
@Override
public void visit(ConcreteElement2 concreteElement2) {
// TODO Auto-generated method stub
concreteElement2.doSomething();
}
}
package src.com.zzf.designpattern.visitorpattern.uml;
public class Client {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
Element element = ObjectStruture.createElement();
element.accept(new Visitor());
}
}
}
场景一
场景
如设计模式之禅中的案例一样，公司员工分成普通员工和领导，普通员工对于老板来说，其只关心的是工作内容，而另一部分领导，其对于老板来说关心的是业绩，业绩分类情况。老板作为一个访问者，会去访问具体的员工和部分领导。
代码
package src.com.zzf.designpattern.visitorpattern.demo1;
public abstract class Employee {
public static final int MALE = 0;
public static final int FEMALE = 1;
String name = "";
int salary = 0;
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();
// System.out.println(info);
// }
// protected abstract String getOtherInfo();
public abstract void accept(IVisitor visitor);
}
package src.com.zzf.designpattern.visitorpattern.demo1;
/**
* 普通员工
* @author zhouzhangfei
*
*/
public class CommonEmployee extends Employee{
private String job;
public void setJob(String job) {
this.job = job;
}
public String getJob() {
return job;
}
// @Override
// protected String getOtherInfo() {
// // TODO Auto-generated method stub
// return "工作:"+this.job+"\t";
// }
@Override
public void accept(IVisitor visitor) {
// TODO Auto-generated method stub
visitor.visit(this);
}
}
package src.com.zzf.designpattern.visitorpattern.demo1;
/**
* 管理类员工
* @author zhouzhangfei
*
*/
public class Manager extends Employee{
private String performance;
public String getPerforence() {
return performance;
}
public void setPerforence(String performance) {
this.performance = performance;
}
// @Override
// protected String getOtherInfo() {
// // TODO Auto-generated method stub
// return "业绩："+ this.performance + "\t";
// }
@Override
public void accept(IVisitor visitor) {
// TODO Auto-generated method stub
visitor.visit(this);
}
}
package src.com.zzf.designpattern.visitorpattern.demo1;
/**
* 抽象访问者
* @author zhouzhangfei
*
*/
public interface IVisitor {
public void visit(CommonEmployee commonEmployee);
public void visit(Manager mManager);
}
具体的访问者
package src.com.zzf.designpattern.visitorpattern.demo1;
public class Visitor implements IVisitor{
public void visit(CommonEmployee commonEmployee) {
// TODO Auto-generated method stub
System.out.println(this.getCommonEmployee(commonEmployee));
}
public void visit(Manager mManager) {
// TODO Auto-generated method stub
System.out.println(this.getManagerInfo(mManager));
}
//组装出基本信息
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.getPerforence() + "\t";
return basicInfo + otherInfo;
}
//组装出普通员工信息
private String getCommonEmployee(CommonEmployee commonEmployee){
String basicInfo = this.getBasicInfo(commonEmployee);
String otherInfo = "工作："+commonEmployee.getJob()+"\t";
return basicInfo + otherInfo;
}
}
测试代码
package src.com.zzf.designpattern.visitorpattern.demo1;
import java.util.ArrayList;
import java.util.List;
/**
* 抽象访问者（Visitor）：抽象类或者接口，声明访问者可以访问哪些元素，具体到程序中就是visit
方法的参数定义哪些对象是可以被访问的；
具体访问者（ConcreteVisitor）:访问者访问到一个类后该怎么干(哎，这个别读歪了)，要做什么事
情；
抽象元素（Element）：接口或者抽象类，声明接受那一类型的访问者访问，程序上是通过accept 方法
中的参数来定义；
具体元素：（ConcreteElement）:实现accept 方法，通常是visitor.visit(this)，基本上都形成了一
个套路了；
结构对象(ObjectStruture):容纳多个不同类、不同接口的容器，比如List、Set、Map 等，在项目中，
一般很少抽象出来这个角色；
* @author Administrator
* 访问者模式三部曲：
* 定义一个接口IVisitor ---->visit
* 实现IVisitor的Visitor
* 定义一个抽象类：Element --->accept
* 实现element的ConcreteElement
*
*/
public class Client {
public static void main(String[] args) {
// for(Employee emp:mockEmployee()){
// emp.report();
// }
/**
* 根据不同人的喜好来产生不同的报表格式，有助于拓展
*/
for(Employee emp:mockEmployee()){
emp.accept(new Visitor());
}
}
// 模拟出公司的人员情况，我们可以想象这个数据室通过持久层传递过来的
public static List<Employee> mockEmployee() {
List<Employee> empList = new ArrayList<Employee>();
// 产生张三这个员工
CommonEmployee zhangSan = new CommonEmployee();
zhangSan.setJob("编写Java程序，绝对的蓝领、苦工加搬运工");
zhangSan.setName("张三");
zhangSan.setSalary(1800);
zhangSan.setSex(Employee.MALE);
empList.add(zhangSan);
// 产生李四这个员工
CommonEmployee liSi = new CommonEmployee();
liSi.setJob("页面美工，审美素质太不流行了！");
liSi.setName("李四");
liSi.setSalary(1900);
liSi.setSex(Employee.FEMALE);
empList.add(liSi);
// 再产生一个经理
Manager wangWu = new Manager();
wangWu.setName("王五");
wangWu.setPerforence("基本上是负值，但是我会拍马屁呀");
wangWu.setSalary(18750);
wangWu.setSex(Employee.MALE);
empList.add(wangWu);
return empList;
}
}
访问者模式扩展
多个访问者
此案例是同样是基于上述案例进行拓展，来源于设计模式之禅
package src.com.zzf.designpattern.visitorpattern.demo1;
public abstract class Employee {
public static final int MALE = 0;
public static final int FEMALE = 1;
String name = "";
int salary = 0;
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();
// System.out.println(info);
// }
// protected abstract String getOtherInfo();
public abstract void accept(IVisitor visitor);
}
package src.com.zzf.designpattern.visitorpattern.demo1;
/**
* 抽象访问者
* @author zhouzhangfei
*
*/
public interface IVisitor {
public void visit(CommonEmployee commonEmployee);
public void visit(Manager mManager);
}
package src.com.zzf.designpattern.visitorpattern.demo1;
/**
* 普通员工
* @author zhouzhangfei
*
*/
public class CommonEmployee extends Employee{
private String job;
public void setJob(String job) {
this.job = job;
}
public String getJob() {
return job;
}
// @Override
// protected String getOtherInfo() {
// // TODO Auto-generated method stub
// return "工作:"+this.job+"\t";
// }
@Override
public void accept(IVisitor visitor) {
// TODO Auto-generated method stub
visitor.visit(this);
}
}
package src.com.zzf.designpattern.visitorpattern.demo1;
/**
* 管理类员工
* @author zhouzhangfei
*
*/
public class Manager extends Employee{
private String performance;
public String getPerforence() {
return performance;
}
public void setPerforence(String performance) {
this.performance = performance;
}
// @Override
// protected String getOtherInfo() {
// // TODO Auto-generated method stub
// return "业绩："+ this.performance + "\t";
// }
@Override
public void accept(IVisitor visitor) {
// TODO Auto-generated method stub
visitor.visit(this);
}
}
package src.com.zzf.designpattern.visitorpattern.demo2;
import src.com.zzf.designpattern.visitorpattern.demo1.IVisitor;
public interface ITotalVisitor extends IVisitor{
//统计所有员工工资总和
public void totalSalary();
}
package src.com.zzf.designpattern.visitorpattern.demo2;
import src.com.zzf.designpattern.visitorpattern.demo1.IVisitor;
public interface IShowVisitor extends IVisitor{
//生成报表
void report();
}
package src.com.zzf.designpattern.visitorpattern.demo2;
import src.com.zzf.designpattern.visitorpattern.demo1.CommonEmployee;
import src.com.zzf.designpattern.visitorpattern.demo1.Employee;
import src.com.zzf.designpattern.visitorpattern.demo1.IVisitor;
import src.com.zzf.designpattern.visitorpattern.demo1.Manager;
public class ShowVisitor implements IVisitor{
private String info = "";
//
public void report() {
System.out.println(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;
}
@Override
public void visit(CommonEmployee commonEmployee) {
// TODO Auto-generated method stub
this.info = this.info + this.getBasicInfo(commonEmployee)
+ "工作"+commonEmployee.getJob()+"\t\n";
}
@Override
public void visit(Manager mManager) {
// TODO Auto-generated method stub
this.info = this.info + this.getBasicInfo(mManager) + "???业绩" + mManager.getPerforence() + "\t\n";
}
}
package src.com.zzf.designpattern.visitorpattern.demo2;
import src.com.zzf.designpattern.visitorpattern.demo1.CommonEmployee;
import src.com.zzf.designpattern.visitorpattern.demo1.Manager;
public class TotalVisitor implements ITotalVisitor{
//打印出报表
private final static int MANAGER_COEFFICIENT = 5; //经理的系数
private final static int COMMONEMPLOYEE_COEFFICIENT = 2; //
//普通员工总和
private int commonTotalSalary = 0;
//经理员工总和
private int managerTotalSalary =0;
public void totalSalary() {
System.out.println("总额:" + (this.commonTotalSalary +this.managerTotalSalary));
}
//
public void visit(CommonEmployee commonEmployee) {
this.commonTotalSalary = this.commonTotalSalary + commonEmployee.getSalary();
}
//
public void visit(Manager manager) {
this.managerTotalSalary = this.managerTotalSalary + manager.getSalary();
}
}
package src.com.zzf.designpattern.visitorpattern.demo2;
import java.util.ArrayList;
import java.util.List;
import src.com.zzf.designpattern.visitorpattern.demo1.CommonEmployee;
import src.com.zzf.designpattern.visitorpattern.demo1.Manager;
import src.com.zzf.designpattern.visitorpattern.demo1.*;
public class Client {
public static void main(String[] args) {
ShowVisitor showVisitor = new ShowVisitor();
ITotalVisitor totalVisitor = new TotalVisitor();
for(Employee emp:mockEmployee()){
emp.accept(totalVisitor);
emp.accept(showVisitor);
}
showVisitor.report();
totalVisitor.totalSalary();
}
// 模拟出公司的人员情况，我们可以想象这个数据室通过持久层传递过来的
public static List<Employee> mockEmployee() {
List<Employee> empList = new ArrayList<Employee>();
// 产生张三这个员工
CommonEmployee zhangSan = new CommonEmployee();
zhangSan.setJob("编写Java程序，绝对的蓝领、苦工加搬运工");
zhangSan.setName("张三");
zhangSan.setSalary(1800);
zhangSan.setSex(Employee.MALE);
empList.add(zhangSan);
// 产生李四这个员工
CommonEmployee liSi = new CommonEmployee();
liSi.setJob("页面美工，审美素质太不流行了！");
liSi.setName("李四");
liSi.setSalary(1900);
liSi.setSex(Employee.FEMALE);
empList.add(liSi);
// 再产生一个经理
Manager wangWu = new Manager();
wangWu.setName("王五");
wangWu.setPerforence("基本上是负值，但是我会拍马屁呀");
wangWu.setSalary(18750);
wangWu.setSex(Employee.MALE);
empList.add(wangWu);
return empList;
}
}
访问者模式应用和注意事项
优点
1：符合单一设计原则，即一个类其对应了一个主要功能
2：优秀的扩展性，对于被访问者其实只要拓展Element接口即可，对于访问者其实只要拓展IVisitor接口即可
3：灵活性也很高，可以对于单独的element进行输出，同样也可以对于整个Element元素进行统计，这就是访问者模式的好处
缺点
1：对于每个具体的元素其实都公布了细节
2：对于元素内部成员变量的修改，这个时候很有可能是要进行访问者内部细节的修改的
3：违反了依赖倒置的原则，即理论上来说访问者不应该去关心具体element元素内部的细节，但是在访问者模式中，不可避免的是需要去依赖具体元素的
欢迎继续访问，我的博客
扫一扫
846
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
