您什么时候决定为您的对象使用访问者？

Question

我一直认为一个对象需要数据和消息来对其进行操作。什么时候你需要一个对象外部的方法？您会遵循什么经验法则来接待访客？这是假设您完全控制对象图。

Answer 1

我一直认为一个对象需要
数据和对其采取行动的消息。
你什么时候想要一个方法
物体外在的？什么规则
有访客时您会遵循拇指吗？
这是假设你有完整的
对象图的控制。

有时在一个类中定义特定对象的所有行为并不方便。例如，在 Java 中，如果您的模块需要在最初在另一个模块中定义的一堆类中实现方法 toXml ，那么它会很复杂，因为您无法在其他地方编写 toXml与原始类文件相比，这意味着您无法在不更改现有源的情况下扩展系统（在 Smalltalk 或其他语言中，您可以将不与特定文件绑定的扩展方法分组）。

更一般地说，静态类型语言中存在以下能力之间的紧张关系：(1) 向现有数据类型添加新函数，以及 (2) 添加支持相同函数的新数据类型实现——这称为 表达式问题 (维基百科页面）。

面向对象语言在第 2 点上表现出色。如果您有接口，则可以安全、轻松地添加新的实现。函数式语言在第 1 点上表现出色。它们依赖于模式匹配/临时多态性/重载，因此您可以轻松地向现有类型添加新函数。

访问者模式是支持面向对象设计中的第 1 点的一种方式：您可以轻松地以类型安全的方式使用新行为来扩展系统（如果您这样做，情况就不会是这样）与 if-else-instanceof 进行手动模式匹配，因为如果未涵盖案例，该语言永远不会警告您）。

当存在一组固定的已知类型时，通常会使用访问者，我认为这就是您所说的“对象图的完全控制”的意思。示例包括解析器中的标记、具有各种类型节点的树以及类似的情况。

总而言之，我想说你的分析是正确的:)

PS：访问者模式与复合模式配合得很好，但它们单独也很有用

Answer 2

当对相当复杂的数据结构的所有元素应用操作时（例如，并行遍历元素，或遍历高度互连的数据结构）或实现双分派，访问者模式特别有用。如果要按顺序处理元素并且不需要双重分派，那么实现自定义 Iterable 和 Iterator 通常是更好的选择，特别是因为它更适合其他 API。

Answer 3

有时这只是组织问题。如果您有 n 种对象（即：类）和 m 种操作（即：方法），您是否希望将 n * m 类/方法对按类或方法分组？大多数面向对象语言强烈倾向于按类对事物进行分组，但在某些情况下按操作进行组织更有意义。例如，在对象图的多阶段处理中，例如在编译器中，将每个阶段（即：操作）视为一个单元通常比考虑特定类型可能发生的所有操作更有用的节点。

访问者模式的一个常见用例不仅仅是严格组织，而是打破不需要的依赖关系。例如，通常不希望您的“数据”对象依赖于表示层，特别是当您想象可能有多个表示层时。通过使用访问者模式，表示层的详细信息存在于访问者对象中，而不是存在于数据对象的方法中。数据对象本身只知道抽象访问者接口。

Answer 4

当我发现我想将一个有状态的方法放到 Entity/DataObject/BusinessObject 上时，我经常使用它，但我真的不想将这种有状态引入到我的对象中。有状态访问者可以完成这项工作，或者从我的无状态数据对象生成有状态执行器对象的集合。当工作的处理将被外包给执行程序线程时特别有用，许多有状态访问者/工作人员可以引用同一组无状态对象。

Answer 5

对我来说，使用访问者模式的唯一原因是当我需要对树/特里树等图形数据结构执行双重调度时。

Answer 6

当您遇到以下问题时：

<块引用>

需要对异构聚合结构中的节点对象执行许多不同且不相关的操作。您希望避免这些操作“污染”节点类。而且，您不希望在执行所需的操作之前查询每个节点的类型并将指针转换为正确的类型。

然后，您可以使用具有以下意图之一的访问者模式：

• 表示要对对象结构的元素执行的操作。
• 定义一个新操作，而不更改其操作的元素的类。
• 恢复丢失类型信息的经典技术。
• 根据两个对象的类型做正确的事情。
• 双重调度

（来自 http://sourcemaking.com/design_patterns/visitor）

Answer 7

当您需要根据对象类型（在类层次结构中）改变行为并且可以根据对象提供的公共接口来定义该行为时，访问者模式最有用。该行为不是该对象固有的，并且不会从对象中受益或不需要对象的封装。

我发现访问者通常会自然而然地出现对象的图形/树，其中每个节点都是类层次结构的一部分。为了允许客户端遍历图/树并以统一的方式处理任何每种类型的节点，访问者模式实际上是最简单的替代方案。

例如，考虑一个 XML DOM - 节点是基类，元素、属性和其他类型的节点定义类层次结构。

想象一下需求是将 DOM 作为 JSON 输出。该行为不是 Node 固有的 - 如果是的话，我们必须向 Node 添加方法来处理客户端可能需要的所有格式（toJSON()、toASN1()、toFastInfoSet() 等）我们甚至可以认为 toXML() 不属于那里，尽管这可能是为了方便而提供的，因为它将是大多数客户端都使用它，并且在概念上“更接近”DOM，因此为了方便起见，可以将 toXML 内置于 Node 中 - 尽管它不是必须的，并且可以像所有其他格式一样进行处理。

由于 Node 及其子类使其状态完全可用作方法，因此我们拥有外部所需的所有信息，以便能够将 DOM 转换为某种输出格式。我们可以使用 Visitor 接口，在 Node 上使用抽象 accept() 方法，并在每个子类中实现，而不是将输出方法放在 Node 对象上。

每个访问者方法的实现处理每个节点类型的格式化。它可以做到这一点，因为所需的所有状态都可以从每个节点类型的方法中获得。

通过使用访问者，我们打开了实现任何所需输出格式的大门，而无需为每个 Node 类增加该功能的负担。

Answer 8

当您完全了解实现接口的类时，我总是建议使用访问者。通过这种方式，您将不会执行任何不那么漂亮的 instanceof 调用，并且代码变得更具可读性。此外，一旦实现了访问者，就可以在现在和将来的许多地方重复使用。

Answer 9

访问者模式是双重调度问题的一个非常自然的解决方案。双重调度问题是动态调度问题的一个子集，它源于这样一个事实：方法重载是在编译时静态确定的，这与虚拟（重写）方法不同，后者是在运行时确定的。

考虑这种情况：

public class CarOperations {
  void doCollision(Car car){}
  void doCollision(Bmw car){}
}

public class Car {
  public void doVroom(){}
}      

public class Bmw extends Car {
  public void doVroom(){}
}

public static void Main() {
    Car bmw = new Bmw();

    bmw.doVroom(); //calls Bmw.doVroom() - single dispatch, works out that car is actually Bmw at runtime.

    CarOperations carops = new CarOperations();
    carops.doCollision(bmw); //calls CarOperations.doCollision(Car car) because compiler chose doCollision overload based on the declared type of bmw variable
}

下面的代码来自 我之前的回答 并翻译成 Java。该问题与上面的示例有些不同，但展示了访问者模式的本质。

//This is the car operations interface. It knows about all the different kinds of cars it supports
//and is statically typed to accept only certain ICar subclasses as parameters
public interface CarVisitor {
   void StickAccelerator(Toyota car);
   void ChargeCreditCardEveryTimeCigaretteLighterIsUsed(Bmw car);
}

//Car interface, a car specific operation is invoked by calling PerformOperation  
public interface Car {

   public string getMake();
   public void setMake(string make);

   public void performOperation(CarVisitor visitor);
}

public class Toyota implements Car {
   private string make;
   public string getMake() {return this.make;}
   public void setMake(string make) {this.make = make;}

   public void performOperation(CarVisitor visitor) {
     visitor.StickAccelerator(this);
   }
}

public class Bmw implements Car{
   private string make;
   public string getMake() {return this.make;}
   public void setMake(string make) {this.make = make;}

   public void performOperation(ICarVisitor visitor) {
     visitor.ChargeCreditCardEveryTimeCigaretteLighterIsUsed(this);
   }
}

public class Program {
  public static void Main() {
    Car car = carDealer.getCarByPlateNumber("4SHIZL");
    CarVisitor visitor = new SomeCarVisitor();
    car.performOperation(visitor);
  }
}