在现实生活中，有些集合对象存在多种不同的元素，且每种元素也存在多种不同的访问者和处理方式。例如，公园中存在多个景点，也存在多个游客，不同的游客对同一个景点的评价可能不同；医院医生开的处方单中包含多种药元素，査看它的划价员和药房工作人员对它的处理方式也不同，划价员根据处方单上面的药品名和数量进行划价，药房工作人员根据处方单的内容进行抓药。这样的例子还有很多，例如，电影或电视剧中的人物角色，不同的观众对他们的评价也不同；还有顾客在商场购物时放在“购物车”中的商品，顾客主要关心所选商品的性价比，而收银员关心的是商品的价格和数量。这些被处理的数据元素相对稳定而访问方式多种多样的数据结构，如果用“访问者模式”来处理比较方便。访问者模式能把处理方法从数据结构中分离出来，并可以根据需要增加新的处理方法，且不用修改原来的程序代码与数据结构，这提高了程序的扩展性和灵活性。

模式的定义与特点

访问者（Visitor）模式的定义：将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离，是行为类模式中最复杂的一种模式。访问者（Visitor）模式是一种对象行为型模式，其主要优点如下。

  1. 扩展性好。能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。
  2. 复用性好。可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度。
  3. 灵活性好。访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由地演化而不影响系统的数据结构。
  4. 符合单一职责原则。访问者模式把相关的行为封装在一起，构成一个访问者，使每一个访问者的功能都比较单一。

访问者（Visitor）模式的主要缺点如下。

  1. 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。
  2. 破坏封装。访问者模式中具体元素对访问者公布细节，这破坏了对象的封装性。

  3. 违反了依赖倒置原则。访问者模式依赖了具体类，而没有依赖抽象类。

    模式的结构与实现

    访问者（Visitor）模式实现的关键是如何将作用于元素的操作分离出来封装成独立的类，其基本结构与实现方法如下。

    1. 模式的结构

    访问者模式包含以下主要角色。

  4. 抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。

  5. 具体访问者（ConcreteVisitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。
  6. 抽象元素（Element）角色：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept() 方法的参数。
  7. 具体元素（ConcreteElement）角色：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作。
  8. 对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、Set、Map 等聚合类实现。

其结构图如图 1 所示。
访问者模式(Visitor) - 图1
图1 访问者（Visitor）模式的结构图（点此查看原图）

2. 模式的实现

访问者模式的实现代码如下：

  1. package net.biancheng.c.visitor;
  3. import java.util.*;
  5. public class VisitorPattern {
  6.     public static void main(String[] args) {
  7.         ObjectStructure os = new ObjectStructure();
  8.         os.add(new ConcreteElementA());
  9.         os.add(new ConcreteElementB());
  10.         Visitor visitor = new ConcreteVisitorA();
  11.         os.accept(visitor);
  12.         System.out.println("------------------------");
  13.         visitor = new ConcreteVisitorB();
  14.         os.accept(visitor);
  15.     }
  16. }
  18. //抽象访问者
  19. interface Visitor {
  20.     void visit(ConcreteElementA element);
  22.     void visit(ConcreteElementB element);
  23. }
  25. //具体访问者A类
  26. class ConcreteVisitorA implements Visitor {
  27.     public void visit(ConcreteElementA element) {
  28.         System.out.println("具体访问者A访问-->" + element.operationA());
  29.     }
  31.     public void visit(ConcreteElementB element) {
  32.         System.out.println("具体访问者A访问-->" + element.operationB());
  33.     }
  34. }
  36. //具体访问者B类
  37. class ConcreteVisitorB implements Visitor {
  38.     public void visit(ConcreteElementA element) {
  39.         System.out.println("具体访问者B访问-->" + element.operationA());
  40.     }
  42.     public void visit(ConcreteElementB element) {
  43.         System.out.println("具体访问者B访问-->" + element.operationB());
  44.     }
  45. }
  47. //抽象元素类
  48. interface Element {
  49.     void accept(Visitor visitor);
  50. }
  52. //具体元素A类
  53. class ConcreteElementA implements Element {
  54.     public void accept(Visitor visitor) {
  55.         visitor.visit(this);
  56.     }
  58.     public String operationA() {
  59.         return "具体元素A的操作。";
  60.     }
  61. }
  63. //具体元素B类
  64. class ConcreteElementB implements Element {
  65.     public void accept(Visitor visitor) {
  66.         visitor.visit(this);
  67.     }
  69.     public String operationB() {
  70.         return "具体元素B的操作。";
  71.     }
  72. }
  74. //对象结构角色
  75. class ObjectStructure {
  76.     private List<Element> list = new ArrayList<Element>();
  78.     public void accept(Visitor visitor) {
  79.         Iterator<Element> i = list.iterator();
  80.         while (i.hasNext()) {
  81.             ((Element) i.next()).accept(visitor);
  82.         }
  83.     }
  85.     public void add(Element element) {
  86.         list.add(element);
  87.     }
  89.     public void remove(Element element) {
  90.         list.remove(element);
  91.     }
  92. }

程序的运行结果如下：

具体访问者A访问—>具体元素A的操作。
具体访问者A访问—>具体元素B的操作。
————————————
具体访问者B访问—>具体元素A的操作。
具体访问者B访问—>具体元素B的操作。

模式的应用实例

【例1】利用“访问者（Visitor）模式”模拟艺术公司与造币公司的功能。分析：艺术公司利用“铜”可以设计出铜像，利用“纸”可以画出图画；造币公司利用“铜”可以印出铜币，利用“纸”可以印出纸币（点此下载运行该程序后所要显示的图片）。对“铜”和“纸”这两种元素，两个公司的处理方法不同，所以该实例用访问者模式来实现比较适合。首先，定义一个公司（Company）接口，它是抽象访问者，提供了两个根据纸（Paper）或铜（Cuprum）这两种元素创建作品的方法；再定义艺术公司（ArtCompany）类和造币公司（Mint）类，它们是具体访问者，实现了父接口的方法。然后，定义一个材料（Material）接口，它是抽象元素，提供了 accept（Company visitor）方法来接受访问者（Company）对象访问；再定义纸（Paper）类和铜（Cuprum）类，它们是具体元素类，实现了父接口中的方法。最后，定义一个材料集（SetMaterial）类，它是对象结构角色，拥有保存所有元素的容器 List，并提供让访问者对象遍历容器中的所有元素的 accept（Company visitor）方法；客户类设计成窗体程序，它提供材料集（SetMaterial）对象供访问者（Company）对象访问，实现了 ItemListener 接口，处理用户的事件请求。图 2 所示是其结构图。访问者模式(Visitor) - 图2
图2 艺术公司与造币公司的结构图
程序代码如下：

  1. package net.biancheng.c.visitor;
  3. import javax.swing.*;
  4. import java.awt.event.ItemEvent;
  5. import java.awt.event.ItemListener;
  6. import java.util.ArrayList;
  7. import java.util.Iterator;
  8. import java.util.List;
  10. public class VisitorProducer {
  11.     public static void main(String[] args) {
  12.         new MaterialWin();
  13.     }
  14. }
  16. //窗体类
  17. class MaterialWin extends JFrame implements ItemListener {
  18.     private static final long serialVersionUID = 1L;
  19.     JPanel CenterJP;
  20.     SetMaterial os;    //材料集对象
  21.     Company visitor1, visitor2;    //访问者对象
  22.     String[] select;
  24.     MaterialWin() {
  25.         super("利用访问者模式设计艺术公司和造币公司");
  26.         JRadioButton Art;
  27.         JRadioButton mint;
  28.         os = new SetMaterial();
  29.         os.add(new Cuprum());
  30.         os.add(new Paper());
  31.         visitor1 = new ArtCompany();//艺术公司
  32.         visitor2 = new Mint(); //造币公司
  33.         this.setBounds(10, 10, 750, 350);
  34.         this.setResizable(false);
  35.         CenterJP = new JPanel();
  36.         this.add("Center", CenterJP);
  37.         JPanel SouthJP = new JPanel();
  38.         JLabel yl = new JLabel("原材料有：铜和纸，请选择生产公司：");
  39.         Art = new JRadioButton("艺术公司", true);
  40.         mint = new JRadioButton("造币公司");
  41.         Art.addItemListener(this);
  42.         mint.addItemListener(this);
  43.         ButtonGroup group = new ButtonGroup();
  44.         group.add(Art);
  45.         group.add(mint);
  46.         SouthJP.add(yl);
  47.         SouthJP.add(Art);
  48.         SouthJP.add(mint);
  49.         this.add("South", SouthJP);
  50.         select = (os.accept(visitor1)).split(" ");    //获取产品名
  51.         showPicture(select[0], select[1]);    //显示产品
  52.     }
  54.     //显示图片
  55.     void showPicture(String Cuprum, String paper) {
  56.         CenterJP.removeAll();    //清除面板内容
  57.         CenterJP.repaint();    //刷新屏幕
  58.         String FileName1 = "src/visitor/Picture/" + Cuprum + ".jpg";
  59.         String FileName2 = "src/visitor/Picture/" + paper + ".jpg";
  60.         JLabel lb = new JLabel(new ImageIcon(FileName1), JLabel.CENTER);
  61.         JLabel rb = new JLabel(new ImageIcon(FileName2), JLabel.CENTER);
  62.         CenterJP.add(lb);
  63.         CenterJP.add(rb);
  64.         this.setVisible(true);
  65.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  66.     }
  68.     @Override
  69.     public void itemStateChanged(ItemEvent arg0) {
  70.         JRadioButton jc = (JRadioButton) arg0.getSource();
  71.         if (jc.isSelected()) {
  72.             if (jc.getText() == "造币公司") {
  73.                 select = (os.accept(visitor2)).split(" ");
  74.             } else {
  75.                 select = (os.accept(visitor1)).split(" ");
  76.             }
  77.             showPicture(select[0], select[1]);    //显示选择的产品
  78.         }
  79.     }
  80. }
  82. //抽象访问者:公司
  83. interface Company {
  84.     String create(Paper element);
  86.     String create(Cuprum element);
  87. }
  89. //具体访问者：艺术公司
  90. class ArtCompany implements Company {
  91.     public String create(Paper element) {
  92.         return "讲学图";
  93.     }
  95.     public String create(Cuprum element) {
  96.         return "朱熹铜像";
  97.     }
  98. }
  100. //具体访问者：造币公司
  101. class Mint implements Company {
  102.     public String create(Paper element) {
  103.         return "纸币";
  104.     }
  106.     public String create(Cuprum element) {
  107.         return "铜币";
  108.     }
  109. }
  111. //抽象元素：材料
  112. interface Material {
  113.     String accept(Company visitor);
  114. }
  116. //具体元素：纸
  117. class Paper implements Material {
  118.     public String accept(Company visitor) {
  119.         return (visitor.create(this));
  120.     }
  121. }
  123. //具体元素：铜
  124. class Cuprum implements Material {
  125.     public String accept(Company visitor) {
  126.         return (visitor.create(this));
  127.     }
  128. }
  130. //对象结构角色:材料集
  131. class SetMaterial {
  132.     private List<Material> list = new ArrayList<Material>();
  134.     public String accept(Company visitor) {
  135.         Iterator<Material> i = list.iterator();
  136.         String tmp = "";
  137.         while (i.hasNext()) {
  138.             tmp += ((Material) i.next()).accept(visitor) + " ";
  139.         }
  140.         return tmp; //返回某公司的作品集
  141.     }
  143.     public void add(Material element) {
  144.         list.add(element);
  145.     }
  147.     public void remove(Material element) {
  148.         list.remove(element);
  149.     }
  150. }

模式的应用场景

当系统中存在类型数量稳定（固定）的一类数据结构时，可以使用访问者模式方便地实现对该类型所有数据结构的不同操作，而又不会对数据产生任何副作用（脏数据）。简而言之，就是当对集合中的不同类型数据（类型数量稳定）进行多种操作时，使用访问者模式。通常在以下情况可以考虑使用访问者（Visitor）模式。

  1. 对象结构相对稳定，但其操作算法经常变化的程序。
  2. 对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。
  3. 对象结构包含很多类型的对象，希望对这些对象实施一些依赖于其具体类型的操作。

    模式的扩展

    访问者（Visitor）模式是使用频率较高的一种设计模式，它常常同以下两种设计模式联用。(1)与“迭代器模式”联用。因为访问者模式中的“对象结构”是一个包含元素角色的容器，当访问者遍历容器中的所有元素时，常常要用迭代器。如【例1】中的对象结构是用 List 实现的，它通过 List 对象的 Iterator() 方法获取迭代器。如果对象结构中的聚合类没有提供迭代器，也可以用迭代器模式自定义一个。(2)访问者（Visitor）模式同“组合模式”联用。因为访问者（Visitor）模式中的“元素对象”可能是叶子对象或者是容器对象，如果元素对象包含容器对象，就必须用到组合模式，其结构图如图 4 所示。访问者模式(Visitor) - 图3
    图4 包含组合模式的访问者模式的结构图