访问者（Visitor）

意图

在不修改元素类的前提下，为一个对象结构（比如组合结构）中的元素增加新的操作。

类图

• Visitor：访问者，为每一个 ConcreteElement 声明一个 visit 操作；
• ConcreteVisitor：具体访问者，存储遍历过程中的累计结果；
• Element：元素，声明 accept(Visitor) 方法；
• ObjectStructure：对象结构，可以是组合结构，或者是一个集合。

实现

下面的例子用一个 GeneralReport 访问者统计客户、订单和商品的数量。元素的 accept() 中调用 visitor.visit(this)，这次调用经过两次分派才落到正确的代码上：

• 第一次，customer.accept(visitor) 按元素的实际类型选中 Customer 的 accept()；
• 第二次，accept() 中 this 的类型是 Customer，编译时选中 visit(Customer) 这个重载（重载按静态类型选择，见多态），运行时再按访问者的实际类型调用 GeneralReport 的实现。

这种做法称为双分派（Double Dispatch）。

新增一种报表只需要再写一个 Visitor 实现，Customer、Order、Item 都不用改；代价是新增一种元素时要修改 Visitor 接口和所有访问者，因此访问者适合元素类型稳定、操作经常增加的场景。

public interface Element {
    void accept(Visitor visitor);
}

class CustomerGroup {

    private List<Customer> customers = new ArrayList<>();

    void accept(Visitor visitor) {
        for (Customer customer : customers) {
            customer.accept(visitor);
        }
    }

    void addCustomer(Customer customer) {
        customers.add(customer);
    }
}

public class Customer implements Element {

    private String name;
    private List<Order> orders = new ArrayList<>();

    Customer(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    void addOrder(Order order) {
        orders.add(order);
    }

    public void accept(Visitor visitor) {
        visitor.visit(this);
        for (Order order : orders) {
            order.accept(visitor);
        }
    }
}

public class Order implements Element {

    private String name;
    private List<Item> items = new ArrayList<>();

    Order(String name) {
        this.name = name;
    }

    Order(String name, String itemName) {
        this.name = name;
        this.addItem(new Item(itemName));
    }

    String getName() {
        return name;
    }

    void addItem(Item item) {
        items.add(item);
    }

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

        for (Item item : items) {
            item.accept(visitor);
        }
    }
}

public class Item implements Element {

    private String name;

    Item(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

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

public interface Visitor {
    void visit(Customer customer);

    void visit(Order order);

    void visit(Item item);
}

public class GeneralReport implements Visitor {

    private int customersNo;
    private int ordersNo;
    private int itemsNo;

    public void visit(Customer customer) {
        System.out.println(customer.getName());
        customersNo++;
    }

    public void visit(Order order) {
        System.out.println(order.getName());
        ordersNo++;
    }

    public void visit(Item item) {
        System.out.println(item.getName());
        itemsNo++;
    }

    public void displayResults() {
        System.out.println("Number of customers: " + customersNo);
        System.out.println("Number of orders:    " + ordersNo);
        System.out.println("Number of items:     " + itemsNo);
    }
}

public class Client {
    public static void main(String[] args) {
        Customer customer1 = new Customer("customer1");
        customer1.addOrder(new Order("order1", "item1"));
        customer1.addOrder(new Order("order2", "item1"));
        customer1.addOrder(new Order("order3", "item1"));

        Order order = new Order("order_a");
        order.addItem(new Item("item_a1"));
        order.addItem(new Item("item_a2"));
        order.addItem(new Item("item_a3"));
        Customer customer2 = new Customer("customer2");
        customer2.addOrder(order);

        CustomerGroup customers = new CustomerGroup();
        customers.addCustomer(customer1);
        customers.addCustomer(customer2);

        GeneralReport visitor = new GeneralReport();
        customers.accept(visitor);
        visitor.displayResults();
    }
}

customer1
order1
item1
order2
item1
order3
item1
customer2
order_a
item_a1
item_a2
item_a3
Number of customers: 2
Number of orders:    4
Number of items:     6

JDK 中的应用

• javax.lang.model.element.Element 与 javax.lang.model.element.ElementVisitor；
• javax.lang.model.type.TypeMirror 与 javax.lang.model.type.TypeVisitor。

参考资料

• 弗里曼. Head First 设计模式 [M]. 中国电力出版社, 2007.
• Gamma E. 设计模式：可复用面向对象软件的基础 [M]. 机械工业出版社, 2007.