设计模式系列-第二十一章（行为型-访问者模式）

た入场券 2022-11-19 04:12 182阅读 0赞

# 一、访问者模式定义 #

访问者模式允许一个或者多个操作应用到一组对象上，设计意图是解耦操作和对象本身，保持类职责单一、满足开闭原则以及应对代码的复杂性，实际策略加工厂模式也可以达到同样效果。虽然策略模式也能实现，但对于多种类型的同个操作聚合在了一起，这种情况属于同父类的一些相同操作就能抽私有共用方法，相对于策略模式会更加优雅和简单。。对于访问者模式，学习的主要难点在代码实现。而代码实现比较复杂的主要原因是，函数重载在大部分面向对象编程语言中是静态绑定的。也就是说，调用类的哪个重载函数，是在编译期间，由参数的声明类型决定的，而非运行时，根据参数的实际类型决定的。

# 二、访问者模式的实现 #

假设我们从网站上爬取了很多资源文件，它们的格式有三种：PDF、PPT、Word。我们现在要开发一个工具来处理这批资源文件。这个工具的其中一个功能是，把这些资源文件中的文本内容抽取出来放到 txt 文件中。如果让你来实现，你会怎么来做呢？

## 2.1 普通的方式 ##

实现这个功能并不难，不同的人有不同的写法，我将其中一种代码实现方式贴在这里。其中，ResourceFile 是一个抽象类，包含一个抽象函数 extract2txt()。PdfFile、PPTFile、WordFile 都继承 ResourceFile 类，并且重写了 extract2txt() 函数。在 ToolApplication 中，我们可以利用多态特性，根据对象的实际类型，来决定执行哪个方法。

public abstract class ResourceFile {
      protected String filePath;
    
      public ResourceFile(String filePath) {
        this.filePath = filePath;
      }
    
      public abstract void extract2txt();
    }
    
    public class PPTFile extends ResourceFile {
      public PPTFile(String filePath) {
        super(filePath);
      }
    
      @Override
      public void extract2txt() {
        //...省略一大坨从PPT中抽取文本的代码...
        //...将抽取出来的文本保存在跟filePath同名的.txt文件中...
        System.out.println("Extract PPT.");
      }
    }
    
    public class PdfFile extends ResourceFile {
      public PdfFile(String filePath) {
        super(filePath);
      }
    
      @Override
      public void extract2txt() {
        //...
        System.out.println("Extract PDF.");
      }
    }
    
    public class WordFile extends ResourceFile {
      public WordFile(String filePath) {
        super(filePath);
      }
    
      @Override
      public void extract2txt() {
        //...
        System.out.println("Extract WORD.");
      }
    }
    
    // 运行结果是：
    // Extract PDF.
    // Extract WORD.
    // Extract PPT.
    public class ToolApplication {
      public static void main(String[] args) {
        List<ResourceFile> resourceFiles = listAllResourceFiles(args[0]);
        for (ResourceFile resourceFile : resourceFiles) {
          resourceFile.extract2txt();
        }
      }
    
      private static List<ResourceFile> listAllResourceFiles(String resourceDirectory) {
        List<ResourceFile> resourceFiles = new ArrayList<>();
        //...根据后缀(pdf/ppt/word)由工厂方法创建不同的类对象(PdfFile/PPTFile/WordFile)
        resourceFiles.add(new PdfFile("a.pdf"));
        resourceFiles.add(new WordFile("b.word"));
        resourceFiles.add(new PPTFile("c.ppt"));
        return resourceFiles;
      }
    }

如果工具的功能不停地扩展，不仅要能抽取文本内容，还要支持压缩、提取文件元信息（文件名、大小、更新时间等等）构建索引等一系列的功能，那如果我们继续按照上面的实现思路，就会存在这样几个问题：

*  违背开闭原则，添加一个新的功能，所有类的代码都要修改；
 *  虽然功能增多，每个类的代码都不断膨胀，可读性和可维护性都变差了；
 *  把所有比较上层的业务逻辑都耦合到 PdfFile、PPTFile、WordFile 类中，导致这些类的职责不够单一，变成了大杂烩。

## 2.2 访问者模式 ##

针对上面2.1的问题，我们常用的解决方法就是拆分解耦，把业务操作跟具体的数据结构解耦，设计成独立的类。这里我们按照访问者模式的演进思路来对上面的代码进行重构。重构之后的代码如下所示。

public abstract class ResourceFile {
      protected String filePath;
      public ResourceFile(String filePath) {
        this.filePath = filePath;
      }
    }
    
    public class PdfFile extends ResourceFile {
      public PdfFile(String filePath) {
        super(filePath);
      }
      //...
    }
    //...PPTFile、WordFile代码省略...
    public class Extractor {
      public void extract2txt(PPTFile pptFile) {
        //...
        System.out.println("Extract PPT.");
      }
    
      public void extract2txt(PdfFile pdfFile) {
        //...
        System.out.println("Extract PDF.");
      }
    
      public void extract2txt(WordFile wordFile) {
        //...
        System.out.println("Extract WORD.");
      }
    }
    
    public class ToolApplication {
      public static void main(String[] args) {
        Extractor extractor = new Extractor();
        List<ResourceFile> resourceFiles = listAllResourceFiles(args[0]);
        for (ResourceFile resourceFile : resourceFiles) {
          extractor.extract2txt(resourceFile);
        }
      }
    
      private static List<ResourceFile> listAllResourceFiles(String resourceDirectory) {
        List<ResourceFile> resourceFiles = new ArrayList<>();
        //...根据后缀(pdf/ppt/word)由工厂方法创建不同的类对象(PdfFile/PPTFile/WordFile)
        resourceFiles.add(new PdfFile("a.pdf"));
        resourceFiles.add(new WordFile("b.word"));
        resourceFiles.add(new PPTFile("c.ppt"));
        return resourceFiles;
      }
    }

这其中最关键的一点设计是，我们把抽取文本内容的操作，设计成了三个重载函数。函数重载是 Java、C++ 这类面向对象编程语言中常见的语法机制。所谓重载函数是指，在同一类中函数名相同、参数不同的一组函数。但是上面的代码是编译通过不了的，第 37 行会报错。因为多态是一种动态绑定，可以在运行时获取对象的实际类型，来运行实际类型对应的方法。而函数重载是一种静态绑定，在编译时并不能获取对象的实际类型，而是根据声明类型执行声明类型对应的方法。解决的办法稍微有点难理解，我们先来看代码。

public abstract class ResourceFile {
      protected String filePath;
      public ResourceFile(String filePath) {
        this.filePath = filePath;
      }
      abstract public void accept(Extractor extractor);
    }
    
    public class PdfFile extends ResourceFile {
      public PdfFile(String filePath) {
        super(filePath);
      }
    
      @Override
      public void accept(Extractor extractor) {
        extractor.extract2txt(this);
      }
    
      //...
    }
    
    //...PPTFile、WordFile跟PdfFile类似，这里就省略了...
    //...Extractor代码不变...
    
    public class ToolApplication {
      public static void main(String[] args) {
        Extractor extractor = new Extractor();
        List<ResourceFile> resourceFiles = listAllResourceFiles(args[0]);
        for (ResourceFile resourceFile : resourceFiles) {
          resourceFile.accept(extractor);
        }
      }
    
      private static List<ResourceFile> listAllResourceFiles(String resourceDirectory) {
        List<ResourceFile> resourceFiles = new ArrayList<>();
        //...根据后缀(pdf/ppt/word)由工厂方法创建不同的类对象(PdfFile/PPTFile/WordFile)
        resourceFiles.add(new PdfFile("a.pdf"));
        resourceFiles.add(new WordFile("b.word"));
        resourceFiles.add(new PPTFile("c.ppt"));
        return resourceFiles;
      }
    }

在执行第 30 行的时候，根据多态特性，程序会调用实际类型的 accept 函数，比如 PdfFile 的 accept 函数，也就是第 16 行代码。而 16 行代码中的 this 类型是 PdfFile 的，在编译的时候就确定了，所以会调用 extractor 的 extract2txt(PdfFile pdfFile) 这个重载函数。这是理解访问者模式的关键所在，也是我之前所说的访问者模式不好理解的原因。现在，如果要继续添加新的功能，比如前面提到的压缩功能，根据不同的文件类型，使用不同的压缩算法来压缩资源文件，那我们该如何实现呢？我们需要实现一个类似 Extractor 类的新类 Compressor 类，在其中定义三个重载函数，实现对不同类型资源文件的压缩。除此之外，我们还要在每个资源文件类中定义新的 accept 重载函数。具体的代码如下所示：

public abstract class ResourceFile {
      protected String filePath;
      public ResourceFile(String filePath) {
        this.filePath = filePath;
      }
      abstract public void accept(Visitor vistor);
    }
    
    public class PdfFile extends ResourceFile {
      public PdfFile(String filePath) {
        super(filePath);
      }
    
      @Override
      public void accept(Visitor visitor) {
        visitor.visit(this);
      }
    
      //...
    }
    //...PPTFile、WordFile跟PdfFile类似，这里就省略了...
    
    public interface Visitor {
      void visit(PdfFile pdfFile);
      void visit(PPTFile pdfFile);
      void visit(WordFile pdfFile);
    }
    
    public class Extractor implements Visitor {
      @Override
      public void visit(PPTFile pptFile) {
        //...
        System.out.println("Extract PPT.");
      }
    
      @Override
      public void visit(PdfFile pdfFile) {
        //...
        System.out.println("Extract PDF.");
      }
    
      @Override
      public void visit(WordFile wordFile) {
        //...
        System.out.println("Extract WORD.");
      }
    }
    
    public class Compressor implements Visitor {
      @Override
      public void visit(PPTFile pptFile) {
        //...
        System.out.println("Compress PPT.");
      }
    
      @Override
      public void visit(PdfFile pdfFile) {
        //...
        System.out.println("Compress PDF.");
      }
    
      @Override
      public void visit(WordFile wordFile) {
        //...
        System.out.println("Compress WORD.");
      }
    
    }
    
    public class ToolApplication {
      public static void main(String[] args) {
        Extractor extractor = new Extractor();
        List<ResourceFile> resourceFiles = listAllResourceFiles(args[0]);
        for (ResourceFile resourceFile : resourceFiles) {
          resourceFile.accept(extractor);
        }
    
        Compressor compressor = new Compressor();
        for(ResourceFile resourceFile : resourceFiles) {
          resourceFile.accept(compressor);
        }
      }
    
      private static List<ResourceFile> listAllResourceFiles(String resourceDirectory) {
        List<ResourceFile> resourceFiles = new ArrayList<>();
        //...根据后缀(pdf/ppt/word)由工厂方法创建不同的类对象(PdfFile/PPTFile/WordFile)
        resourceFiles.add(new PdfFile("a.pdf"));
        resourceFiles.add(new WordFile("b.word"));
        resourceFiles.add(new PPTFile("c.ppt"));
        return resourceFiles;
      }
    }

在上面例子中，经过层层重构之后的最终代码，就是标准的访问者模式的实现代码。这里，我又总结了一张类图，贴在了下面，你可以对照着前面的例子代码一块儿来看一下。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70][]

# 三、访问者模式的应用场景 #

一般来说，访问者模式针对的是一组类型不同的对象（PdfFile、PPTFile、WordFile）。不过，尽管这组对象的类型是不同的，但是，它们继承相同的父类（ResourceFile）或者实现相同的接口。在不同的应用场景下，我们需要对这组对象进行一系列不相关的业务操作（抽取文本、压缩等），但为了避免不断添加功能导致类（PdfFile、PPTFile、WordFile）不断膨胀，职责越来越不单一，以及避免频繁地添加功能导致的频繁代码修改，我们使用访问者模式，将对象与操作解耦，将这些业务操作抽离出来，定义在独立细分的访问者类（Extractor、Compressor）中。

当然也可以使用策略模式，对于不同的处理方式定义不同的接口，然后接口中提供对于不同类型文件的实现，再使用静态工厂类保存不同文件类型和不同处理方法的映射关系。对于后续扩展的新增文件处理方法，比如composer，按同样的方式实现一组策略，然后修改application代码使用对应的策略。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmcxMzEyNw_size_16_color_FFFFFF_t_70]: /images/20221022/0a93851fe43745a2928a21fadfd3fcc8.png