为什么访问者负责枚举访问者模式中的子项？

Question

根据我发现的代码，访问者似乎需要了解所访问对象的结构并调用所需的子对象。 在某些情况下，即使访问的类被修改，访问者仍希望继续工作，这似乎有点笨拙。

我想真正的问题是：他们的枚举是由访问的代码而不是访问者代码完成的吗？

Answer 1

访问者对象需要知道它访问的事物的结构。 不过没关系。 您应该为访问者知道如何访问的每种类型的事物编写专门的访问操作。 这使得访问者可以决定自己真正想要访问的程度以及访问顺序。

假设你有一棵树。 一个访问者可能会进行前序遍历，一个访问者可能会进行中序遍历，而另一位访问者可能只对叶节点进行操作。 访问者类可以完成所有这些事情，而不需要对树类进行任何更改。

访问者知道该结构，但这并不一定意味着访问者执行的操作知道所有结构。 您可以将访问者与命令组合起来。命令。 为访问者对象提供一个命令对象，访问者将在其访问的每个对象上调用该命令。

如果您想要进行简单的操作并让集合为您提供要操作的每个项目，那么您希望集合为自己提供一个迭代器。 对迭代器为您提供的每件事调用您的函数。

如果您想以不同的顺序迭代树的节点，那么树将需要提供多个迭代器。 如果您想按照树尚不支持的顺序处理节点，则需要修改树类。

Answer 2

是的。 被访问的对象可以进行枚举（即调用所需的子对象）。 这仍然称为“Visitor”模式（事实上，设计模式的第一个 Visitor 示例就是这样做的）。 我编造的示例片段：

public void accept(Visitor visitor) {
  for (Node n : children) {
    n.accept(visitor);
  }
}

注意：对于拜访孩子们，我们不能说 visitor.visit(n);。 这是因为 Java 不是动态选择方法（根据其参数的运行时类），而是静态选择方法（根据其参数的编译时类型）。

Answer 3

简而言之，我认为访问者模式与枚举的完成方式正交。 可以用任何一种方式完成，也可以根本不进行枚举。

我认为访问者需要知道访问的结构由哪些元素组成。 想知道汽车由车轮和发动机组成。 我认为没有必要知道它们到底是如何组合的。 考虑以下示例。 Insider 知道访问的对象结构并自行执行枚举。 局外人不知道这一点，并将枚举委托给访问的对象。

interface Visitable {
    void accept(Visitor visitor);
}

class WorkingRoom implements Visitable {
    public int number;
    WorkingRoom(int number) {
        this.number = number;
    }

    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

class BossRoom implements Visitable {
    public String bossName;
    BossRoom(String bossName) {
        this.bossName = bossName;
    }
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

interface Visitor{
    void visit(WorkingRoom workingRoom);
    void visit(BossRoom bossRoom);
    void visit(Office office);
}

class Office implements Visitable{
    public Visitable[] firstFloor;
    public Visitable[] secondFloor;
    public Visitable ceoRoom;
    public Office(){
        firstFloor = new Visitable[]{ new WorkingRoom(101),
                                        new WorkingRoom(102),
                                        new BossRoom("Jeff Atwood"),
                                        new WorkingRoom(103)};
        secondFloor = new Visitable[]{  new WorkingRoom(201),
                                        new WorkingRoom(202),
                                        new BossRoom("Joel Spolsky")};

        ceoRoom = new BossRoom("Bill Gates");
    }

    public void accept(Visitor visitor) {
        visitor.visit(this);
    }

    public void showMeTheOffice(Visitor visitor, boolean sayPlease) {
        // Office manager decides the order in which rooms are visited
        for(int i=secondFloor.length-1; i >= 0; i--){
            secondFloor[i].accept(visitor);
        }
        if (sayPlease){
            ceoRoom.accept(visitor);
        }
        for (int i = 0; i < firstFloor.length; i++) {
            firstFloor[i].accept(visitor);
        }
    }
}

class Insider implements Visitor{
    public void visit(WorkingRoom workingRoom) {
        System.out.println("I> This is working room #"+workingRoom.number);
    }

    public void visit(BossRoom bossRoom) {
        System.out.println("I> Hi, "+bossRoom.bossName);
    }

    public void visit(Office office) {
        // I know about office structure, so I'll just go to the 1st floor
        for(int i=0;i<office.firstFloor.length;i++){
            office.firstFloor[i].accept(this);
        }
    }
}

class Outsider implements Visitor{

    public void visit(Office office) {
        // I do not know about office structure, but I know they have a 
        // nice office manager
        // I'll just ask to show me the office
        office.showMeTheOffice(this, true);
    }

    public void visit(WorkingRoom workingRoom) {
        System.out.println("O> Wow, room #"+workingRoom.number);
    }

    public void visit(BossRoom bossRoom) {
        System.out.println("O> Oh, look, this is "+bossRoom.bossName);
    }
}

public class Main{
    public static void main(String[] args) {
        Office office = new Office(); // visited structure
        // visitor who knows about office structure
        Insider employee = new Insider(); 
        office.accept(employee);
        System.out.println();
        // visitor who does not know about exact office structure
        // but knows something else
        Outsider candidate = new Outsider(); 
        office.accept(candidate);

        // no enumeration at all, but still a visitor pattern
        Visitable v = new BossRoom("Linus Torvalds");
        v.accept(candidate);
    }
}

我有一个项目广泛使用访问者模式，根本没有任何枚举。 我们有基本接口 Field 和许多实现它的类，如 StringField、NumberField 等。很多时候我们必须根据字段类型做不同的事情，例如以不同的方式呈现它、从 DB 加载、导出到 xml 等我们可以在 Field 接口中定义方法，但这会使其与项目的每个功能相结合 - 可怜的字段必须了解导出、导入、渲染为 html 和 rtf 等。我们也可以使用 instanceof 但可能的集合。实现 Field 接口的类随着时间的推移而改变，并且有可能添加新的字段类型并忘记

else if (field instanceof NewlyAddedFieldType) {...}

在某个地方添加。 所以我们决定使用访问者模式，就像

Visitor v = new XMLExportVisitor(outputStream);
field.accept(v);

任何 Field 实现都需要有方法

void accept(FieldVisitor visitor)

一样，如果我添加 Field 接口的新实现，我必须以某种方式实现它。 通常

visitor.visit(this);

这是新添加的类的地方。 这迫使我添加

void visit(NewlyAddedClass visited);

到 FieldVisitor 接口，这使我在我们已有的每个 FieldVisitor 实现中实现它。 所以如果我忘记做一些事情 - 我会得到编译器错误。
这种情况下的枚举（如果有的话）是在访问的结构和访问者之外完成的。 但我仍然认为这是访客模式的一个有效案例。
它实施起来有点困难，但使用起来更容易、更安全。

Answer 4

分层访问者模式解释了一种不同的方法，它添加了进入和离开级别的事件。 关联的讨论页面提供访问者或容器内迭代的参数。 它包括使用外部迭代器的建议，如果您有一个常规树并且需要以不同方式进行迭代，这对我来说很有意义。

回顾我的 oofRep 访客，它有一系列不同类别的级别访问并在方法中进行迭代，例如：

void
oofRepVisitor::VisitViewHeaders(oofRepBandList& inBands)
{
    VisitBandList(inBands);
}


void
oofRepVisitor::VisitBandList(oofRepBandList& inBands)
{
    EnterLevel();
    const unsigned long numBands = inBands.count();
    for (unsigned long i=0; i<numBands; i++) {
        oofRepBand* theBand = inBands.value(i);
        assert(theBand);
        VisitTypedBand(theBand);
    }
    LeaveLevel();
}

使用覆盖

void
OOF_repXMLlayoutVisitor::VisitViewHeaders(oofRepBandList& inBands)
{
    oofRepStreamEnv::out() << mIdentities.getIndentString();
    if (inBands.keepTogether())
        oofRepStreamEnv::out()  << "<header>\n";    
    else  // default is ON, and simplifies XML
        oofRepStreamEnv::out()  << "<header keepTogether='false'>\n";
    VisitBandList(inBands);
    oofRepStreamEnv::out() 
        << mIdentities.getIndentString()
        << "</header>\n";
}

Answer 5

看看这篇文章中的解释。

来自 Wiki：

在面向对象编程中
软件工程，访客
设计模式是一种分离的方式
来自对象结构的算法
它的运作依据。 一个实用的
这种分离的结果是
添加新操作的能力
现有的对象结构没有
修改这些结构。 因此，
使用访客模式有帮助
符合开放/封闭
原理。