关于访客模式的问题（Java 示例）

Question

我只是想了解使用访问者模式的主要好处。

这是一个 Java 实现示例，

///////////////////////////////////
// Interfaces
interface MamalVisitor {
    void visit(Mammal mammal);
}
interface MammalVisitable {
    public void accept(MamalVisitor visitor);
}
interface Mammal extends MammalVisitable {
    public int getLegsNumber();
}
///////////////////////////////////


///////////////////////////////////
// Model
class Human implements Mammal {
    @Override
    public void accept(MamalVisitor visitor) {  visitor.visit(this);  }
    @Override
    public int getLegsNumber() { return 2; }
}
//PIRATE HAS A WOOD LEG
class Pirate extends Human { 
    @Override
    public int getLegsNumber() { return 1; }
    public int getWoodLegNumber() { return 1; }
}
class Dog implements Mammal {
    @Override
    public void accept(MamalVisitor visitor) {  visitor.visit(this);  }
    @Override
    public int getLegsNumber() { return 4; }
}
///////////////////////////////////


///////////////////////////////////
class LegCounterVisitor implements MamalVisitor {
    private int legNumber = 0;
    @Override
    public void visit(Mammal mammal) {   legNumber += mammal.getLegsNumber();   }
    public int getLegNumber() { return legNumber; }
}
class WoodLegCounterVisitor implements MamalVisitor {
    private int woodLegNumber = 0;
    @Override
    public void visit(Mammal mammal) {   
        // perhaps bad but i'm lazy
        if ( mammal instanceof Pirate ) {
            woodLegNumber += ((Pirate) mammal).getWoodLegNumber();
        }
    }
    public int getWoodLegNumber() { return woodLegNumber; }
}
///////////////////////////////////



///////////////////////////////////
public class Main {
    public static void main(String[] args) {
        // Create a list with 9 mammal legs and 3 pirate woodlegs
        List<Mammal> mammalList = Arrays.asList(
                new Pirate(),
                new Dog(),
                new Human(),
                new Pirate(),
                new Pirate()
        );

        ///////////////////////////////////
        // The visitor method
        LegCounterVisitor legCounterVisitor = new LegCounterVisitor();
        WoodLegCounterVisitor woodLegCounterVisitor = new WoodLegCounterVisitor();
        for ( Mammal mammal : mammalList ) {
            mammal.accept(legCounterVisitor);
            mammal.accept(woodLegCounterVisitor);
            // why not also using:
            // legCounterVisitor.visit(mammal);
            // woodLegCounterVisitor.visit(mammal);
        }
        System.out.println("Number of legs:" + legCounterVisitor.getLegNumber());
        System.out.println("Number of wood legs:" + woodLegCounterVisitor.getWoodLegNumber());

        ///////////////////////////////////
        // The standart method
        int legNumber = 0;
        int woodLegNumber = 0;
        for ( Mammal mammal : mammalList ) {
            legNumber += mammal.getLegsNumber();
            // perhaps bad but i'm lazy
            if ( mammal instanceof Pirate ) {
                woodLegNumber += ((Pirate) mammal).getWoodLegNumber();
            }
        }
        System.out.println("Number of legs:" + legNumber);
        System.out.println("Number of wood legs:" + woodLegNumber);
    }
}
///////////////////////////////////

我只是想知道在这种情况下使用这种模式的主要优点是什么。我们还可以迭代集合并获得几乎相同的东西，只不过我们不必处理新接口并向模型添加样板代码......

使用 Apache Commons 或函数式语言，经典方法似乎可以做到一些映射/减少操作（映射到腿号并通过加法减少），这很容易...

我也想知道为什么我们使用

        mammal.accept(legCounterVisitor);
        mammal.accept(woodLegCounterVisitor);

而不是

        legCounterVisitor.visit(mammal);
        woodLegCounterVisitor.visit(mammal);

第二个选项似乎删除了模型部分上的accept(...)方法。

在我发现的许多示例中，它们似乎没有使用模型对象的通用接口。我添加它是因为这样我只需要添加一个访问（哺乳动物）方法，而不是为每个哺乳动物实现一个方法。 让我的所有对象都实现 Mammal 好吗？ （我想有时无论如何都是不可能的）。仍然是这样的访客模式吗？

所以我的问题是： - 您认为我的例子中使用访客有什么优势吗？ - 如果没有，您能为访问者提供一些具体的用例吗？ - 访问者在函数式编程语言中有用吗

我发现与此模式相关的唯一示例是漂亮打印机的情况，其中您将访问者状态中的偏移量保存在访问不同节点期间使用的偏移量（用于显示 XML 树）示例）

Answer 1

访问者模式只是双重调度。

我不确定我是否同意您对访客的实施。我会实现这样的东西：

interface MammalVisitor {
    void visit(Pirate pirate);
    void visit(Human human);
    void visit(Dog dog);
}

// Basic visitor provides no-op behaviour for everything.
abstract class MammalAdapter implements MammalVisitor {
    void visit(Pirate pirate) {};
    void visit(Human human) {};
    void visit(Dog dog) {};
}

然后实现会变得更清晰：

// We only want to provide specific behaviour for pirates
class WoodLegCounterVisitor extends MammalAdaptor {
    private int woodLegNumber = 0;
    @Override
    public void visit(Pirate pirate) {   
        woodLegNumber += pirate.getWoodLegNumber();
    }

    public int getWoodLegNumber() { return woodLegNumber; }
}

在回答您的实际问题时，使用访问者的主要优点是避免需要进行“instanceof”检查。它使您能够将处理层次结构的逻辑分离到单独的类中。它还使您能够在不更改原始类的情况下添加新行为。

Answer 2

访客模式是一个奇特的 switch case / 模式匹配系统，可促进 图遍历。

由于典型的函数式语言提供模式匹配和遍历图形的有效方法，因此兴趣更加有限。

即使在 JAVA 中，使用 instanceof 或使用 enum，访问者也更像是一种奇特的执行方式，而不是通用解决方案，因为许多算法不能很好地适应它。

Answer 3

访问者模式的目的是分离对象结构（在您的情况下，哺乳动物）来自算法（在您的例子中，是计数器腿计数器算法）。

整个想法是你的对象（主要是java，JavaBeans）根本不改变它的结构，而只是一个新的 虚函数的引入是为了引入新的算法。

与 Jeff Foster 的实现不同，我们可以使用泛型来简化代码。这为您的访客带来了特殊性，例如：

public interface MammalVisitor<T extends Mammal> {

    public void visit(T mammal);
}

public class LegCounterVisitor implements MamalVisitor<Human> {
    private int legNumber = 0;
    @Override
    public void visit(Human mammal) {   legNumber += mammal.getLegsNumber();   }
    public int getLegNumber() { return legNumber; }
}

public class WoodLegCounterVisitor implements MamalVisitor<Pirate> {
    private int legNumber = 0;
    @Override
    public void visit(Pirate mammal) {legNumber += mammal.getWoodLegNumber();   }
    public int getLegNumber() { return legNumber; }
}

Answer 4

似乎上面的所有答案都在数据结构/算法层面提供了详细的解释，但是仍然缺乏高层/概念性的理解。而缺乏概念上的理解可能会导致误解，认为访问者模式只不过是一种花哨的风格。

恕我直言，让我们考虑一下域实体之间的所有交互都可以简化为一对一的交互。访问者模式适用于这样的情况：一个实体保持稳定的类型，而另一个实体具有多个专业化并且正在动态扩展。在这种情况下，稳定实体可以建模为元素（或可访问），动态实体可以建模为访问者。

有关双重调度的更详细说明，请考虑以下假设：Class A 和 Class B 之间存在交互，其中 m 和 >n 个专业化，分别。我们必须为每个组合实现所有m*n 方法。我们假设 m n，因此我们将 A 类 表示为 Element，将 B 类 表示为 Visitor。

• 首先，我们需要设计一条分支为 m*n 条路径的路线。 Element.accept 方法进行第一次选择，而 Visitor.visit 方法进行第二次选择。
• 很明显，Element 应该更稳定（意味着数量更少），就像它位于决策树中的更高级别一样。
• 在这个三层树中，顶层代表起始点，第二层对应每个 Element 专门化，第三层代表每个 下的多个 Visitor元素 实现。树的叶子代表相应的Element 和Visitor 的方法。
• 要向 Element 添加新的专门化，每个 Visitor 必须在不同的代码文件中实现新方法，从而导致低内聚性。相反，添加一个新的Visitor只需要在单个文件中实现所有方法，而其他文件不变，这是高度解耦的。

我相信，在这些上下文之外，很难判断任何交付是否合理的访问者模式，因为任何交互都可以实现为 A.accept 和 B.visit。

代码设计的一个关键区别是访问者始终知道可访问对象的确切类型，但反之则不然。

希望这有帮助。