访问者模式

1. 什么是访问者模式

Visitor 模式也叫访问者模式，是行为模式之一，它分离对象的数据和行为，使用 Visitor 模式，可以不修改已有类的情况下，增加新的操作。

2. 访问者模式的应用示例

比如有一个公园，有一到多个不同的组成部分；该公园存在多个访问者：清洁工 A 负责打扫公园的 A 部分，清洁工 B 负责打扫公园的 B 部分，公园的管理者负责检点各项事务是否完成，上级领导可以视察公园等等。也就是说，对于同一个公园，不同的访问者有不同的行为操作，而且访问者的种类也可能需要根据时间的推移而变化（行为的扩展性）。

根据软件设计的开闭原则（对修改关闭，对扩展开放），我们怎么样实现这种需求呢？

3. 访问者模式的结构

25_访问者模式 - 图1

4. 访问者模式的角色和职责

  1. 访问者角色（Visitor）：为该对象结构中具体元素角色声明一个访问操作接口。该操作接口的名字和参数标识了发送访问请求给具体访问者的具体元素角色。这样访问者就可以通过该元素角色的特定接囗直接访问它。
  2. 具体访问者角色（Concrete visitor）：实现每个由访问者角色（ Visitor）声明的操作。
  3. 元素角色（Element）：定义一个 Accept 操作，它以一个访问者为参数。
  4. 具体元素角色（Concrete element）：实现由元素角色提供的 Accept 操作。
  5. 对象结构角色（Object Structure）：这是使用访问者模式必备的角色。它要具备以下特征：能枚举它的元素；可以提供一个高层的接囗以允许该访间者访问它的元素；可以是一个复合（组合模式）或是一个集合，如一个列表或一个无序集合。

5. 代码演示

  1. public interface ParkElement {
  2.     void accept(Visitor visitor);
  3. }
  1. public class ParkA implements ParkElement {
  2.     private String name;
  3.     @Override
  4.     public void accept(Visitor visitor) {
  5.         visitor.visit(this);
  6.     }
  7.     public String getName() {
  8.         return name;
  9.     }
  10.     public void setName(String name) {
  11.         this.name = name;
  12.     }
  13. }
  1. public class ParkB implements ParkElement {
  2.     private String name;
  3.     @Override
  4.     public void accept(Visitor visitor) {
  5.         visitor.visit(this);
  6.     }
  7.     public String getName() {
  8.         return name;
  9.     }
  10.     public void setName(String name) {
  11.         this.name = name;
  12.     }
  13. }
  1. public class Park implements ParkElement {
  2.     private String name;
  3.     private final ParkA parkA;
  4.     private final ParkB parkB;
  5.     public Park() {
  6.         this.parkA = new ParkA();
  7.         this.parkB = new ParkB();
  8.         this.parkA.setName("A");
  9.         this.parkB.setName("B");
  10.     }
  11.     @Override
  12.     public void accept(Visitor visitor) {
  13.         visitor.visit(this);
  14.         this.parkA.accept(visitor);
  15.         this.parkB.accept(visitor);
  16.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  23. }
  1. public interface Visitor {
  2.     void visit(Park park);
  3.     void visit(ParkA parkA);
  4.     void visit(ParkB parkB);
  5. }
  1. public class VisitorA implements Visitor {
  2.     @Override
  3.     public void visit(Park park) {
  4.     }
  5.     @Override
  6.     public void visit(ParkA parkA) {
  7.         System.out.println("清洁工A：完成公园" + parkA.getName() + "的卫生");
  8.     }
  9.     @Override
  10.     public void visit(ParkB parkB) {
  11.     }
  12. }
  1. public class VisitorB implements Visitor {
  2.     @Override
  3.     public void visit(Park park) {
  4.     }
  5.     @Override
  6.     public void visit(ParkA parkA) {
  7.     }
  8.     @Override
  9.     public void visit(ParkB parkB) {
  10.         System.out.println("清洁工B：完成公园" + parkB.getName() + "的卫生");
  11.     }
  12. }
  1. public class VisitorManager implements Visitor {
  2.     @Override
  3.     public void visit(Park park) {
  4.         System.out.println("管理员：负责检查" + park.getName() + "卫生");
  5.     }
  6.     @Override
  7.     public void visit(ParkA parkA) {
  8.         System.out.println("管理员：负责检查公园" + parkA.getName() + "的卫生");
  9.     }
  10.     @Override
  11.     public void visit(ParkB parkB) {
  12.         System.out.println("管理员：负责检查公园" + parkB.getName() + "的卫生");
  13.     }
  14. }
  1. Park park = new Park();
  2. park.setName("越秀公园");
  3. Visitor visitorA = new VisitorA();
  4. park.accept(visitorA);
  5. Visitor visitorB = new VisitorB();
  6. park.accept(visitorB);
  7. Visitor visitorManager = new VisitorManager();
  8. park.accept(visitorManager);
  1. 清洁工A：完成公园A的卫生
  2. 清洁工B：完成公园B的卫生
  3. 管理员：负责检查越秀公园卫生
  4. 管理员：负责检查公园A的卫生
  5. 管理员：负责检查公园B的卫生