Das Visitor Pattern erlaubt es eine Klasse oder auch eine ganze Objektstruktur um Funktionalitäten zu erweitern ohne diese direkt zu verändern. Die hinzukommende Logik wird im Visitor gekapselt. Die Klasse(n), welche eine Interaktion mit dem Visitor erlauben soll, muss jedoch verändert werden.

Eine beliebige Klasse Foo.

class Foo {
 
  /* eigentliche Klassenimplementation */
}

Der Besucher

Eine Klasse Visitor, welche die Klasse Foo besuchen soll. Diese besitzt dazu für die zu besuchenden Klassen entsprechende Methoden visitKlassenname().

class Visitor {
 
  public function visitFoo(Foo $foo) {
    /* Mach was mit $foo */
  }
}

Foo wird gastfreundlich

Die Klasse Foo wird nun um die Möglichkeit den entsprechenden Visitor zu akzeptieren erweitert.

class Foo {
 
  /* eigentliche Klassenimplementation */
 
  public function accept(Visitor $visitor) {
    $visitor->visitFoo($this);
  }
}

Der Visitor bekommt nun das zu Besuchende Objekt übergeben und kann mit diesem interagieren. Richtig interessant wird dies jedoch erst bei komplexeren Strukturen von Objekten.

Beispiel am Kompositum

Um das ganze etwas interessanter zu gestalten, könnte das Visitor Pattern anstatt einer einzelnen Klasse auch einer Objektstruktur, wie dem Composite Pattern, einen Besuch abstatten.
Um das folgende Beispiel besser zu verstehen, sollte mein Beispiel zum Composite Pattern bekannt sein.

Der Visitor wird zum Beispiel mit den Methoden für die verschiedenen Error-Klassen ausgestattet.

class ErrorVisitor {
 
  public function visitErrorLog(ErrorLog $error) {
    /* Mach was mit $error */
  }
 
  public function visitErrorMail(ErrorMail $error) {
    /* ... */
  }
 
  public function visitErrorSms(ErrorSms $error) {
    /* ... */
  }
 
  public function visitErrorOutput(ErrorOutput $error) {
    /* ... */
  }
}

Blätter des Kompositum erweitern

Die verschiedenen Error-Klassen bekommen jeweils eine Methode um den Visitor zu akzeptieren.

class ErrorLog implements CommandInterface {
 
  /* Eigentliche Klassenimplementation */
 
  public function accept(ErrorVisitor $visitor) {
    $visitor->visitErrorLog($this);
  }
}
 
class ErrorMail implements CommandInterface {
 
  /* ... */
 
  public function accept(ErrorVisitor $visitor) {
    $visitor->visitErrorMail($this);
  }
}
 
/* usw. */

Kompositum erweitern

Das Kompositum bekommt ebenfalls eine Methode accept(), welche den Visitor an die registrierten Elemente weiter delegiert.

class ErrorComposite implements CommandInterface {
 
  /* Eigentliche Klassenimplementation */
 
  public function accept(ErrorVisitor $visitor) {
 
    foreach ($this->_errorTypes as $errorType) {
      $errorType->accept($visitor);
    }
  }
}

Der Visitor hat nun die Möglichkeit alle Elemente der Objektstruktur des Kompositums zu durchlaufen und dessen Blätter (die Error-Objekte) aufzusuchen. Wie der Baum dabei strukturiert ist, ist für den Visitor nicht interessant, da die jeweiligen Knoten wissen, wie sie den Visitor weiter zureichen haben.