设计模式：访问者（Visitor）模式

时间 2019-11-12

标签设计模式访问者 visitor 繁體版

原文原文链接

设计模式：访问者（Visitor）模式

1、前言html

什么叫作访问，若是你们学过数据结构，对于这点就很清晰了，遍历就是访问的通常形式，单独读取一个元素进行相应的处理也叫做访问，读取到想要查看的内容+对其进行处理就叫作访问，那么咱们日常是怎么访问的，基本上就是直接拿着须要访问的地址（引用）来读写内存就能够了。java

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

所以，咱们思考，可不能够将访问操做独立出来变成一个新的类，当咱们须要增长访问操做的时候，直接增长新的类，原来的代码不须要任何的改变，若是能够这样作，那么咱们的程序就是好的程序，由于能够扩展，符合开闭原则。而访问者模式就是实现这个的，使得使用不一样的访问方式均可以对某些元素进行访问。设计模式

2、代码数据结构

Element 接口：

1 package zyr.dp.visitor;
2 
3 public interface Element {
4 
5     public abstract void accept(Visitor visitor);
6     
7 }

Entry 类：

 1 package zyr.dp.visitor;
 2 
 3 import java.util.Iterator;
 4 
 5 public abstract class Entry implements Element{
 6     public abstract String getName();
 7     public abstract int getSize();
 8     public abstract void printList(String prefix);
 9     public  void printList(){
10         printList("");
11     }
12     public  Entry add(Entry entry) throws RuntimeException{
13         throw new RuntimeException();
14     }
15     public  Iterator iterator() throws RuntimeException{
16         throw new RuntimeException();
17     }
18     public  String toString(){
19         return getName()+"<"+getSize()+">";
20     }
21 }

File 类：

 1 package zyr.dp.visitor;
 2 
 3 public class File extends Entry {
 4 
 5     private String name;
 6     private int size;
 7     public File(String name,int size){
 8         this.name=name;
 9         this.size=size;
10     }
11     public String getName() {
12         return name;
13     }
14 
15     public int getSize() {
16         return size;
17     }
18 
19     public void printList(String prefix) {
20         System.out.println(prefix+"/"+this);
21     }
22     public void accept(Visitor visitor) {
23        //  System.out.println("开始访问文件:"+this);
24         visitor.visit(this);
25        // System.out.println("结束访问文件:"+this);
26        // System.out.println();
27     }
28 
29 }

Directory类：函数

 1 package zyr.dp.visitor;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 public class Directory extends Entry {
 7 
 8     String name;
 9     ArrayList entrys=new ArrayList();
10     public Directory(String name){
11         this.name=name;
12     }
13     public String getName() {
14         return name;
15     }
16 
17     public int getSize() {
18         int size=0;
19         Iterator it=entrys.iterator();
20         while(it.hasNext()){
21             size+=((Entry)it.next()).getSize();
22         }
23         return size;
24     }
25 
26     public Entry add(Entry entry) {
27         entrys.add(entry);
28         return this;
29     }
30     
31     public Iterator iterator() {
32         return entrys.iterator();
33     }
34     
35     public void printList(String prefix) {
36         System.out.println(prefix+"/"+this);
37         Iterator it=entrys.iterator();
38         Entry entry;
39         while(it.hasNext()){
40             entry=(Entry)it.next();
41             entry.printList(prefix+"/"+name);
42         }
43     }
44     public void accept(Visitor visitor) {
45       //  System.out.println("开始访问文件夹:"+this);
46         visitor.visit(this);
47      //   System.out.println("结束访问文件夹:"+this);
48      //   System.out.println();
49     }
50 
51 }

Visitor 类：

1 package zyr.dp.visitor;
2 
3 public abstract class Visitor {
4 
5     public abstract void visit(File file);
6     public abstract void visit(Directory directory);
7     
8 }

ListVisitor类：学习

 1 package zyr.dp.visitor;
 2 
 3 import java.util.Iterator;
 4 
 5 public class ListVisitor extends Visitor {
 6 
 7     String currentDir = "";
 8     public void visit(File file) {
 9         System.out.println(currentDir+"/"+file);
10     }
11 
12     public void visit(Directory directory) {
13         System.out.println(currentDir+"/"+directory);
14         String saveDir=currentDir;
15         currentDir+=("/"+directory.getName());
16         Iterator it=directory.iterator();
17         while(it.hasNext()){
18             Entry entry=(Entry)it.next();
19             entry.accept(this);
20         }
21         currentDir=saveDir;
22     }
23 
24 }

FileVisitor 类：

 1 package zyr.dp.visitor;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Iterator;
 5 
 6 public class FileVisitor extends Visitor {
 7 
 8     String currentDir = "";
 9     String suffix;
10     ArrayList files=new ArrayList();
11     
12     public FileVisitor(String suffix){
13          this.suffix = suffix;
14     }
15     
16     public void visit(File file) {
17         if(file.getName().endsWith(suffix)){
18          // System.out.println(currentDir+"/"+file);
19             files.add(currentDir+"/"+file);
20         }
21     }
22 
23     public void visit(Directory directory) {
24         String saveDir=currentDir;
25         currentDir+=("/"+directory.getName());
26         Iterator it=directory.iterator();
27         while(it.hasNext()){
28             Entry entry=(Entry)it.next();
29             entry.accept(this);
30         }
31         currentDir=saveDir;
32     }
33     Iterator getFiles(){
34         return files.iterator();
35     }
36 
37 }

Main类：this

 1 package zyr.dp.visitor;
 2 
 3 import java.util.Iterator;
 4 
 5 
 6 public class Main {
 7 
 8     public static void main(String[] args) {
 9 
10         Directory root=new Directory("根目录");
11         
12         Directory life=new Directory("个人生活");
13         File eat=new File("吃火锅.txt",100);
14         File sleep=new File("睡觉.html",100);
15         File study=new File("学习.txt",100);
16         life.add(eat);
17         life.add(sleep);
18         life.add(study);
19         
20         Directory work=new Directory("个人工做");
21         File write=new File("写博客.doc",200);
22         File paper=new File("写论文.html",200);
23         File homework=new File("写家庭做业.docx",200);
24         work.add(write);
25         work.add(paper);
26         work.add(homework);
27         
28         Directory relax=new Directory("个人休闲");
29         File music=new File("听听音乐.js",200);
30         File walk=new File("出去转转.psd",200);
31         relax.add(music);
32         relax.add(walk);
33         
34         Directory read=new Directory("个人阅读");
35         File book=new File("学习书籍.psd",200);
36         File novel=new File("娱乐小说.txt",200);
37         read.add(book);
38         read.add(novel);
39         
40         root.add(life);
41         root.add(work);
42         root.add(relax);
43         root.add(read);
44         
45         root.accept(new ListVisitor());
46         System.out.println("========================");
47         FileVisitor visitor=new FileVisitor(".psd");
48         root.accept(visitor);
49         Iterator it = visitor.getFiles();
50         while(it.hasNext()){
51             System.out.println(it.next());
52         }
53         
54     }
55 
56 }

运行结果：spa

能够看到咱们的运行结果第一个和使用Composite模式的结果同样，第二个是实现另外一种方式的访问，只访问文件后缀为某一特定的内容的文件，结果也是正确的，而且为了说明咱们的访问还能够保存下来访问的结果，咱们使用了ArrayList自带的迭代器将保存到ArrayList中的结果输出出来，咱们固然也能够直接在遍历的时候就输出出来，这个看咱们的使用要求了。由此能够看到在保证数据结构（File和Directory）不发生变化的状况下（没有新增或者删除），能够很是方便增长新的一种访问方法，只须要新增长一个访问类便可，可是若是咱们数据结构发生变化以后，就须要修改继承自Visitor类的全部类了，这也违背了开闭原则，所以咱们应该认真考虑，到底咱们的数据结构是定死的仍是常常变化的。没有任何一种设计模式是十全十美的，老是有所取舍，有所利弊，根据实际状况来选择才是最好的设计方法。设计

这里要说明一下双重分发机制，咱们来看一下最核心的遍历逻辑，结合组合模式的时候咱们已经分析过的遍历方法，递归，你们以为此次咱们要怎么在数据结构外面进行遍历，确定仍是要使用递归了，但是数据结构中的数据在类的内部，怎么递归到内部呢，咱们想到了间接递归，也就是双重分发。

1     public void printList(String prefix) {
2         System.out.println(prefix+"/"+this);
3         Iterator it=entrys.iterator();
4         Entry entry;
5         while(it.hasNext()){
6             entry=(Entry)it.next();
7            entry.printList(prefix+"/"+name); 8         }
9     }

上面的代码是在组合模式类的内部遍历的过程，能够明确的看到递归（直接递归）的使用。咱们看一下访问者模式中的间接递归：

Directory类中：

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

File类：

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

在ListVisitor中：

 1 public void visit(File file) { 2 System.out.println(currentDir+"/"+file); 3 }  4 
 5     public void visit(Directory directory) {
 6         System.out.println(currentDir+"/"+directory);
 7         String saveDir=currentDir;
 8         currentDir+=("/"+directory.getName());
 9         Iterator it=directory.iterator();
10         while(it.hasNext()){
11             Entry entry=(Entry)it.next();
12             entry.accept(this); 13         }
14         currentDir=saveDir;
15     }

咱们看到了entry.accept(this)这句话，这句话是很是重要的，咱们在Main中是这样用的：

1     root.accept(new ListVisitor());

那么串连起来，在Main中咱们经过Directory或者File类型的对象调用accept（访问者）方法，接受访问者的访问，这是访问者和被访问者的第一次亲密接触，亲近对方就是为了得到对方的数据，而后才能对对方的数据进行使用，那么怎么拿到的呢？！咱们看到了这句visitor.visit(this);这句话无疑是重要的，被调用者告诉访问者，我将个人内容this，所有给你了，之后访问者就能够对this所指代的被访问者的内容进行操做了，分为两类，若是被访问者是File文件类型的，就会直接输出内容，到达叶子结点，访问结束；若是是文件夹，那就很是有意思了，首先咱们仍旧是让被访问者将本身的内容交给访问者visitor.visit(this);，以后public void visit(Directory directory)被调用，经过遍历的方式将属于这个文件夹下面的数据所有拿到Iterator it=directory.iterator();，而后开始一个个的处理，怎么处理呢，继续访问属于这个文件夹下面对象的accept()方法使用entry.accept(this);，来将访问者交过去，交给谁？！确定是给entry所指的对象，也就是文件夹里面的子文件夹或者文件，若是是文件的话，继续在本身的方法中调用visitor.visit(this);，最终落实到调用 public void visit(File file)经过System.out.println(currentDir+"/"+file);访问结束，若是不是文件呢？若为文件夹，则继续调用属于文件夹的方法，就这样不断地往下面查找，一直到遍历完文件夹下面的全部的元素，所以也是深度优先遍历。就这样经过压栈和出栈，咱们完成了最终的遍历，最终的出口有两个，一个是访问文件，输出以后结束，另外一个是遍历完文件夹，即便文件夹下面没有文件依旧结束。

1 root.accept(new ListVisitor());

1     public void accept(Visitor visitor) {
2         visitor.visit(this); 3     }

 1     public void visit(File file) {  2         System.out.println(currentDir+"/"+file);
 3     }
 4 
 5     public void visit(Directory directory) {
 6         System.out.println(currentDir+"/"+directory);
 7         String saveDir=currentDir;
 8         currentDir+=("/"+directory.getName());
 9         Iterator it=directory.iterator();
10         while(it.hasNext()){
11             Entry entry=(Entry)it.next();
12             entry.accept(this); 13         }
14         currentDir=saveDir;
15     }

在accept函数中调用visit，一样在visit中调用accept，这就是间接递归，或者叫作双重分发。产生的缘由就是访问者须要和被访问者相互交流，才能一步步的获得想要的数据。咱们能够考虑主持人采访一个明星，那么这个明星接受采访，把本身基本信息（能问的问题以及某些答案）告诉主持人，问主持人有问题吗？若是主持人有问题（还能向下问）要问那么就再次拿着新的问题问这个明星，这个明星再次将本身关于这方面的信息告诉主持人；若是没有问题（获得答案），主持人将信息总结以后说出来。就这样一直持续下去，直到主持人没问题问了，而且明星的信息也都被问到了，这样采访就结束了。因而可知，不少时候设计模式都是和生活密切相关的，生活中的常识有时候就是一些套路，而这种套路就是一种抽象的模式。

3、总结

访问者模式是一个很是有意思的模式，由于本身须要获得数据就须要向被访者索取，若是可以一次索取成功，访问就结束了，若是还须要其余信息，则再次向被访问者索取，就这样知道拿到本身须要的全部数据。在本例中借用了组合模式中的数据结构，那是由于这种树形的结构很适合咱们进行递归访问。访问者模式和迭代器模式都是在某种数据结构上进行处理，一种是对数据结构中的元素进行某种特定的处理，另外一种是用某种方式遍历全部元素。在实际应用中，咱们根据实际须要来考虑是否是须要双重分发机制。在本例中的访问者模式中用到了组合模式、委托（组合）、双重分发等原理，便于新增访问方式，不便于对数据结构的修改。

程序代码