16.7 访问器模式

接下来，让我们思考如何将具有完全不同目标的一个设计模式应用到垃圾归类系统。

对这个模式，我们不再关心在系统中加入新型Trash时的优化。事实上，这个模式使新型Trash的添加显得更加复杂。假定我们有一个基本类结构，它是固定不变的；它或许来自另一个开发者或公司，我们无权对那个结构进行任何修改。然而，我们又希望在那个结构里加入新的多态性方法。这意味着我们一般必须在基类的接口里添加某些东西。因此，我们目前面临的困境是一方面需要向基类添加方法，另一方面又不能改动基类。怎样解决这个问题呢？

“访问器”（Visitor）模式使我们能扩展基本类型的接口，方法是创建类型为Visitor的一个独立的类结构，对以后需对基本类型采取的操作进行虚拟。基本类型的任务就是简单地“接收”访问器，然后调用访问器的动态绑定方法。看起来就象下面这样：

16.7 访问器模式 - 图1

现在，假如v是一个指向Aluminum（铝制品）的Visitable引用，那么下述代码：

  1. PriceVisitor pv = new PriceVisitor();
  2. v.accept(pv);

会造成两个多态性方法调用：第一个会选择accept()的Aluminum版本；第二个则在accept()里——用基类Visitor引用v动态调用visit()的特定版本时。

这种配置意味着可采取Visitor的新子类的形式将新的功能添加到系统里，没必要接触Trash结构。这就是“访问器”模式最主要的优点：可为一个类结构添加新的多态性功能，同时不必改动结构——只要安装好了accept()方法。注意这个优点在这儿是有用的，但并不一定是我们在任何情况下的首选方案。所以在最开始的时候，就要判断这到底是不是自己需要的方案。

现在注意一件没有做成的事情：访问器方案防止了从主控Trash序列向单独类型序列的归类。所以我们可将所有东西都留在单主控序列中，只需用适当的访问器通过那个序列传递，即可达到希望的目标。尽管这似乎并非访问器模式的本意，但确实让我们达到了很希望达到的一个目标（避免使用RTTI）。

访问器模式中的双生分发负责同时判断Trash以及Visitor的类型。在下面的例子中，大家可看到Visitor的两种实现方式：PriceVisitor用于判断总计及价格，而WeightVisitor用于跟踪重量。

可以看到，所有这些都是用回收程序一个新的、改进过的版本实现的。而且和DoubleDispatch.java一样，Trash类被保持孤立，并创建一个新接口来添加accept()方法：

  1. //: Visitable.java
  2. // An interface to add visitor functionality to
  3. // the Trash hierarchy without modifying the
  4. // base class.
  5. package c16.trashvisitor;
  6. import c16.trash.*;
  8. interface Visitable {
  9.   // The new method:
  10.   void accept(Visitor v);
  11. } ///:~

Aluminum，Paper，Glass以及Cardboard的子类型实现了accept()方法：

  1. //: VAluminum.java
  2. // Aluminum for the visitor pattern
  3. package c16.trashvisitor;
  4. import c16.trash.*;
  6. public class VAluminum extends Aluminum
  7.     implements Visitable {
  8.   public VAluminum(double wt) { super(wt); }
  9.   public void accept(Visitor v) {
  10.     v.visit(this);
  11.   }
  12. } ///:~
  13. //: VPaper.java
  14. // Paper for the visitor pattern
  15. package c16.trashvisitor;
  16. import c16.trash.*;
  18. public class VPaper extends Paper
  19.     implements Visitable {
  20.   public VPaper(double wt) { super(wt); }
  21.   public void accept(Visitor v) {
  22.     v.visit(this);
  23.   }
  24. } ///:~
  25. //: VGlass.java
  26. // Glass for the visitor pattern
  27. package c16.trashvisitor;
  28. import c16.trash.*;
  30. public class VGlass extends Glass
  31.     implements Visitable {
  32.   public VGlass(double wt) { super(wt); }
  33.   public void accept(Visitor v) {
  34.     v.visit(this);
  35.   }
  36. } ///:~
  37. //: VCardboard.java
  38. // Cardboard for the visitor pattern
  39. package c16.trashvisitor;
  40. import c16.trash.*;
  42. public class VCardboard extends Cardboard
  43.     implements Visitable {
  44.   public VCardboard(double wt) { super(wt); }
  45.   public void accept(Visitor v) {
  46.     v.visit(this);
  47.   }
  48. } ///:~

由于Visitor基类没有什么需要实在的东西，可将其创建成一个接口：

  1. //: Visitor.java
  2. // The base interface for visitors
  3. package c16.trashvisitor;
  4. import c16.trash.*;
  6. interface Visitor {
  7.   void visit(VAluminum a);
  8.   void visit(VPaper p);
  9.   void visit(VGlass g);
  10.   void visit(VCardboard c);
  11. } ///:~
  13. c16.TrashVisitor.VGlass:54
  14. c16.TrashVisitor.VPaper:22
  15. c16.TrashVisitor.VPaper:11
  16. c16.TrashVisitor.VGlass:17
  17. c16.TrashVisitor.VAluminum:89
  18. c16.TrashVisitor.VPaper:88
  19. c16.TrashVisitor.VAluminum:76
  20. c16.TrashVisitor.VCardboard:96
  21. c16.TrashVisitor.VAluminum:25
  22. c16.TrashVisitor.VAluminum:34
  23. c16.TrashVisitor.VGlass:11
  24. c16.TrashVisitor.VGlass:68
  25. c16.TrashVisitor.VGlass:43
  26. c16.TrashVisitor.VAluminum:27
  27. c16.TrashVisitor.VCardboard:44
  28. c16.TrashVisitor.VAluminum:18
  29. c16.TrashVisitor.VPaper:91
  30. c16.TrashVisitor.VGlass:63
  31. c16.TrashVisitor.VGlass:50
  32. c16.TrashVisitor.VGlass:80
  33. c16.TrashVisitor.VAluminum:81
  34. c16.TrashVisitor.VCardboard:12
  35. c16.TrashVisitor.VGlass:12
  36. c16.TrashVisitor.VGlass:54
  37. c16.TrashVisitor.VAluminum:36
  38. c16.TrashVisitor.VAluminum:93
  39. c16.TrashVisitor.VGlass:93
  40. c16.TrashVisitor.VPaper:80
  41. c16.TrashVisitor.VGlass:36
  42. c16.TrashVisitor.VGlass:12
  43. c16.TrashVisitor.VGlass:60
  44. c16.TrashVisitor.VPaper:66
  45. c16.TrashVisitor.VAluminum:36
  46. c16.TrashVisitor.VCardboard:22

程序剩余的部分将创建特定的Visitor类型，并通过一个Trash对象列表发送它们：

  1. //: TrashVisitor.java
  2. // The "visitor" pattern
  3. package c16.trashvisitor;
  4. import c16.trash.*;
  5. import java.util.*;
  7. // Specific group of algorithms packaged
  8. // in each implementation of Visitor:
  9. class PriceVisitor implements Visitor {
  10.   private double alSum; // Aluminum
  11.   private double pSum; // Paper
  12.   private double gSum; // Glass
  13.   private double cSum; // Cardboard
  14.   public void visit(VAluminum al) {
  15.     double v = al.weight() * al.value();
  16.     System.out.println(
  17.       "value of Aluminum= " + v);
  18.     alSum += v;
  19.   }
  20.   public void visit(VPaper p) {
  21.     double v = p.weight() * p.value();
  22.     System.out.println(
  23.       "value of Paper= " + v);
  24.     pSum += v;
  25.   }
  26.   public void visit(VGlass g) {
  27.     double v = g.weight() * g.value();
  28.     System.out.println(
  29.       "value of Glass= " + v);
  30.     gSum += v;
  31.   }
  32.   public void visit(VCardboard c) {
  33.     double v = c.weight() * c.value();
  34.     System.out.println(
  35.       "value of Cardboard = " + v);
  36.     cSum += v;
  37.   }
  38.   void total() {
  39.     System.out.println(
  40.       "Total Aluminum: $" + alSum + "\n" +
  41.       "Total Paper: $" + pSum + "\n" +
  42.       "Total Glass: $" + gSum + "\n" +
  43.       "Total Cardboard: $" + cSum);
  44.   }
  45. }
  47. class WeightVisitor implements Visitor {
  48.   private double alSum; // Aluminum
  49.   private double pSum; // Paper
  50.   private double gSum; // Glass
  51.   private double cSum; // Cardboard
  52.   public void visit(VAluminum al) {
  53.     alSum += al.weight();
  54.     System.out.println("weight of Aluminum = "
  55.         + al.weight());
  56.   }
  57.   public void visit(VPaper p) {
  58.     pSum += p.weight();
  59.     System.out.println("weight of Paper = "
  60.         + p.weight());
  61.   }
  62.   public void visit(VGlass g) {
  63.     gSum += g.weight();
  64.     System.out.println("weight of Glass = "
  65.         + g.weight());
  66.   }
  67.   public void visit(VCardboard c) {
  68.     cSum += c.weight();
  69.     System.out.println("weight of Cardboard = "
  70.         + c.weight());
  71.   }
  72.   void total() {
  73.     System.out.println("Total weight Aluminum:"
  74.         + alSum);
  75.     System.out.println("Total weight Paper:"
  76.         + pSum);
  77.     System.out.println("Total weight Glass:"
  78.         + gSum);
  79.     System.out.println("Total weight Cardboard:"
  80.         + cSum);
  81.   }
  82. }
  84. public class TrashVisitor {
  85.   public static void main(String[] args) {
  86.     Vector bin = new Vector();
  87.     // ParseTrash still works, without changes:
  88.     ParseTrash.fillBin("VTrash.dat", bin);
  89.     // You could even iterate through
  90.     // a list of visitors!
  91.     PriceVisitor pv = new PriceVisitor();
  92.     WeightVisitor wv = new WeightVisitor();
  93.     Enumeration it = bin.elements();
  94.     while(it.hasMoreElements()) {
  95.       Visitable v = (Visitable)it.nextElement();
  96.       v.accept(pv);
  97.       v.accept(wv);
  98.     }
  99.     pv.total();
  100.     wv.total();
  101.   }
  102. } ///:~

注意main()的形状已再次发生了变化。现在只有一个垃圾（Trash）筒。两个Visitor对象被接收到序列中的每个元素内，它们会完成自己份内的工作。Visitor跟踪它们自己的内部数据，计算出总重和价格。

最好，将东西从序列中取出的时候，除了不可避免地向Trash转换以外，再没有运行期的类型验证。若在Java里实现了参数化类型，甚至那个转换操作也可以避免。

对比之前介绍过的双重分发方案，区分这两种方案的一个办法是：在双重分发方案中，每个子类创建时只会重载其中的一个重载方法，即add()。而在这里，每个重载的visit()方法都必须在Visitor的每个子类中进行重载。

(1) 更多的结合？

这里还有其他许多代码，Trash结构和Visitor结构之间存在着明显的“结合”（Coupling）关系。然而，在它们所代表的类集内部，也存在着高度的凝聚力：都只做一件事情（Trash描述垃圾或废品，而Visitor描述对垃圾采取什么行动）。作为一套优秀的设计模式，这无疑是个良好的开端。当然就目前的情况来说，只有在我们添加新的Visitor类型时才能体会到它的好处。但在添加新类型的Trash时，它却显得有些碍手碍脚。

类与类之间低度的结合与类内高度的凝聚无疑是一个重要的设计目标。但只要稍不留神，就可能妨碍我们得到一个本该更出色的设计。从表面看，有些类不可避免地相互间存在着一些“亲密”关系。这种关系通常是成对发生的，可以叫作“对联”（Couplet）——比如集合和迭代器（Enumeration）。前面的Trash-Visitor对似乎也是这样的一种“对联”。