HelloWorld

HelloWorld 访问者模式教程

作者：

user

在

访问者模式（Visitor）是一种让你把对一组对象结构中各元素执行的操作封装到独立类中的设计方式；用它可以在不修改这些元素类的前提下，新增操作。它的核心在于“双重分派”：元素接受访问者并回调访问者的相应方法，从而把类型判断交给编译期分派来处理。本文用一个HelloWorld风格的例子，逐步讲清为什么需要它、怎么实现、常见变体、以及实用的重构与测试建议，带着代码和实践要点，让你能马上上手。

HelloWorld 访问者模式教程

先把问题说清楚：为什么要用访问者模式？

想象一个场景：你有一组不同类型的对象（比如：文本节点、图片节点、链接节点），现在需要对它们做多种不同的操作（渲染、导出为HTML、统计字数、生成索引等）。如果把这些操作都写到节点类里，类会臃肿且修改频繁；而如果把操作都写在外部，又经常需要判断类型并做分支，代码会变成一堆if/instanceof逻辑。

访问者模式的思想是把“操作”封装成访问者对象（Visitor），每个元素（Element）实现一个 accept(Visitor) 方法，接收访问者并把自己传给访问者的相应 visit 方法。这样你可以很容易地新增操作（只需添加新的访问者类），而不必修改元素类。

模式结构（参与者）

  • Visitor：声明一组 visitXxx(ElementXxx) 方法，每种元素对应一个方法。
  • ConcreteVisitor：实现 Visitor，定义具体的操作。
  • Element：声明 accept(Visitor) 方法。
  • ConcreteElement：实现 accept，通常是 visitor.visitConcreteElement(this)。
  • ObjectStructure：持有元素集合，提供遍历并让访问者访问所有元素的机制。

“双重分派”是什么

Java等语言只有单分派（方法根据对象的运行时类型决定），但访问者模式通过 accept 方法实现了所谓的“双重分派”：第一级分派是元素对象选择 accept 的实现，第二级分派是访问者对象选择合适的 visit 方法，最终的组合让访问者根据元素的具体类型执行正确的逻辑。

HelloWorld 示例（Java）——一步步实现

下面用最小 HelloWorld 风格示例，把概念落到代码。目的是清楚展示结构而非复杂业务。

1) 先定义元素接口和两个具体元素

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

public class HelloElement implements Element {
    private String msg = "Hello";
    public String getMsg() { return msg; }
    @Override
    public void accept(Visitor visitor) {
        visitor.visitHello(this);
    }
}

public class WorldElement implements Element {
    private String msg = "World";
    public String getMsg() { return msg; }
    @Override
    public void accept(Visitor visitor) {
        visitor.visitWorld(this);
    }
}

2) 定义访问者接口与具体访问者

public interface Visitor {
    void visitHello(HelloElement e);
    void visitWorld(WorldElement e);
}

public class PrintVisitor implements Visitor {
    @Override
    public void visitHello(HelloElement e) {
        System.out.print(e.getMsg());
    }
    @Override
    public void visitWorld(WorldElement e) {
        System.out.println(" " + e.getMsg());
    }
}

3) 对象结构与运行

public class Structure {
    private List elements = new ArrayList<>();
    public void add(Element e) { elements.add(e); }
    public void accept(Visitor visitor) {
        for (Element e : elements) e.accept(visitor);
    }
}

// main
Structure s = new Structure();
s.add(new HelloElement());
s.add(new WorldElement());
s.accept(new PrintVisitor()); // 输出 Hello World

这段代码里发生了什么（用费曼法解释）

  • 你把具体的“操作”（打印）从元素类中抽出来，放进了 PrintVisitor。
  • 元素只负责“把自己交给访问者”：HelloElement.accept 调用 visitor.visitHello(this)，WorldElement 相应调用 visitWorld。
  • 访问者根据元素类型执行不同代码：这是第二次“选择”发生的位置，第一次是元素自己把请求转发给访问者的哪个方法。

常见用途与适用场景

  • 当系统有一组结构化对象（例如 AST、DOM、复合对象）且这些对象类型固定，但对它们的操作经常扩展时，适合使用访问者。
  • 当需要对元素进行跨切面的复杂遍历与处理（比如代码分析、编译器阶段、文档导出）时很合适。
  • 不合适的场景：元素层次会频繁变化（新增元素类），因为每次新增元素都需要修改 Visitor 接口及其所有实现。

优缺点速览

优点 新增操作只需添加新的 Visitor 实现；可把复杂操作集中到访问者里，便于管理和重用。
缺点 扩展新的元素类型代价高，需要修改所有已有 Visitor；破坏封装可能暴露过多内部状态给访问者。

变体与现实中的折中

在现实项目里，纯粹的访问者模式有时显得僵硬。因此常见折中做法包括：

  • 默认方法（Java 8+）：在 Visitor 接口提供默认实现，减少新加元素时对已有 Visitor 的改动。
  • 反射/注解：用反射寻找匹配的 visit 方法，减少接口源码改动，但牺牲类型安全与性能。
  • 函数式替代：把操作作为函数对象传给元素（类似策略模式），在元素多且操作少时更灵活。

反射实现示例（简要）

下面是一个思路：访问者只有一个 visit(Object) 方法，内部通过反射调用具体 visitXxx。优点是向后兼容，缺点是复杂且容易出错，不建议频繁使用。

如何把已有代码重构为访问者模式（步骤建议）

  • 识别目标：找出对多种元素做类似操作且包含大量类型分支的代码。
  • 抽取操作：把分支逻辑提取为独立的 Visitor 接口方法草稿。
  • 实现 accept：在每个 Element 中实现 accept(Visitor) 并调用 visitor.visitXxx(this)。
  • 迁移逻辑：把原来分支内的代码迁移到具体 Visitor，实现测试确保行为不变。
  • 添加测试：对每个元素-访问者组合写单元测试，保证回归安全。

测试与调试小技巧

  • 为每个 ConcreteVisitor 写独立单元测试，覆盖所有 visitXxx 方法。
  • 对 ObjectStructure 的遍历也要测试：确保元素顺序和访问次数正确。
  • 当使用反射或默认方法时，多写集成测试，防止运行时缺方法或调用错误。

性能与内存考虑

访问者模式本身不会导致明显的性能问题，但如果元素很多且访问者复杂，频繁的虚方法调用和对象创建会产生开销。以下是可行的优化方向：

  • 重用访问者实例，避免不必要的分配。
  • 如果性能敏感，避免反射实现，优先使用静态分派（显式方法）。
  • 在遍历大型结构时考虑迭代深度与栈消耗，必要时改用显式栈遍历。

常见误区与反模式

  • 把访问者当成万能工具：访问者适合“操作频繁变动，结构稳定”的场景，若元素类型常变则不合适。
  • 访客过大：把所有逻辑塞进一个 ConcreteVisitor，会降低可维护性，建议按职责拆分。
  • 破坏封装：让访问者直接读取元素内部大量字段，会导致元素内部变化影响众多访问者，优先提供必要的访问接口。

与其他模式的对比

与策略模式 策略是把算法封装为可互换的对象；访问者是把针对对象结构的操作封装。策略更关注单对象的算法替换，访问者更适合跨元素的操作。
与组合模式 组合处理树形结构，访问者常用来对组合结构做统一操作，它们经常一起出现（Composite + Visitor）。

实际案例与参考

访问者模式在编译器构建（AST 遍历）、文档处理（DOM 变换）、序列化/反序列化、数据分析管道等场景中应用广泛。可以参考的经典资料：Design Patterns（Gamma等），以及相关编译器实现论文。

遇到困难怎么办（实践小贴士）

  • 如果新增元素频繁，考虑用组合策略或把公共行为放入超类，减少 Visitor 接口变化。
  • 当访问者需要访问很多内部状态时，先为元素提供受控的访问方法（getters 或 acceptContext），以免暴露实现细节。
  • 编码时用清晰的命名（visitXxx），并把访问者分包管理，便于查找和维护。

总结性的操作清单（上手指南）

  • 步骤一：定义 Element 接口并实现 accept。
  • 步骤二：定义 Visitor 接口，列出所有 visit 方法。
  • 步骤三：实现至少一个 ConcreteVisitor，实现具体操作。
  • 步骤四：用 ObjectStructure 遍历并执行 visitor。
  • 步骤五：补充单元测试，逐步替换原有分支代码。

好了，代码、原理、优劣、变体和落地建议都给到这儿了。你可以基于示例先在一个小模块里试试，把打印替换为更实际的操作（比如导出、校验、统计），会比只读理论来得更容易理解。就像我当年第一次把 Visitor 用在 AST 上，从一堆 if/instanceof 变成清爽的访问者集合，明显更能把注意力放在业务逻辑上——这是它最吸引人的地方。

更多文章