訪問者模式

訪問者模式（英語：visitor pattern），是一種將算法與對象結構分離的軟件設計模式^[2]。在傳統的單分派語言比如Smalltalk、Java和C++之中，訪問者模式被用來模擬雙分派（英語：Double dispatch）。在支持多分派的語言如CLOS之中，訪問者模式就不再需要了。

訪問者模式用統一建模語言（UML）來表示。^{[1]（p. 381）}

概述

訪問者模式是一個由許多對象構成的對象結構，這些對象的類都擁有一個accept方法用來接受訪問者對象；訪問者是一個接口，它有一個visit方法，這個方法對訪問到的對象結構中不同類型的元素作出相應的動作；在對象結構的訪問過程中，visit方法遍歷整個對象結構，對每一個元素都實施accept方法，在每一個元素的accept方法中回調訪問者的visit方法，從而使訪問者得以處理對象結構的每一個元素。我們可以針對對象結構設計不同的實在的訪問者類來完成不同的操作。

結構

訪問者模式的樣例UML類圖和序列圖^[3]。

在上面的UML類圖中：

• ElementA類不直接實現新的運算，ElementA轉而實現一個分派運算accept(visitor)，它將請求分配（委託）給被接受的訪問者對象（visitor.visitElementA(this)）。Visitor1類實現這個運算（visitElementA(e:ElementA)）。
• ElementB 接着通過分派到visitor.visitElementB(this)實現accept(visitor)。Visitor1類實現這個運算（visitElementB(e:ElementB)）。

UML序列圖展示了運行時交互：

• Client對象遊歷一個對象結構中的元素（ElementA,ElementB）並調用accept(visitor)於每個元素之上。
• 首先，Client調用accept(visitor)於ElementA之上，它調用visitElementA(this)於被接受的visitor對象之上。這個元素自身（this）被傳遞給visitor，使得它可以訪問ElementA（調用operationA()）。
• 此後，Client調用accept(visitor)於ElementB之上，它調用visitElementB(this)於visitor之上，它訪問ElementB（調用operationB()）。

例子

Java

Java的例子：

import java.util.List;

interface CarElement {
    void accept(CarElementVisitor visitor);
}

interface CarElementVisitor {
    void visit(Body body);
    void visit(Car car);
    void visit(Engine engine);
    void visit(Wheel wheel);
}

class Wheel implements CarElement {
    private final String name;
    public Wheel(final String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    @Override
    public void accept(CarElementVisitor visitor) {
        visitor.visit(this);
    }
}

class Body implements CarElement {
    @Override
    public void accept(CarElementVisitor visitor) {
        visitor.visit(this);
    }
}

class Engine implements CarElement {
    @Override
    public void accept(CarElementVisitor visitor) {
        visitor.visit(this);
    }
}

class Car implements CarElement {
    private final List<CarElement> elements;
    public Car() {
        this.elements = List.of(
            new Wheel("front left"), new Wheel("front right"),
            new Wheel("back left"), new Wheel("back right"),
            new Body(), new Engine()
        );
    }
    @Override
    public void accept(CarElementVisitor visitor) {
        for (CarElement element : elements) {
            element.accept(visitor);
        }
        visitor.visit(this);
    }
}

class CarElementDoVisitor implements CarElementVisitor {
    @Override
    public void visit(Body body) {
        System.out.println("Moving my body");
    }
    @Override
    public void visit(Car car) {
        System.out.println("Starting my car");
    }
    @Override
    public void visit(Wheel wheel) {
        System.out.println("Kicking my " + wheel.getName() + " wheel");
    }
    @Override
    public void visit(Engine engine) {
        System.out.println("Starting my engine");
    }
}

class CarElementPrintVisitor implements CarElementVisitor {
    @Override
    public void visit(Body body) {
        System.out.println("Visiting body");
    }
    @Override
    public void visit(Car car) {
        System.out.println("Visiting car");
    }
    @Override
    public void visit(Engine engine) {
        System.out.println("Visiting engine");
    }
    @Override
    public void visit(Wheel wheel) {
        System.out.println("Visiting " + wheel.getName() + " wheel");
    }
}

public class VisitorDemo {
    public static void main(final String[] args) {
        Car car = new Car();
        car.accept(new CarElementPrintVisitor());
        car.accept(new CarElementDoVisitor());
    }
}

輸出：

Visiting front left wheel
Visiting front right wheel
Visiting back left wheel
Visiting back right wheel
Visiting body
Visiting engine
Visiting car
Kicking my front left wheel
Kicking my front right wheel
Kicking my back left wheel
Kicking my back right wheel
Moving my body
Starting my engine
Starting my car

Python

Python的例子：

class Element():
    def accept(self, visitor):
        key = '_'+type(self).__name__+'__visit'
        if key in visitor.__dir__():
            visitor.__getattribute__(key)(self)

class Body(Element): pass

class Engine(Element): pass

class Wheel(Element):
    def __init__(self, name):
        self.name = name

class Car(Element):
    def __init__(self):
        self.element_list = [
            Wheel("front left"), Wheel("front right"),
            Wheel("back left"), Wheel("back right"),
            Body(), Engine()]
    def accept(self, visitor):
        for element in self.element_list:
            element.accept(visitor)
        super().accept(visitor)

class Visitor():
    @classmethod
    def admit(cls, visitor_dict):
        for key, value in visitor_dict.items():
            type.__setattr__(cls, '_'+key+'__visit', value)

class PrintVisitor(Visitor): pass
def _print_body(self, body):
    print(f"Visiting body.")
def _print_car(self, car):
    print(f"Visiting car.")
def _print_wheel(self, wheel):
    print(f"Visiting {wheel.name} wheel.")
def _print_engine(self, engine):
    print(f"Visiting engine.")
print_visitor_dict = {
    'Body': _print_body, 'Car': _print_car,
    'Wheel': _print_wheel, 'Engine': _print_engine}
PrintVisitor.admit(print_visitor_dict)

class DoVisitor(Visitor): pass
def _do_body(self, body):
    print(f"Moving my body.")
def _do_car(self, car):
    print(f"Starting my car.")
def _do_wheel(self, wheel):
    print(f"Kicking my {wheel.name} wheel.")
def _do_engine(self, engine):
    print(f"Starting my engine.")
do_visitor_dict = {
    'Body': _do_body, 'Car': _do_car,
    'Wheel': _do_wheel, 'Engine': _do_engine}
DoVisitor.admit(do_visitor_dict)

這裡的訪問者的反射式實現方式，主要解決訪問者模式中難於動態增加具體元素類的問題^[4]。下面是其用例：

>>> car = Car()
>>> car.accept(PrintVisitor())
Visiting front left wheel.
Visiting front right wheel.
Visiting back left wheel.
Visiting back right wheel.
Visiting body.
Visiting engine.
Visiting car.
>>> car.accept(DoVisitor())
Kicking my front left wheel.
Kicking my front right wheel.
Kicking my back left wheel.
Kicking my back right wheel.
Moving my body.
Starting my engine.
Starting my car.

C#

下面的C#例子，聲明了一個獨立的ExpressionPrintingVisitor類處理打印。如果想要介入一個新的具體訪問者，則需要創建一個實現Visitor接口的新類，並且提供一個Visit方法的新實現。現存的類（Literal和Addition）將保持不變。

using System;

namespace Wikipedia;

public interface Visitor {
    void Visit(Literal literal);  
    void Visit(Addition addition);
}

public class ExpressionPrintingVisitor : Visitor {
    public void Visit(Literal literal) {
        Console.WriteLine(literal.Value);
    }

    public void Visit(Addition addition) {
        double leftValue = addition.Left.GetValue();
        double rightValue = addition.Right.GetValue();
        var sum = addition.GetValue();
        Console.WriteLine($"{leftValue} + {rightValue} = {sum}");
    }
 }

public abstract class Expression {
    public abstract void Accept(Visitor v);
   
    public abstract double GetValue();
}

public class Literal : Expression {
    public Literal(double value) {
        this.Value = value;
    }

    public double Value { get; set; }

    public override void Accept(Visitor v) {
        v.Visit(this);
    }
 
    public override double GetValue() {
        return Value;
    }
}

public class Addition : Expression {
    public Addition(Expression left, Expression right) {
        Left = left;
        Right = right;
    }

    public Expression Left { get; set; }
    public Expression Right { get; set; }

    public override void Accept(Visitor v) {
        Left.Accept(v);
        Right.Accept(v);
        v.Visit(this);
    }
  
    public override double GetValue() {
        return Left.GetValue() + Right.GetValue();
    }
}

public static class Program {
    public static void Main(string[] args) {
        // Emulate 1 + 2 + 3
        var e = new Addition(
            new Addition(
                new Literal(1),
                new Literal(2)
            ),
            new Literal(3)
        );

        var printingVisitor = new ExpressionPrintingVisitor();
        e.Accept(printingVisitor);
        Console.ReadKey();
    }
}

參考條目

• 迭代器模式
• 多分派