设计模式（十三）-访问者模式（Visitor Pattern）——访问数据结构并处理数据

快来打我* 2022-05-31 02:39 139阅读 0赞

访问者模式（Visitor Pattern）中，数据结构与处理被分离开来。

**Visitor.java**

package com.test.dp.Visitor.Sample;
    
    //表示访问者的抽象来，用它来访问文件和文件夹
    public abstract class Visitor {
        public abstract void visit(File file);
        public abstract void visit(Directory directory);
    }

**Element.java**

package com.test.dp.Visitor.Sample;
    
    //表示接口的抽象类，用它接受访问者的访问
    public interface Element {
        public abstract void accept(Visitor v);
    }

**Entry.java**

package com.test.dp.Visitor.Sample;
    
    import java.util.Iterator;
    
    //File类和Directory类的父类，他是也是抽象类（实现了Element接口）
    public abstract class Entry implements Element {
        public abstract String getName();                                   // 获取名字
        public abstract int getSize();                                      // 获取大小
        public Entry add(Entry entry) throws FileTreatmentException {       // 增加目录条目
            throw new FileTreatmentException();
        }
        public Iterator iterator() throws FileTreatmentException {    // 生成Iterator
            throw new FileTreatmentException();
        }
        public String toString() {                                          // 显示字符串
            return getName() + " (" + getSize() + ")";
        }
    }

**File.java**

package com.test.dp.Visitor.Sample;
    
    //表示文件的类，代表了一种结构
    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 accept(Visitor v) {
            v.visit(this);
        }
    }

**Directory.java**

package com.test.dp.Visitor.Sample;
    
    import java.util.Iterator;
    import java.util.ArrayList;
    
    //表示文件夹的类
    public class Directory extends Entry {
        private String name;                    // 文件夹名字
        private ArrayList dir = new ArrayList();      // 目录条目集合
        public Directory(String name) {         // 构造函数
            this.name = name;
        }
        public String getName() {               // 获取名字
            return name;
        }
        public int getSize() {                  // 获取大小
            int size = 0;
            Iterator it = dir.iterator();
            while (it.hasNext()) {
                Entry entry = (Entry)it.next();
                size += entry.getSize();
            }
            return size;
        }
        public Entry add(Entry entry) {         // 增加目录条目
            dir.add(entry);
            return this;
        }
        public Iterator iterator() {      // 生成Iterator
            return dir.iterator();
        }
        public void accept(Visitor v) {         // 接受访问者的访问
            v.visit(this);
        }
    }

**ListVisitor.java**

package com.test.dp.Visitor.Sample;
    
    import java.util.Iterator;
    
    //Visitor访问者抽象类的子类，实现显示文件和文件一览
    public class ListVisitor extends Visitor {
        private 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 = currentdir + "/" + directory.getName();
            Iterator it = directory.iterator();
            while (it.hasNext()) {
                Entry entry = (Entry)it.next();
                entry.accept(this);
            }
            currentdir = savedir;
        }
    }

**FileTreatmentException.java**

package com.test.dp.Visitor.Sample;
    
    //表示向文件发送add时发生异常的类
    public class FileTreatmentException extends RuntimeException {
        public FileTreatmentException() {
        }
        public FileTreatmentException(String msg) {
            super(msg);
        }
    }

**Main.java**

package com.test.dp.Visitor.Sample;
    
    public class Main {
        public static void main(String[] args) {
            try {
                System.out.println("Making root entries...");
                Directory rootdir = new Directory("root");
                Directory bindir = new Directory("bin");
                Directory tmpdir = new Directory("tmp");
                Directory usrdir = new Directory("usr");
                rootdir.add(bindir);
                rootdir.add(tmpdir);
                rootdir.add(usrdir);
                bindir.add(new File("vi", 10000));
                bindir.add(new File("latex", 20000));
                rootdir.accept(new ListVisitor());              
    
                System.out.println("");
                System.out.println("Making user entries...");
                Directory yuki = new Directory("yuki");
                Directory hanako = new Directory("hanako");
                Directory tomura = new Directory("tomura");
                usrdir.add(yuki);
                usrdir.add(hanako);
                usrdir.add(tomura);
                yuki.add(new File("diary.html", 100));
                yuki.add(new File("Composite.java", 200));
                hanako.add(new File("memo.tex", 300));
                tomura.add(new File("game.doc", 400));
                tomura.add(new File("junk.mail", 500));
                rootdir.accept(new ListVisitor());              
            } catch (FileTreatmentException e) {
                e.printStackTrace();
            }
        }
    }

**执行结果：**

Making root entries...  
/root (30000)  
/root/bin (30000)  
/root/bin/vi (10000)  
/root/bin/latex (20000)  
/root/tmp (0)  
/root/usr (0)  
  
Making user entries...  
/root (31500)  
/root/bin (30000)  
/root/bin/vi (10000)  
/root/bin/latex (20000)  
/root/tmp (0)  
/root/usr (1500)  
/root/usr/yuki (300)  
/root/usr/yuki/diary.html (100)  
/root/usr/yuki/Composite.java (200)  
/root/usr/hanako (300)  
/root/usr/hanako/memo.tex (300)  
/root/usr/tomura (900)  
/root/usr/tomura/game.doc (400)  
/root/usr/tomura/junk.mail (500)

**总结：**

**应用实例：**您在朋友家做客，您是访问者，朋友接受您的访问，您通过朋友的描述，然后对朋友的描述做出一个判断，这就是访问者模式。

**优点：**1、符合单一职责原则。2、优秀的扩展性。3、灵活性。

**缺点：**1、具体元素对访问者公布细节，违反了迪米特原则。2、具体元素变更比较困难。3、违反了依赖倒置原则，依赖了具体类，没有依赖抽象。

**使用场景：**1、对象结构中对象对应的类很少改变，但经常需要在此对象结构上定义新的操作。2、需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免让这些操作"污染"这些对象的类，也不希望在增加新操作时修改这些类。

**注意事项：**访问者可以对功能进行统一，可以做报表、UI、拦截器与过滤器。