#1.定义
封装一些作用于某种数据结构中的各元素的操作,它可以在不改变数据结构的前提下作用于这些元素的新的操作。
#2.类图
##角色介绍
- Visitor 抽象访问者:抽象类或接口,声明访问者可以访问哪些元素,具体到程序中就是visit方法的参数定义哪些对象是可以访问的
- ConcreteVisitor 具体访问者:它影响到访问者访问一个类后该怎么干,要做什么事情
- Element 抽象元素:接口或抽象类,声明接受哪一类访问者访问,程序上是通过accept方法中的参数来定义的
- ConcreteElement 具体元素:实现accept方法,通常是visitor.visit(this),基本上已经是一种模式了
- ObjectStruture 结构对象:元素生产者,一般容纳在多个不同类、不同接口的容器,如List、Set、Map等,在项目中,一般很少抽象出这个角色
#3.通用源码
Visitor抽象访问者
public interface IVisitor {
//可以访问哪些对象
public void visit(ConcreteElement1 el1);
public void visit(ConcreteElement2 el2);
}
具体访问者
public class Visitor implements IVisitor {
//访问el1元素
@Override
public void visit(ConcreteElement1 el1) {
el1.doSomething();
}
//访问el2元素
@Override
public void visit(ConcreteElement2 el2) {
el2.doSomething();
}
}
抽象元素
public abstract class Element {
//定义业务逻辑
public abstract void doSomething();
//允许谁来访问
public abstract void accept(IVisitor visitor);
}
具体元素1
public class ConcreteElement1 extends Element {
//完善业务逻辑
public void doSomething() {
//业务处理
}
public void accept(IVisitor visitor) {
visitor.visit(this);
}
}
具体元素2
public class ConcreteElement2 extends Element {
//完善业务逻辑
public void doSomething() {
//业务处理
}
public void accept(IVisitor visitor) {
visitor.visit(this);
}
}
结构对象
public class ObjectStruture {
//对象生成器,这里通过一个工厂方法模式模拟
public static Element createElement() {
Random random = new Random();
if(random.nextInt(100)>50) {
return new ConcreteElement1();
}else {
return new ConcreteElement2();
}
}
}
场景类
public class Client {
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
//获得元素对象
Element el = ObjectStruture.createElement();
//接收访问者访问
el.accept(new Visitor());
}
}
}
#4.Demo
看了上面的通用代码,可能并不理解具体的意思,我们来看一个简单的demo,现在有一个公司,公司有普通员工,管理层,现在领导想要查看所有人的报表信息
抽象员工类,即抽象元素
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 Employee() {};
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) {
Salary = salary;
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
public abstract void accept(IVisitor visitor);
}
普通员工,即具体元素
public class CommonEmployee extends Employee {
private String job; //工作
public CommonEmployee() {};
public CommonEmployee(String name,int salary,int sex,String job) {
super(name,salary,sex);
this.job = job;
}
protected String getOtherInfo() {
return "工作:"+ this.job + "\t";
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
//允许访问者访问
@Override
public void accept(IVisitor visitor) {
visitor.visit(this);
}
}
管理层,即具体元素
public class Manager extends Employee {
private String performance; //业绩
public Manager() {};
public Manager(String name,int salary ,int sex,String performance) {
super(name,salary,sex);
this.performance = performance;
}
protected String getOtherInfo() {
return "工作:"+ this.performance + "\t";
}
public String getPerformance() {
return performance;
}
public void setPerformance(String performance) {
this.performance = performance;
}
//允许的访问者
@Override
public void accept(IVisitor visitor) {
visitor.visit(this);
}
}
抽象访问者
public interface IVisitor {
public void visit(CommonEmployee commonEmployee);
public void visit(Manager manager);
}
具体访问者
public class Visitor implements IVisitor {
//访问普通员工,打印普通员工报表
@Override
public void visit(CommonEmployee commonEmployee) {
System.out.println(this.getCommonEmployee(commonEmployee));
}
//访问部门经理,打印部门经理报表
@Override
public void visit(Manager manager) {
System.out.println(this.getMangerInfo(manager));
}
//组装基本信息
private String getBasicInfo(Employee employee) {
StringBuffer info = new StringBuffer();
info.append("姓名:"+employee.getName()+"\t");
info.append("性别:"+(employee.getSex()==Employee.FEMALE?"女":"男")+"\t");
info.append("薪资:"+employee.getSalary()+"\t");
return info.toString();
}
//组装部门经理信息
private String getMangerInfo(Manager manager) {
StringBuffer info = new StringBuffer();
info.append(this.getBasicInfo(manager));
info.append("业绩:"+manager.getPerformance());
return info.toString();
}
//组装普通员工的信息
private String getCommonEmployee(CommonEmployee commonEmployee) {
StringBuffer info = new StringBuffer();
info.append(this.getBasicInfo(commonEmployee));
info.append("工作:"+commonEmployee.getJob());
return info.toString();
}
}
场景类
public class Client {
public static void main(String[] args) {
for (Employee emp : mockEmployee()) {
//emp.report();
emp.accept(new Visitor());
}
}
//模拟出公司的人员情况
public static List<Employee> mockEmployee(){
List<Employee> list = new ArrayList<Employee>();
CommonEmployee zhangsan = new CommonEmployee();
zhangsan.setName("张三");
zhangsan.setSalary(8000);
zhangsan.setSex(Employee.MALE);
zhangsan.setJob("java程序员");
list.add(zhangsan);
CommonEmployee lisi = new CommonEmployee();
lisi.setName("李四");
lisi.setSalary(7500);
lisi.setSex(Employee.MALE);
lisi.setJob("前端");
list.add(lisi);
CommonEmployee laowang = new CommonEmployee();
laowang.setName("老王");
laowang.setSalary(7000);
laowang.setSex(Employee.MALE);
laowang.setJob("测试");
list.add(laowang);
Manager zhaoliu = new Manager("赵六",12000,Employee.MALE,"项目经理");
list.add(zhaoliu);
return list;
}
}
运行结果
为什么没有结构角色,因为元素我们在场景类里产生了。
#5.应用场景
- 一个对象结构包含很多类对象,它们有不同的接口,而你想对这些对象实施一些依赖于其具体类的操作,也就是说迭代器模式已经不能胜任的场景
- 需要对一个对象结构中的对象进行很多不同并且不相关的操作,而你想避免让这些操作“污染”这些对象的类
- 业务规则要求遍历多个不同的对象。迭代器只能访问同类或同接口的数据。访问者模式还可以充当拦截器
#6.优缺点
###优点:
- 符合单一职责原则
- 优秀的扩展性
- 灵活性非常高
###缺点 - 具体元素对访问者公布细节
- 具体原色变更比较困难
- 违背了依赖倒置原则
#7.扩展
###7.1 多个访问者
###7.2 双分派