Was ist der Punkt der accept () -Methode im Besuchermuster?

Es wird viel darüber geredet, die Algorithmen von den Klassen zu entkoppeln. Eines bleibt jedoch nicht erklärt.

Sie benutzen Besucher wie diesen

abstract class Expr {
  public <T> T accept(Visitor<T> visitor) {visitor.visit(this);}
}

class ExprVisitor extends Visitor{
  public Integer visit(Num num) {
    return num.value;
  }

  public Integer visit(Sum sum) {
    return sum.getLeft().accept(this) + sum.getRight().accept(this);
  }

  public Integer visit(Prod prod) {
    return prod.getLeft().accept(this) * prod.getRight().accept(this);
  }

Anstatt visit (element) direkt aufzurufen, fordert Visitor das Element auf, seine visit-Methode aufzurufen. Es widerspricht der erklärten Idee der Klassenunwissenheit über Besucher.

PS1 Bitte erkläre es mit deinen eigenen Worten oder zeige auf eine genaue Erklärung. Weil sich zwei Antworten auf etwas Allgemeines und Ungewisses beziehen.

PS2 Meine Vermutung: Da getLeft()das Basic zurückgegeben Expressionwird, visit(getLeft())würde ein Anruf dazu führen visit(Expression), während ein getLeft()Anruf visit(this)zu einem anderen, angemesseneren Besuchsaufruf führt. So,accept() führt die Typumwandlung (aka Gießen).

PS3 Scalas Pattern Matching = Besuchermuster auf Steroid zeigt, wie viel einfacher das Besuchermuster ohne die Akzeptanzmethode ist. Wikipedia fügt dieser Aussage hinzu : indem ein Artikel verknüpft wird, der zeigt, "dass accept()Methoden nicht erforderlich sind, wenn Reflexion verfügbar ist; führt den Begriff" Walkabout "für die Technik ein".

Das Besuchermuster visit/accept Konstrukte sind ein notwendiges Übel aufgrund von C-ähnliche Sprachen (C #, Java, etc.) Semantik. Das Ziel des Besuchermusters besteht darin, Ihren Anruf mithilfe des doppelten Versands so weiterzuleiten, wie Sie es vom Lesen des Codes erwarten.

Normalerweise ist bei Verwendung des Besuchermusters eine Objekthierarchie beteiligt, bei der alle Knoten von einem Basistyp abgeleitet sind Node, der im Folgenden als bezeichnet wird Node. Instinktiv würden wir es so schreiben:

Node root = GetTreeRoot();
new MyVisitor().visit(root);

Hierin liegt das Problem. Wenn unsere MyVisitorKlasse wie folgt definiert wurde:

class MyVisitor implements IVisitor {
  void visit(CarNode node);
  void visit(TrainNode node);
  void visit(PlaneNode node);
  void visit(Node node);
}

Wenn zur Laufzeit, unabhängig vom tatsächlichen Typ root, unser Aufruf in die Überlastung gehen würde visit(Node node). Dies gilt für alle vom Typ deklarierten Variablen Node. Warum ist das? Da Java und andere C-ähnliche Sprachen bei der Entscheidung, welche Überladung aufgerufen werden soll, nur den statischen Typ oder den Typ berücksichtigen, als den die Variable deklariert ist. Java unternimmt nicht den zusätzlichen Schritt, um bei jedem Methodenaufruf zur Laufzeit zu fragen: "Okay, was ist der dynamische Typ root? Oh, ich verstehe. Es ist einTrainNode . Mal sehen, ob es eine Methode inMyVisitor die einen Parameter vom Typ akzeptiertTrainNode... ". Der Compiler bestimmt zur Kompilierungszeit, welche Methode aufgerufen wird. (Wenn Java tatsächlich die dynamischen Typen der Argumente untersuchen würde, wäre die Leistung ziemlich schrecklich.)

Java bietet uns ein Tool, mit dem der Laufzeittyp (dh der dynamische Typ) eines Objekts beim Aufruf einer Methode berücksichtigt werden kann - der Versand virtueller Methoden . Wenn wir eine virtuelle Methode aufrufen, wird der Aufruf tatsächlich an eine Tabelle im Speicher gesendet, die aus Funktionszeigern besteht. Jeder Typ hat eine Tabelle. Wenn eine bestimmte Methode von einer Klasse überschrieben wird, enthält der Funktionstabelleneintrag dieser Klasse die Adresse der überschriebenen Funktion. Wenn die Klasse eine Methode nicht überschreibt, enthält sie einen Zeiger auf die Implementierung der Basisklasse. Dies verursacht immer noch einen Leistungsaufwand (bei jedem Methodenaufruf werden im Wesentlichen zwei Zeiger dereferenziert: einer zeigt auf die Funktionstabelle des Typs und einer auf die Funktion selbst), aber es ist immer noch schneller, als Parametertypen untersuchen zu müssen.

Das Ziel des Besuchermusters ist es, einen doppelten Versand zu erreichen - wird nicht nur der Typ des Anrufziels berücksichtigt ( MyVisitorüber virtuelle Methoden), sondern auch der Typ des Parameters (welche Art von betrachten Nodewir)? Das Besuchermuster ermöglicht es uns, dies durch die Kombination visit/ zu tun accept.

Indem Sie unsere Linie dahingehend ändern:

root.accept(new MyVisitor());

Wir können bekommen, was wir wollen: Über den Versand virtueller Methoden geben wir den richtigen accept () -Aufruf ein, wie er von der Unterklasse implementiert wurde. In unserem Beispiel mit geben TrainElementwir die TrainElementImplementierung von ein accept():

class TrainNode extends Node implements IVisitable {
  void accept(IVisitor v) {
    v.visit(this);
  }
}

Was weiß der Compiler an dieser Stelle im Rahmen von TrainNode's accept? Es weiß, dass der statische Typ von a thisistTrainNode . Dies ist eine wichtige zusätzliche Information, die dem Compiler im Bereich unseres Aufrufers nicht bekannt war: Dort wusste er rootnur, dass es sich um eine handelt Node. Jetzt weiß der Compiler, dass this( root) nicht nur ein Node, sondern tatsächlich ein ist TrainNode. Infolgedessen bedeutet die eine Zeile im Inneren accept(): v.visit(this)etwas ganz anderes. Der Compiler sucht nun nach einer Überladung visit(), die a benötigt TrainNode. Wenn es keinen findet, kompiliert es den Aufruf zu einer Überladung, die a benötigtNode. Wenn beides nicht vorhanden ist, wird ein Kompilierungsfehler angezeigt (es sei denn, Sie haben eine Überladung, die erforderlich ist object). Die Ausführung wird somit in das eingehen, was wir die ganze Zeit beabsichtigt hatten: MyVisitordie Implementierung von visit(TrainNode e). Es waren keine Abgüsse erforderlich, und vor allem war keine Reflexion erforderlich. Daher ist der Aufwand für diesen Mechanismus eher gering: Er besteht nur aus Zeigerreferenzen und sonst nichts.

Sie haben Recht mit Ihrer Frage - wir können eine Besetzung verwenden und das richtige Verhalten erzielen. Oft wissen wir jedoch nicht einmal, um welchen Knotentyp es sich handelt. Nehmen Sie den Fall der folgenden Hierarchie:

abstract class Node { ... }
abstract class BinaryNode extends Node { Node left, right; }
abstract class AdditionNode extends BinaryNode { }
abstract class MultiplicationNode extends BinaryNode { }
abstract class LiteralNode { int value; }

Und wir haben einen einfachen Compiler geschrieben, der eine Quelldatei analysiert und eine Objekthierarchie erzeugt, die der obigen Spezifikation entspricht. Wenn wir einen Interpreter für die als Besucher implementierte Hierarchie schreiben würden:

class Interpreter implements IVisitor<int> {
  int visit(AdditionNode n) {
    int left = n.left.accept(this);
    int right = n.right.accept(this); 
    return left + right;
  }
  int visit(MultiplicationNode n) {
    int left = n.left.accept(this);
    int right = n.right.accept(this);
    return left * right;
  }
  int visit(LiteralNode n) {
    return n.value;
  }
}

Casting würde uns nicht sehr weit bringen, da wir die Arten leftoder rightin den visit()Methoden nicht kennen . Unser Parser würde höchstwahrscheinlich auch nur ein Objekt vom Typ zurückgeben, Nodedas ebenfalls auf die Wurzel der Hierarchie zeigt, sodass wir dies auch nicht sicher umsetzen können. Unser einfacher Dolmetscher kann also so aussehen:

Node program = parse(args[0]);
int result = program.accept(new Interpreter());
System.out.println("Output: " + result);

Das Besuchermuster ermöglicht es uns, etwas sehr Mächtiges zu tun: Bei einer gegebenen Objekthierarchie können wir modulare Operationen erstellen, die über die Hierarchie arbeiten, ohne dass der Code in die Klasse der Hierarchie selbst eingefügt werden muss. Das Besuchermuster wird beispielsweise in der Compilerkonstruktion häufig verwendet. In Anbetracht des Syntaxbaums eines bestimmten Programms werden viele Besucher geschrieben, die diesen Baum bearbeiten: Typprüfung, Optimierungen und Emission von Maschinencode werden normalerweise als unterschiedliche Besucher implementiert. Im Falle des Optimierungsbesuchers kann er anhand des Eingabebaums sogar einen neuen Syntaxbaum ausgeben.

Das hat natürlich seine Nachteile: Wenn wir der Hierarchie einen neuen Typ hinzufügen, müssen wir visit()der IVisitorSchnittstelle auch eine Methode für diesen neuen Typ hinzufügen und bei allen unseren Besuchern Stub- (oder vollständige) Implementierungen erstellen. accept()Aus den oben beschriebenen Gründen müssen wir auch die Methode hinzufügen . Wenn Ihnen die Leistung nicht so viel bedeutet, gibt es Lösungen für das Schreiben von Besuchern, ohne die zu benötigen. accept()Diese beinhalten jedoch normalerweise Reflexionen und können daher einen ziemlich hohen Overhead verursachen.

Das wäre natürlich albern, wenn das das einzige wäre so Accept implementiert würde.

Aber es ist nicht.

Zum Beispiel sind Besucher wirklich sehr nützlich, wenn es um Hierarchien geht. In diesem Fall könnte die Implementierung eines nicht-terminalen Knotens so aussehen

interface IAcceptVisitor<T> {
  void Accept(IVisit<T> visitor);
}
class HierarchyNode : IAcceptVisitor<HierarchyNode> {
  public void Accept(IVisit<T> visitor) {
    visitor.visit(this);
    foreach(var n in this.children)
      n.Accept(visitor);
  }

  private IEnumerable<HierarchyNode> children;
  ....
}

Siehst du? Was Sie als dumm beschreiben, ist die Lösung für das Durchqueren von Hierarchien.

Hier ist ein viel längerer und ausführlicher Artikel, der mir den Besucher verständlich gemacht hat .

Bearbeiten: Zur Verdeutlichung: Die Besuchermethode Visitenthält Logik, die auf einen Knoten angewendet werden soll. Die AcceptMethode des Knotens enthält eine Logik zum Navigieren zu benachbarten Knoten. Der Fall, wo Sie nur doppelt versenden, ist ein Sonderfall, in dem einfach keine benachbarten Knoten zum Navigieren vorhanden sind.

Der Zweck des Besuchermusters besteht darin, sicherzustellen, dass Objekte wissen, wann der Besucher mit ihnen fertig ist und abgereist ist, damit die Klassen anschließend alle erforderlichen Aufräumarbeiten durchführen können. Außerdem können Klassen ihre Interna "vorübergehend" als "ref" -Parameter verfügbar machen und wissen, dass die Interna nicht mehr verfügbar sind, sobald der Besucher weg ist. In Fällen, in denen keine Bereinigung erforderlich ist, ist das Besuchermuster nicht besonders nützlich. Klassen, die keines dieser Dinge tun, profitieren möglicherweise nicht vom Besuchermuster, aber Code, der zur Verwendung des Besuchermusters geschrieben wurde, kann mit zukünftigen Klassen verwendet werden, die nach dem Zugriff möglicherweise bereinigt werden müssen.

Angenommen, eine Datenstruktur enthält viele Zeichenfolgen, die atomar aktualisiert werden sollen, aber die Klasse, die die Datenstruktur enthält, weiß nicht genau, welche Arten von atomaren Aktualisierungen durchgeführt werden sollen (z. B. wenn ein Thread alle Vorkommen von "ersetzen möchte). X ", während ein anderer Thread eine beliebige Ziffernfolge durch eine numerisch höhere Folge ersetzen möchte, sollten die Operationen beider Threads erfolgreich sein. Wenn jeder Thread einfach eine Zeichenfolge vorliest, seine Aktualisierungen durchführt und sie zurückschreibt, den zweiten Thread das Zurückschreiben seiner Zeichenfolge würde die erste überschreiben). Eine Möglichkeit, dies zu erreichen, besteht darin, dass jeder Thread eine Sperre erhält, seine Operation ausführt und die Sperre aufhebt. Wenn Schlösser auf diese Weise freigelegt werden,

Das Besuchermuster bietet (mindestens) drei Ansätze, um dieses Problem zu vermeiden:

1. Es kann einen Datensatz sperren, die bereitgestellte Funktion aufrufen und dann den Datensatz entsperren. Der Datensatz kann für immer gesperrt werden, wenn die angegebene Funktion in eine Endlosschleife fällt. Wenn die angegebene Funktion jedoch eine Ausnahme zurückgibt oder auslöst, wird der Datensatz entsperrt (es kann sinnvoll sein, den Datensatz als ungültig zu markieren, wenn die Funktion eine Ausnahme auslöst es ist wahrscheinlich keine gute Idee). Beachten Sie, dass es wichtig ist, dass ein Deadlock auftreten kann, wenn die aufgerufene Funktion versucht, andere Sperren zu erhalten.
2. Auf einigen Plattformen kann ein Speicherort übergeben werden, der die Zeichenfolge als 'ref'-Parameter enthält. Diese Funktion könnte dann die Zeichenfolge kopieren, eine neue Zeichenfolge basierend auf der kopierten Zeichenfolge berechnen, versuchen, die alte Zeichenfolge mit der neuen zu vergleichen, und den gesamten Vorgang wiederholen, wenn CompareExchange fehlschlägt.
3. Es kann eine Kopie der Zeichenfolge erstellen, die angegebene Funktion für die Zeichenfolge aufrufen und dann mit CompareExchange selbst versuchen, das Original zu aktualisieren, und den gesamten Vorgang wiederholen, wenn CompareExchange fehlschlägt.

Ohne das Besuchermuster würde das Ausführen atomarer Aktualisierungen das Aufdecken von Sperren und das Risiko eines Fehlers erfordern, wenn die aufrufende Software nicht einem strengen Sperr- / Entsperrprotokoll folgt. Mit dem Besuchermuster können atomare Aktualisierungen relativ sicher durchgeführt werden.

Die Klassen, die geändert werden müssen, müssen alle die Methode 'accept' implementieren. Clients rufen diese Akzeptanzmethode auf, um eine neue Aktion für diese Klassenfamilie auszuführen und dadurch ihre Funktionalität zu erweitern. Kunden können diese One-Accept-Methode verwenden, um eine Vielzahl neuer Aktionen auszuführen, indem sie für jede bestimmte Aktion eine andere Besucherklasse übergeben. Eine Besucherklasse enthält mehrere überschriebene Besuchsmethoden, die definieren, wie dieselbe spezifische Aktion für jede Klasse innerhalb der Familie ausgeführt werden soll. Diese Besuchsmethoden erhalten eine Instanz, an der gearbeitet werden soll.

Besucher sind nützlich, wenn Sie einer stabilen Klassenfamilie häufig Funktionen hinzufügen, ändern oder entfernen, da jedes Funktionselement in jeder Besucherklasse separat definiert wird und die Klassen selbst nicht geändert werden müssen. Wenn die Klassenfamilie nicht stabil ist, ist das Besuchermuster möglicherweise weniger nützlich, da viele Besucher jedes Mal geändert werden müssen, wenn eine Klasse hinzugefügt oder entfernt wird.

Ein gutes Beispiel ist die Quellcode-Kompilierung:

interface CompilingVisitor {
   build(SourceFile source);
}

Kunden können ein implementieren JavaBuilder, RubyBuilder,XMLValidator usw. und die Umsetzung für das Sammeln und den Besuch der alle Quelldateien in einem Projekt nicht ändern müssen.

Dies wäre ein schlechtes Muster, wenn Sie für jeden Quelldateityp separate Klassen haben:

interface CompilingVisitor {
   build(JavaSourceFile source);
   build(RubySourceFile source);
   build(XMLSourceFile source);
}

Es kommt auf den Kontext an und darauf, welche Teile des Systems erweiterbar sein sollen.