前言

什么叫做访问,如果大家学过数据结构,对于这点就很清晰了,遍历就是访问的一般形式,单独读取一个元素进行相应的处理也叫作访问,读取到想要查看的内容+对其进行处理就叫做访问,那么我们平常是怎么访问的,基本上就是直接拿着需要访问的地址(引用)来读写内存就可以了。

为什么还要有一个访问者模式呢,这就要放到OOP之中了,在面向对象编程的思想中,我们使用类来组织属性,以及对属性的操作,那么我们理所当然的将访问操作放到了类的内部,这样看起来没问题,但是当我们想要使用另一种遍历方式要怎么办呢,我们必须将这个类进行修改,这在设计模式中是大忌,在设计模式中就要保证,对扩展开放,对修改关闭的开闭原则。

因此,我们思考,可不可以将访问操作独立出来变成一个新的类,当我们需要增加访问操作的时候,直接增加新的类,原来的代码不需要任何的改变,如果可以这样做,那么我们的程序就是好的程序,因为可以扩展,符合开闭原则。而访问者模式就是实现这个的,使得使用不同的访问方式都可以对某些元素进行访问。

类图

涉及角色

  • Visitor 抽象访问者角色,为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色,这样访问者就可以通过该元素角色的特定接口直接访问它。
  • ConcreteVisitor (下文中ListVisitor和FileVisitor).具体访问者角色,实现Visitor声明的接口。
  • Element 定义一个接受访问操作(accept()),它以一个访问者(Visitor)作为参数。
  • ConcreteElement (下文中Directory和File) 具体元素,实现了抽象元素(Element)所定义的接受操作接口。
  • ObjectStructure (下文中Entry) 结构对象角色,这是使用访问者模式必备的角色。它具备以下特性:能枚举它的元素;可以提供一个高层接口以允许访问者访问它的元素;如有需要,可以设计成一个复合对象或者一个聚集(如一个列表或无序集合)

代码

Element 接口


public interface Element {

public abstract void accept(Visitor visitor);

}

Entry 类

import java.util.Iterator;

public abstract class Entry implements Element{
public abstract String getName();
public abstract int getSize();
public abstract void printList(String prefix);
public void printList(){
printList("");
}
public Entry add(Entry entry) throws RuntimeException{
throw new RuntimeException();
}
public Iterator iterator() throws RuntimeException{
throw new RuntimeException();
}
public String toString(){
return getName()+"<"+getSize()+">";
}
}

File 类:


public class File extends Entry {

private String name;
private int size;
public File(String name,int size){
this.name=name;
this.size=size;
}
public String getName() {
return name;
}

public int getSize() {
return size;
}

public void printList(String prefix) {
System.out.println(prefix+"/"+this);
}
public void accept(Visitor visitor) {
// System.out.println("开始访问文件:"+this);
visitor.visit(this);
// System.out.println("结束访问文件:"+this);
// System.out.println();
}

}

Directory类:


import java.util.ArrayList;
import java.util.Iterator;

public class Directory extends Entry {

String name;
ArrayList entrys=new ArrayList();
public Directory(String name){
this.name=name;
}
public String getName() {
return name;
}

public int getSize() {
int size=0;
Iterator it=entrys.iterator();
while(it.hasNext()){
size+=((Entry)it.next()).getSize();
}
return size;
}

public Entry add(Entry entry) {
entrys.add(entry);
return this;
}

public Iterator iterator() {
return entrys.iterator();
}

public void printList(String prefix) {
System.out.println(prefix+"/"+this);
Iterator it=entrys.iterator();
Entry entry;
while(it.hasNext()){
entry=(Entry)it.next();
entry.printList(prefix+"/"+name);
}
}
public void accept(Visitor visitor) {
// System.out.println("开始访问文件夹:"+this);
visitor.visit(this);
// System.out.println("结束访问文件夹:"+this);
// System.out.println();
}

}

Visitor 类:


public abstract class Visitor {

public abstract void visit(File file);
public abstract void visit(Directory directory);

}

ListVisitor类:


import java.util.Iterator;

public class ListVisitor extends Visitor {

String currentDir = "";
public void visit(File file) {
System.out.println(currentDir+"/"+file);
}

public void visit(Directory directory) {
System.out.println(currentDir+"/"+directory);
String saveDir=currentDir;
currentDir+=("/"+directory.getName());
Iterator it=directory.iterator();
while(it.hasNext()){
Entry entry=(Entry)it.next();
entry.accept(this);
}
currentDir=saveDir;
}

}

FileVisitor 类:


import java.util.ArrayList;
import java.util.Iterator;

public class FileVisitor extends Visitor {

String currentDir = "";
String suffix;
ArrayList files=new ArrayList();

public FileVisitor(String suffix){
this.suffix = suffix;
}

public void visit(File file) {
if(file.getName().endsWith(suffix)){
// System.out.println(currentDir+"/"+file);
files.add(currentDir+"/"+file);
}
}

public void visit(Directory directory) {
String saveDir=currentDir;
currentDir+=("/"+directory.getName());
Iterator it=directory.iterator();
while(it.hasNext()){
Entry entry=(Entry)it.next();
entry.accept(this);
}
currentDir=saveDir;
}
Iterator getFiles(){
return files.iterator();
}

}

Client类

package com.visitor.t1;

import java.util.Iterator;

public class Client {

public static void main(String[] args) {
Directory root=new Directory("根目录");

Directory life=new Directory("我的生活");
File eat=new File("吃火锅.txt",100);
File sleep=new File("睡觉.html",100);
File study=new File("学习.txt",100);
life.add(eat);
life.add(sleep);
life.add(study);

Directory work=new Directory("我的工作");
File write=new File("写博客.doc",200);
File paper=new File("写论文.html",200);
File homework=new File("写家庭作业.docx",200);
work.add(write);
work.add(paper);
work.add(homework);

Directory relax=new Directory("我的休闲");
File music=new File("听听音乐.js",200);
File walk=new File("出去转转.psd",200);
relax.add(music);
relax.add(walk);

Directory read=new Directory("我的阅读");
File book=new File("学习书籍.psd",200);
File novel=new File("娱乐小说.txt",200);
read.add(book);
read.add(novel);

root.add(life);
root.add(work);
root.add(relax);
root.add(read);

root.accept(new ListVisitor());
System.out.println("========================");
FileVisitor visitor=new FileVisitor(".psd");
root.accept(visitor);
Iterator it = visitor.getFiles();
while(it.hasNext()){
System.out.println(it.next());
}
}
}

运行结果

运行结果

可以看到我们的运行结果第一个和使用Composite模式的结果一样,第二个是实现另一种方式的访问,只访问文件后缀为某一特定的内容的文件,结果也是正确的,并且为了说明我们的访问还可以保存下来访问的结果,我们使用了ArrayList自带的迭代器将保存到ArrayList中的结果输出出来,我们当然也可以直接在遍历的时候就输出出来,这个看我们的使用要求了。由此可以看到在保证数据结构(File和Directory)不发生变化的情况下(没有新增或者删除),可以非常方便增加新的一种访问方法,只需要新增加一个访问类即可,但是如果我们数据结构发生变化之后,就需要修改继承自Visitor类的所有类了,这也违背了开闭原则,因此我们应该认真考虑,到底我们的数据结构是定死的还是经常变化的。没有任何一种设计模式是十全十美的,总是有所取舍,有所利弊,根据实际情况来选择才是最好的设计方法。

这里要说明一下双重分发机制,我们来看一下最核心的遍历逻辑,结合组合模式的时候我们已经分析过的遍历方法,递归,大家觉得这次我们要怎么在数据结构外面进行遍历,肯定还是要使用递归了,可是数据结构中的数据在类的内部,怎么递归到内部呢,我们想到了间接递归,也就是双重分发。

public void printList(String prefix) {
System.out.println(prefix+"/"+this);
Iterator it=entrys.iterator();
Entry entry;
while(it.hasNext()){
entry=(Entry)it.next();
entry.printList(prefix+"/"+name);
}
}

上面的代码是在组合模式类的内部遍历的过程,可以明确的看到递归(直接递归)的使用。我们看一下访问者模式中的间接递归:

Directory类中:

public void accept(Visitor visitor) {
//System.out.println("开始访问文件夹:"+this);
visitor.visit(this);
//System.out.println("结束访问文件夹:"+this);
//System.out.println();
}

在ListVisitor中:

public void visit(File file) {
System.out.println(currentDir+"/"+file);
}

public void visit(Directory directory) {
System.out.println(currentDir+"/"+directory);
String saveDir=currentDir;
currentDir+=("/"+directory.getName());
Iterator it=directory.iterator();
while(it.hasNext()){
Entry entry=(Entry)it.next();
entry.accept(this);
}
currentDir=saveDir;
}

我们看到了entry.accept(this)这句话,这句话是非常重要的,我们在Client中是这样用的:

root.accept(new ListVisitor());

在accept函数中调用visit,同样在visit中调用accept,这就是间接递归,或者叫做双重分发。产生的原因就是访问者需要和被访问者相互交流,才能一步步的得到想要的数据。我们可以考虑主持人采访一个明星,那么这个明星接受采访,把自己基本信息(能问的问题以及某些答案)告诉主持人,问主持人有问题吗?如果主持人有问题(还能向下问)要问那么就再次拿着新的问题问这个明星,这个明星再次将自己关于这方面的信息告诉主持人;如果没有问题(得到答案),主持人将信息总结之后说出来。就这样一直持续下去,直到主持人没问题问了,并且明星的信息也都被问到了,这样采访就结束了。由此可见,很多时候设计模式都是和生活密切相关的,生活中的常识有时候就是一些套路,而这种套路就是一种抽象的模式。

特性

  1. 优点

    符合单一职责原则
    元素类可以通过接受不同的访问者来实现对不同操作的扩展。

  2. 缺点

    具体元素对访问者公布细节,违背了迪米特法则。
    违背了依赖倒置原则,访问者依赖的是具体元素,而不是抽象元素。

总结

访问者模式是一个非常有意思的模式,因为自己需要得到数据就需要向被访者索取,如果能够一次索取成功,访问就结束了,如果还需要其他信息,则再次向被访问者索取,就这样知道拿到自己需要的所有数据。在本例中借用了组合模式中的数据结构,那是因为这种树形的结构很适合我们进行递归访问。访问者模式和迭代器模式都是在某种数据结构上进行处理,一种是对数据结构中的元素进行某种特定的处理,另一种是用某种方式遍历所有元素。在实际应用中,我们根据实际需要来考虑是不是需要双重分发机制。在本例中的访问者模式中用到了组合模式、委托(组合)、双重分发等原理,便于新增访问方式,不便于对数据结构的修改。

代码地址

博主主页

可以加博主微信一起交流:twobixiaoxin