定义

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

结构和说明

行为型模式-访问者模式 - 图1

示例代码

  1. public class VisitorDemo {
  3.     /**
  4.      * 访问者接口
  5.      */
  6.     public static interface Visitor {
  8.         /**
  9.          * 访问元素 A,相当于给元素 A 添加访问者的功能
  10.          * 
  11.          * @param elementA
  12.          *            元素 A 的对象
  13.          */
  14.         void visitConcreteElementA(ConcreteElementA elementA);
  16.         /**
  17.          * 访问元素 B,相当于给元素 B 添加访问者的功能
  18.          *
  19.          * @param elementB
  20.          *            元素 B 的对象
  21.          */
  22.         void visitConcreteElementB(ConcreteElementB elementB);
  24.     }
  26.     /**
  27.      * 具体的访问者实现
  28.      */
  29.     public static class ConcreteVisitor1 implements Visitor {
  31.         @Override
  32.         public void visitConcreteElementA(ConcreteElementA elementA) {
  33.             // 把要访问 ConcreteElementA 时，需要执行的功能实现在这里
  34.             // 可能需要访问元素已有的功能，比如：
  35.             elementA.operationA();
  36.         }
  38.         @Override
  39.         public void visitConcreteElementB(ConcreteElementB elementB) {
  40.             elementB.operationB();
  41.         }
  42.     }
  44.     public static class ConcreteVisitor2 implements Visitor {
  46.         @Override
  47.         public void visitConcreteElementA(ConcreteElementA elementA) {
  48.             elementA.operationA();
  49.         }
  51.         @Override
  52.         public void visitConcreteElementB(ConcreteElementB elementB) {
  53.             elementB.operationB();
  54.         }
  55.     }
  57.     /**
  58.      * 被访问的元素的接口
  59.      */
  60.     public static abstract class Element {
  62.         /**
  63.          * 接受访问者的访问
  64.          * 
  65.          * @param visitor
  66.          *            访问者对象
  67.          */
  68.         abstract void accept(Visitor visitor);
  70.     }
  72.     /**
  73.      * 具体元素的实现对象
  74.      */
  75.     public static class ConcreteElementA extends Element {
  77.         @Override
  78.         void accept(Visitor visitor) {
  79.             // 回调访问者对象的相应方法
  80.             visitor.visitConcreteElementA(this);
  81.         }
  83.         /**
  84.          * 示例方法，表示元素已有的功能实现
  85.          */
  86.         public void operationA() {
  87.             // 已有的功能实现
  88.         }
  90.     }
  92.     public static class ConcreteElementB extends Element {
  94.         @Override
  95.         void accept(Visitor visitor) {
  96.             visitor.visitConcreteElementB(this);
  97.         }
  99.         public void operationB() {}
  100.     }
  102.     /**
  103.      * 对象结构，通常在这里对元素对象进行遍历，让访问者能访问到所有元素
  104.      */
  105.     public static class ObjectStructure {
  107.         /**
  108.          * 示意，表示对象结构，可以是一个组合结构或是集合
  109.          */
  110.         private Collection<Element> col = new ArrayList<>();
  112.         /**
  113.          * 示意方法，提供给客户端操作的高层接口
  114.          * 
  115.          * @param visitor
  116.          *            客户端需要使用的访问者
  117.          */
  118.         public void handleRequest(Visitor visitor) {
  119.             col.stream().forEach(element -> {
  120.                 element.accept(visitor);
  121.             });
  122.         }
  124.         /**
  125.          * 示意方法，组建对象结构，向对象结构中添加元素 不同对象结构有不同的构建方式
  126.          * 
  127.          * @param ele
  128.          *            加入对象结构的元素
  129.          */
  130.         public void addElement(Element ele) {
  131.             col.add(ele);
  132.         }
  134.     }
  136.     public static class Client {
  138.         public static void main(String[] args) {
  139.             // 创建 ObjectStructure
  140.             ObjectStructure os = new ObjectStructure();
  142.             // 创建要加入对象结构的元素
  143.             Element elementA = new ConcreteElementA();
  144.             Element elementB = new ConcreteElementB();
  146.             // 把元素加入对象结构
  147.             os.addElement(elementA);
  148.             os.addElement(elementB);
  150.             // 创建访问者
  151.             Visitor visitor1 = new ConcreteVisitor1();
  153.             // 调用业务处理的方法
  154.             os.handleRequest(visitor1);
  155.         }
  157.     }
  159. }

调用顺序

行为型模式-访问者模式 - 图2

访问者模式结合组合模式

结构和说明

行为型模式-访问者模式 - 图3

优缺点

优点

  • 好的扩展性

能够在不修改对象结构中元素的情况下，为对象结构中的元素添加新的功能。

  • 好的复用性

可以通过定义访问者来定义整个对象结构中通用的功能，从而提高复用程度。

  • 分离无关行为

可以通过提供访问者来分离无关的行为，把相关的行为封装在一起，构成一个访问者，这样每个访问者的功能都比较单一。

缺点

  • 对象结构变化很困难

不适用于对象结构中的类经常变化的情况，因为对象结构发生了变化，访问者的结构和访问者的实现都要发生相应的变化，代价太高。

  • 破坏封装

访问者模式通常需要对象结构开放内部数据给访问者和 ObjectStructrue, 这破坏了对象的封装性。

思考

本质

预留通路，回调实现。

何时选用

  • 如果想对一个对象结构实施一些依赖于对象结构中具体类的操作，可以使用访问者模式。
  • 如果想对一个对象结构中的各个元素进行很多不同的而且不相关的操作，为了避免这些操作使类变得混乱，可以使用访问者模式。把这些操作分散到不同的访问者对象中去，每个访问者对象实现同一类的功能。
  • 如果对象结构很少变动，但是需要经常给对象结构中的元素对象定义新的操作，可以使用访问者模式。

相关模式

  • 访问者模式和组合模式

这两个模式可以组合使用。
如果前面示例的那样，通过访问者模式给组合对象预留下扩展功能的接口，使得为组合模式的对象结构添加功能非常方便。

  • 访问者模式和装饰模式

这两个模式从表面上看功能有些类似，都能够实现在不修改对象原结构的情况下修改原对象的功能。但是装饰模式更多的实现是对已有功能的加强、修改或者是完全全新实现; 而访问者模式更多的是实现为对象结构添加新的功能。

  • 访问者模式和解析器模式

这两个模式可以组合使用。
解释器模式在构建抽象语法树的时候，是使用组合模式来构建的，也就是说解析器模式解释并执行的抽象语法树是一个组合对象结构，这个组合对象结构是很少变动的，但是可能经常需要为解释器增加新的功能，实现对同一对象结构的不同解释和执行的功能，这正式访问者的优势所在，因此在使用解释器模式的时候通常会组合访问者模式来使用。