揭秘设计模式：优雅地为复杂对象结构增添新功能-访问者模式

在软件工程中既强大又有点"烧脑"的设计模式------访问者模式（Visitor Pattern） 。它不像单例或工厂模式那样常见，但在处理复杂对象结构时，它却是保持代码整洁和可扩展性的利器。

什么是访问者模式？

访问者模式是一种行为型设计模式 ，它的核心目的是：在不改变一个复杂对象结构（比如由不同类型对象组成的树形结构）的前提下，为这个结构中的所有元素定义一个全新的操作。

简单来说，就是当你想为一堆不同类型的对象（比如文档中的段落、图片、表格）增加新功能时，你不需要去修改这些对象本身的类，而是创建一个独立的"访问者"来完成这个任务。

不使用访问者模式：痛点何在？

想象一下，你正在开发一个文档编辑器。你的文档由各种元素组成：Paragraph（段落）、Image（图片）、Table（表格）等。现在，你需要为这个文档实现多种功能，比如导出为 XML 格式。

一个常见的、不使用任何设计模式的做法，是创建一个 DocumentExporter 类，并在其中使用类型判断 （instanceof）来处理不同类型的元素。

Java

java 复制代码

import java.util.List;

public class DocumentExporter {
    public void exportToXml(List<DocumentElement> elements) {
        System.out.println("<document>");
        for (DocumentElement element : elements) {
            if (element instanceof Paragraph) {
                Paragraph p = (Paragraph) element;
                System.out.println("  <p>" + p.getText() + "</p>");
            } else if (element instanceof Image) {
                Image i = (Image) element;
                System.out.println("  <img src="" + i.getUrl() + ""/>");
            }
        }
        System.out.println("</document>");
    }
}
// 假设有DocumentElement, Paragraph, Image类，但未实现访问者模式

这段代码看起来能正常工作，但问题很快就会出现：

违反开闭原则 ：如果未来你需要增加一个 Table 元素类型，你必须回到 DocumentExporter 类中，在 exportToXml 方法里添加一个新的 if-else 分支。
代码耦合性高 ：元素的类型判断逻辑（instanceof）和操作逻辑（导出 XML）紧密地耦合在一起。
难以维护 ：随着操作（比如导出 PDF、计算字数）和元素类型（比如 List, Header）的增加，DocumentExporter 类会变得越来越臃肿，if-else 链也越来越长，难以维护和理解。

这就是访问者模式试图解决的核心问题。它将数据结构 （元素）和算法（操作）彻底分离，从而避免了这些维护上的噩梦。

访问者模式的完整实现

它是如何工作的？------ 双分派的魔力

访问者模式最精妙之处在于它利用了双分派（Double Dispatch） 。

当你调用 paragraph.accept(xmlVisitor) 时，发生了两次方法选择：

第一次分派 ：根据 paragraph 对象的运行时类型 （Paragraph），确定调用 Paragraph 类中的 accept 方法。
第二次分派 ：在 Paragraph 的 accept 方法内部，它又调用了 xmlVisitor.visitParagraph(this)。这次是根据 xmlVisitor 对象的运行时类型 （ExportToXMLVisitor）和传入参数 this 的运行时类型 （Paragraph）来确定调用 ExportToXMLVisitor 中针对 Paragraph 的 visit 方法。

通过这种"反向"调用，操作逻辑（在访问者中）和数据结构（在元素中）得到了完美分离。

访问者模式 UML 类图

为了更直观地理解访问者模式中各个角色的关系，下面是对应的 UML 类图。

类图说明：

DocumentElement 和 Visitor 是模式的核心接口，它们定义了元素和访问者的通用行为。
Paragraph 和 Image 是具体的元素，它们都实现了 DocumentElement 接口，并重写了 accept() 方法。
ExportToXMLVisitor 和 RenderToMarkdownVisitor 是具体的访问者，它们实现了 Visitor 接口，并包含了针对不同元素的具体操作逻辑。

下面我们来用 Java 完整实现访问者模式，以解决上述问题。

1. 抽象元素（Element）

DocumentElement.java

java 复制代码

public interface DocumentElement {
    void accept(Visitor visitor);
}

2. 具体元素（Concrete Element）

Paragraph.java

java 复制代码

public class Paragraph implements DocumentElement {
    private String text;

    public Paragraph(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visitParagraph(this);
    }
}

Image.java

java 复制代码

public class Image implements DocumentElement {
    private String url;

    public Image(String url) {
        this.url = url;
    }

    public String getUrl() {
        return url;
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visitImage(this);
    }
}

3. 抽象访问者（Visitor）

Visitor.java

java 复制代码

public interface Visitor {
    void visitParagraph(Paragraph paragraph);
    void visitImage(Image image);
}

4. 具体访问者（Concrete Visitor）

ExportToXMLVisitor.java

java 复制代码

public class ExportToXMLVisitor implements Visitor {

    @Override
    public void visitParagraph(Paragraph paragraph) {
        System.out.println("  <p>" + paragraph.getText() + "</p>");
    }

    @Override
    public void visitImage(Image image) {
        System.out.println("  <img src="" + image.getUrl() + ""/>");
    }
}

RenderToMarkdownVisitor.java

java 复制代码

public class RenderToMarkdownVisitor implements Visitor {

    @Override
    public void visitParagraph(Paragraph paragraph) {
        System.out.println(paragraph.getText());
    }

    @Override
    public void visitImage(Image image) {
        System.out.println("![](" + image.getUrl() + ")");
    }
}

5. 客户端代码 (Client)

java 复制代码

import java.util.ArrayList;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        List<DocumentElement> document = new ArrayList<>();
        document.add(new Paragraph("Hello, Visitor Pattern!"));
        document.add(new Image("https://example.com/logo.png"));
        document.add(new Paragraph("This is a second paragraph."));

        System.out.println("--- Exporting to XML ---");
        Visitor xmlVisitor = new ExportToXMLVisitor();
        for (DocumentElement element : document) {
            element.accept(xmlVisitor);
        }

        System.out.println("\n--- Rendering to Markdown ---");
        Visitor markdownVisitor = new RenderToMarkdownVisitor();
        for (DocumentElement element : document) {
            element.accept(markdownVisitor);
        }
    }
}

运行结果：

less 复制代码

--- Exporting to XML ---
  <p>Hello, Visitor Pattern!</p>
  <img src="https://example.com/logo.png"/>
  <p>This is a second paragraph.</p>

--- Rendering to Markdown ---
Hello, Visitor Pattern!
![](https://example.com/logo.png)
This is a second paragraph.

通过这种方式，我们成功地将数据结构 （元素）和算法（访问者）完全分离。当我们想要增加一个新的操作（例如导出为 PDF），我们只需要创建一个新的 ExportToPDFVisitor，而无需修改任何已有的元素类。

访问者模式的优缺点

优点：

增加新操作容易（开闭原则） ：当你需要为对象结构添加一个新功能时，只需创建一个新的具体访问者类，而无需修改任何已有的元素类。
职责分离：将复杂的算法逻辑从对象结构中抽离，使元素类只关注数据和结构，访问者类只关注算法。
集中算法：与特定元素相关的操作逻辑被集中在访问者类中，更易于管理和维护。

缺点：

增加新元素类型困难 ：这是访问者模式最大的缺点。每当你需要增加一个新的元素类型时（例如，从 Paragraph 和 Image 增加 Table），你不仅要创建新的元素类，还必须修改所有已有的访问者接口及其所有实现类，这会带来巨大的维护成本，违反了开闭原则。
复杂性高：模式本身涉及多个接口和类，理解和实现起来相对复杂。
破坏封装性：为了让访问者能够访问元素内部的数据，元素有时需要暴露其内部状态，可能破坏了封装性。

适用场景与框架中的应用

访问者模式最适合对象结构稳定，但操作多变的场景，比如：

编译器和解释器：

这是访问者模式最经典的用例。在处理**抽象语法树（AST）**时，访问者模式被广泛使用。AST 由不同类型的节点（如表达式、变量声明、函数定义）组成，这些节点的类型是相对固定的。但编译器需要对这棵树执行多种操作：

语法检查：用一个访问者来遍历 AST，检查语法错误。
代码生成：用另一个访问者将 AST 转换成机器码或字节码。
代码优化：用第三个访问者来简化 AST 结构，提高性能。

每增加一个操作，我们只需要创建一个新的访问者类，而无需修改 AST 节点的代码。

框架应用：Java NIO FileVisitor

在 Java 中，java.nio.file.FileVisitor 接口是访问者模式的一个典型应用。它被用于遍历文件目录结构。

当你想要遍历一个目录，并对其中的文件和子目录执行不同操作时，你可以实现 FileVisitor 接口，它提供了像 visitFile、preVisitDirectory、postVisitDirectory 等方法。你只需将你的逻辑写在这些 visit 方法里，然后调用 Files.walkFileTree 方法，Java 就会自动帮你完成遍历，并在遍历到不同类型的文件或目录时，调用你实现的相应 visit 方法。这使得文件遍历操作和文件系统结构完全解耦。

GUI 工具箱：

图形界面中的组件（如按钮、文本框、下拉菜单）类型通常是固定的。但我们可能需要为这些组件提供各种操作，比如渲染、序列化或属性检查。每个操作都可以设计成一个访问者，去访问不同的 GUI 组件，实现相应的逻辑。

总结：

访问者模式是一个权衡的艺术。它在牺牲"新增元素类型"的灵活性的前提下，换取了"新增操作"的极大便利。在编译器、解释器、大型框架（如 Java NIO、Spring 某些内部机制）、文件系统遍历等领域，访问者模式发挥着至关重要的作用。