Java中怎么用Reflection实现Visitor模式

这篇文章主要为大家展示了“Java中怎么用Reflection实现Visitor模式”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“Java中怎么用Reflection实现Visitor模式”这篇文章吧。

集合(Collection)普遍应用于面向对象编程中，但它也经常引发一些和代码有关的疑问。例如，"如果一个集合存在不同的对象，该如何对它执行操作？"

一种方法是，对集合中的每个元素进行迭代，然后基于所在的类，对每个元素分别执行对应的操作。这会很难办，特别是，如果你不知道集合中有什么类型的对象。例如，假设想打印集合中的元素，你可以写出如下的一个方法(method)：

public void messyPrintCollection(Collection collection) {
  Iterator iterator = collection.iterator()
  while (iterator.hasNext())
  System.out.println(iterator.next().toString())
}

这看起来够简单的了。它只不过调用了object.toString()方法，然后打印出对象，对吗？但如果有一组哈希表怎么办？事情就会开始变得复杂起来。你必须检查从集合中返回的对象的类型：

public void messyPrintCollection(Collection collection) {
  Iterator iterator = collection.iterator()
  while (iterator.hasNext()) {
  Object o = iterator.next();
  if (o instanceof Collection)
  messyPrintCollection((Collection)o);
  else
  System.out.println(o.toString());
  }
}

不错，现在已经解决了嵌套集合的问题，但它需要对象返回String，如果有其它不返回String的对象存在怎么办？如果想在String对象前后添加引号以及在Float后添加f又该怎么办？代码还是越来越复杂：

public void messyPrintCollection(Collection collection) {
  Iterator iterator = collection.iterator()
  while (iterator.hasNext()) {
  Object o = iterator.next();
  if (o instanceof Collection)
  messyPrintCollection((Collection)o);
  else if (o instanceof String)
  System.out.println("'"+o.toString()+"'");
  else if (o instanceof Float)
  System.out.println(o.toString()+"f");
  else
  System.out.println(o.toString());
  }
}

可以看到，事情的复杂度会急剧增长。你当然不想让一段代码到处充斥着if-else语句！那怎么避免呢？Visitor模式可以帮你。

要实现Visitor模式，得为访问者建立一个Visitor接口，还要为被访问的集合建立一个Visitable接口。然后，让具体类实现Visitor和Visitable接口。这两个接口如下所示：

public interface Visitor
{
  public void visitCollection(Collection collection);
  public void visitString(String string);
  public void visitFloat(Float float);
}

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

对于具体的String，可能是这样：

public class VisitableString implements Visitable
{
  private String value;
  public VisitableString(String string) {
  value = string;
  }
  public void accept(Visitor visitor) {
  visitor.visitString(this);
  }
}

在accept方法中，对this类型调用正确的visitor方法：

visitor.visitString(this)

这样，就可以如下实现具体的Visitor：

public class PrintVisitor implements Visitor
{
  public void visitCollection(Collection collection) {
  Iterator iterator = collection.iterator()
  while (iterator.hasNext()) {
  Object o = iterator.next();
  if (o instanceof Visitable)
  ((Visitable)o).accept(this);
  }

  public void visitString(String string) {
  System.out.println("'"+string+"'");
  }

  public void visitFloat(Float float) {
  System.out.println(float.toString()+"f");
  }
}

实现VisitableFloat和VisitableCollection类的时候，它们也是各自调用合适的Visitor方法，所得到的效果和前面那个用了if-else的messyPrintCollection方法一样，但这里的手法更干净。在visitCollection()中，调用的是Visitable.accept(this)，然后这个调用又返回去调用一个合适的Visitor方法。这被称做 "双分派"；即，Visitor先调用了Visitable类中的方法，这个方法又回调到Visitor类中。

虽然通过实现visitor消除了if-else语句，却也增加了很多额外的代码。最初的String和Float对象都要用实现了Visitable接口的对象进行包装。这有点讨厌，但一般说来不是问题，因为你可以让经常被访问的集合只包含那些实现了Visitable接口的对象。

但似乎这还是额外的工作。更糟糕的是，当增加一个新的Visitable类型如VisitableInteger时，会发生什么呢？这是Visitor模式的一个重大缺陷。如果想增加一个新的Visitable对象，就必须修改Visitor接口，然后对每一个Visitor实现类中的相应的方法一一实现。你可以用一个带缺省空操作的Visitor抽象基类来代替接口。那就很象Java GUI中的Adapter类。那个方法的问题在于，它需要占用单继承；而你往往想保留单继承，让它用于其它什么东西，比如继承StringWriter。那个方法还有限制，它只能够成功访问Visitable对象。

幸运的是，Java可以让Visitor模式更灵活，使得你可以随心所欲地增加Visitable对象。怎么做？答案是，使用Reflection。比如，可以设计这样一个ReflectiveVisitor接口，它只需要一个方法：

public interface ReflectiveVisitor {
  public void visit(Object o);
}

就这样，很简单。至于Visitable，还是和前面一样，我过一会儿再说。现在先用Reflection来实现PrintVisitor：

public class PrintVisitor implements ReflectiveVisitor {
  public void visitCollection(Collection collection)
  { ... same as above ... }
  public void visitString(String string)
  { ... same as above ... }
  public void visitFloat(Float float)
  { ... same as above ... }

  public void default(Object o)
  {
  System.out.println(o.toString());
  }

  public void visit(Object o) {
  // Class.getName() returns package information as well.
  // This strips off the package information giving us
  // just the class name
  String methodName = o.getClass().getName();
  methodName = "visit"+
  methodName.substring(methodName.lastIndexOf('.')+1);
  // Now we try to invoke the method visit
  try {
  // Get the method visitFoo(Foo foo)
  Method m = getClass().getMethod(methodName,
  new Class[] { o.getClass() });
  // Try to invoke visitFoo(Foo foo)
  m.invoke(this, new Object[] { o });
  } catch (NoSuchMethodException e) {
  // No method, so do the default implementation
  default(o);
  }
  }
}

现在不需要Visitable包装类。仅仅只是调用visit()，请求就会分发到正确的方法上。很不错的一点是，只要认为适合，visit()就可以分发。这并非必须使用reflection--它可以使用其它完全不同的机制。

新的PrintVisitor中，有针对Collection，String和Float而写的方法，但然后它又在catch语句中捕捉所有未处理的类型。你要扩展visit()方法，使得它也能够处理所有的父类。首先，得增加一个新方法，称为getMethod(Class c)，它返回的是要调用的方法；为了找到这个相匹配的方法，先在类c的所有父类中寻找，然后在类c的所有接口中寻找。

protected Method getMethod(Class c) {
  Class newc = c;
  Method m = null;
  // Try the superclasses
  while (m == null && newc != Object.class) {
  String method = newc.getName();
  method = "visit" + method.substring(method.lastIndexOf('.') + 1);
  try {
  m = getClass().getMethod(method, new Class[] {newc});
  } catch (NoSuchMethodException e) {
  newc = newc.getSuperclass();
  }
  }
  // Try the interfaces.  If necessary, you
  // can sort them first to define 'visitable' interface wins
  // in case an object implements more than one.
  if (newc == Object.class) {
  Class[] interfaces = c.getInterfaces();
  for (int i = 0; i < interfaces.length; i++) {
  String method = interfaces[i].getName();
  method = "visit" + method.substring(method.lastIndexOf('.') + 1);
  try {
  m = getClass().getMethod(method, new Class[] {interfaces[i]});
  } catch (NoSuchMethodException e) {}
  }
  }
  if (m == null) {
  try {
  m = thisclass.getMethod("visitObject", new Class[] {Object.class});
  } catch (Exception e) {
  // Can't happen
  }
  }
  return m;
}

看起来有些复杂，其实不然。实际上，它只是根据传进来的类名去寻找相应的方法而已。如果没找到，就在父类中找；还没找到，再到接口中找。最后，就拿visitObject()作为缺省。

注意，为了照顾那些熟悉传统Visitor模式的读者，我对方法的名称采用了传统的命名方式。但正如你们一些人所注意到的，把所有的方法命名为 "visit" 然后让参数类型作为区分会更高效。但这样做的话，你得把主visit(Object o)方法的名字改为dispatch(Object o)之类。否则，就没有一个缺省方法可用了，你就得在调用visit(Object o)时将类型转换为Object，以保证visit采用的是正确的调用方式。

现在可以修改visit()方法，以利用getMethod()：

public void visit(Object object) {
  try {
  Method method = getMethod(getClass(), object.getClass());
  method.invoke(this, new Object[] {object});
  } catch (Exception e) { }
}

现在，visitor对象的功能强大多了。你可以传进任何对象，并且有某个方法处理它。另外一个好处是，还有一个缺省方法visitObject(Object o)，它可以捕捉任何未知的对象。再多花点工夫，你还可以写出一个visitNull()方法。

我在上面对Visitable接口避而不谈自有原因。传统Visitor模式的另一个好处是，它允许Visitable对象来控制对对象结构的访问。例如，假设有一个实现了Visitable的TreeNode对象，你可以让一个accept()方法来遍历它的左右节点：

public void accept(Visitor visitor) {
  visitor.visitTreeNode(this);
  visitor.visitTreeNode(leftsubtree);
  visitor.visitTreeNode(rightsubtree);
}

这样，只用对Visitor类再进行一点修改，就可以进行Visitable控制访问：

public void visit(Object object) throws Exception
{
  Method method = getMethod(getClass(), object.getClass());
  method.invoke(this, new Object[] {object});
  if (object instanceof Visitable)
  {
  callAccept((Visitable) object);
  }
}
public void callAccept(Visitable visitable) {
  visitable.accept(this);
}

如果已经实现了一个Visitable对象结构，可以保留callAccept()方法并使用Visitable控制访问。如果想在visitor中访问结构，只需改写callAccept()方法，使之什么也不做。

想让数个不同的访问者对同一个对象集合进行访问时，Visitor模式可以发挥它的强大作用。假设已经有一个解释器，一个中缀写作器，一个后缀写作器，一个XML写作器和一个sql写作器，它们都作用在同一个对象集合上。那么，也可以很容易地为相同的对象集合写出一个前缀写作器和一个SOAP写作器。另外，这些写作器可以正常地和它们所不知道的对象工作；当然，如果愿意，也可以让它们抛出异常。

以上是“Java中怎么用Reflection实现Visitor模式”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注亿速云行业资讯频道！