访问者模式：操作与数据结构分离

FreeGuideOnline 最新 2026-06-18

访问者模式：操作与数据结构分离

什么是访问者模式？

访问者模式是一种行为设计模式，它能将算法与对象结构分离开来。简单来说，就是让你在不修改已有类的前提下，为这些类增加新的操作。

举个现实中的例子：你的电脑由 CPU、内存、硬盘等零件组成，这些零件本身结构稳定（不常改变）。但你可以用不同的“访问者”来对它们做不同的事情——修理师傅检查故障、评测人员测试性能、清洁人员除尘……这些操作都不同，但不需要改变电脑零件的内部结构。在软件中，访问者模式让你能够添加新的行为，而无需改动被操作的元素类。

为什么需要分离操作与数据结构？

面向对象设计中，我们通常将数据和使用数据的操作封装在同一个类里。但在某些系统中，数据结构相对稳定，而需要施加在其上的操作却频繁变化。如果每新增一种操作就修改原来的类，不仅违反开闭原则（对扩展开放、对修改封闭），还会让类变得臃肿，职责不单一。

访问者模式正是为了解决这一问题而诞生的。它将“操作”提取到独立的访问者对象中，把“数据结构”保留在元素类内部。当你需要新操作时，只需新增一个访问者，而无需改动已有的元素类。这就实现了操作与数据结构分离，让系统更灵活，也更易于维护。

模式结构与参与者

访问者模式通常包含五个关键角色：

  • Visitor（抽象访问者）：为每一个具体元素类声明一个 visit 方法，方法名和参数标识了要访问的具体元素。
  • ConcreteVisitor（具体访问者）：实现抽象访问者声明的各个 visit 方法，定义对每种元素的具体操作。
  • Element（抽象元素）：定义一个 accept 方法，该方法接收一个访问者对象。
  • ConcreteElement（具体元素）：实现 accept 方法，在方法中调用访问者的 visit 方法，并将自身传递过去。
  • ObjectStructure（对象结构）：可以是集合或复合结构，用于存放元素对象，并提供遍历元素的方法让访问者得以访问所有元素。

核心交互流程如下：

  1. 客户端创建访问者对象。
  2. 对象结构遍历元素集合，对每个元素调用 accept(visitor)。
  3. 元素在其 accept 方法中将自身传递给访问者的 visit 方法：visitor.visit(this)。
  4. 访问者根据元素的具体类型执行对应的操作。

之所以把元素自身传给 visit，而不是在访问者里调用元素的方法，是为了利用双重分派机制——第一次分派由 accept 方法将调用委派给访问者；第二次分派由访问者的重载方法决定执行哪一种针对该具体元素的操作。这样就不需要在访问者中做 instanceof 判断，从而遵循了开闭原则。

代码示例（Python）

假设我们有一个电脑组件结构，包含 CPU 和 Memory 两类元件，现在希望用访问者模式实现不同操作。

from abc import ABC, abstractmethod

# 抽象访问者
class ComputerPartVisitor(ABC):
    @abstractmethod
    def visit_cpu(self, cpu):
        pass

    @abstractmethod
    def visit_memory(self, memory):
        pass

# 抽象元素
class ComputerPart(ABC):
    @abstractmethod
    def accept(self, visitor: ComputerPartVisitor):
        pass

# 具体元素：CPU
class CPU(ComputerPart):
    def __init__(self, model, cores):
        self.model = model
        self.cores = cores

    def accept(self, visitor):
        visitor.visit_cpu(self)

# 具体元素：内存
class Memory(ComputerPart):
    def __init__(self, size):
        self.size = size

    def accept(self, visitor):
        visitor.visit_memory(self)

# 具体访问者：显示信息
class PrintInfoVisitor(ComputerPartVisitor):
    def visit_cpu(self, cpu):
        print(f"CPU: {cpu.model}, {cpu.cores} cores")

    def visit_memory(self, memory):
        print(f"Memory: {memory.size} GB")

# 具体访问者：诊断检查
class DiagnoseVisitor(ComputerPartVisitor):
    def visit_cpu(self, cpu):
        print("Checking CPU temperature and frequency...")

    def visit_memory(self, memory):
        print("Running memory diagnostic test...")

# 对象结构
class Computer:
    def __init__(self):
        self.parts = []

    def add_part(self, part):
        self.parts.append(part)

    def accept(self, visitor):
        for part in self.parts:
            part.accept(visitor)

# 客户端使用
if __name__ == "__main__":
    computer = Computer()
    computer.add_part(CPU("Intel i7", 8))
    computer.add_part(Memory(16))

    print("=== 打印信息 ===")
    computer.accept(PrintInfoVisitor())

    print("\n=== 运行诊断 ===")
    computer.accept(DiagnoseVisitor())

运行结果：

=== 打印信息 ===
CPU: Intel i7, 8 cores
Memory: 16 GB

=== 运行诊断 ===
Checking CPU temperature and frequency...
Running memory diagnostic test...

如果未来需要添加新的操作（如序列化、价格计算），只需实现一个新的 ComputerPartVisitor 子类，不用修改 CPU、Memory 这些已有类。

优缺点与适用场景

优点

  • 拓展性好：增加新操作只需要新增访问者，无需改动现有元素类，完全遵循开闭原则。
  • 职责清晰：将同一个操作的逻辑集中在一个访问者类中，避免分散到各个元素类里，使得代码内聚性更高。
  • 复用性强：同一套元素结构可以被多个不同的访问者复用，每个访问者只关心自己的逻辑。
  • 便于维护：相关操作放在一起，修改或升级某类行为时不必在多个类间跳转。

缺点

  • 元素变更困难：如果元素类需要增加新的具体元素（例如新增 GPU 类），那么抽象访问者及其所有具体访问者都必须修改添加对应的 visit 方法，违背开闭原则。
  • 破坏封装性：访问者可能需要访问元素的内部细节才能完成操作，导致元素暴露不想公开的状态和方法。
  • 类数量增加：每增加一种操作，就要创建一个新的访问者类，系统复杂度随之上升。
  • 双重分派理解成本：对初学者来说，双重分派的调用机制较为抽象，上手有一定门槛。

何时使用访问者模式

  • 当对象结构包含较多类型，且各类上的操作可独立变化时。
  • 当对象结构相对稳定，但经常需要定义新的操作时。
  • 当你希望将相关行为提取到单一类中，而不是分散在数据结构里时。
  • 当元素类的层次结构很少变化，而你又不愿意为了添加一种小功能去“污染”这些基类时。

典型的应用场景包括：

  • 编译器/解释器：抽象语法树（AST）的结构稳定，但编译、类型检查、代码生成、格式化打印等操作各不相同，适合用访问者模式。
  • 文档对象模型（DOM）：XML/HTML 的节点结构固定，但导出、验证、渲染等操作千变万化。
  • 符号表处理、报表生成、UI 组件统计等。

总结

访问者模式通过将操作抽取到独立的访问者对象，达成了操作与数据结构分离的核心目标。它在数据结构稳定、操作多变的场景下尤为有用，可以让你在不触碰已有类的前提下自由扩展功能。同时，必须注意该模式的固有局限：元素类的变更成本很高，因此适用于元素层次结构相对固定的系统。理解双重分派是掌握访问者模式的关键，它使得类型安全并且符合开闭原则的行为添加成为可能。在实际开发中，当面对“为多个不同结构的类添加一组功能，又不想修改它们”的需求时，访问者模式会是一个优雅且强大的选择。