Java Tip: 用Reflection实现Visitor模式

原创 2001年09月13日 19:48:00

Java Tip: 用Reflection实现Visitor模式

概述

Visitor模式的常用之处在于,它将对象集合的结构和对集合所执行的操作分离开来。例如,它可以将一个编译器中的分析逻辑和代码生成逻辑分离开来。有了这样的分离,想使用不同的代码生成器就会很容易。更大的好处还有,其它一些公用程序,如lint,可以在使用分析逻辑的同时免受代码生成逻辑之累。不幸的是,向集合中增加新的对象往往需要修改已经写好的Visitor类。本文提出了一种在Java中实现Visitor模式的更灵活的方法:使用Reflection(反射)。

-------------------------------------------------------------

集合(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模式,使之具有操作对象结构的强大功能,并在增加新Visitable类型方面提供灵活性。希望你在以后的程序设计中能够应用这一模式。

用Reflection实现Visitor模式

概述Visitor模式的常用之处在于,它将对象集合的结构和对集合所执行的操作分离开来。例如,它可以将一个编译器中的分析逻辑和代码生成逻辑分离开来。有了这样的分离,想使用不同的代码生成器就会很容易。更大...
  • shang_soft
  • shang_soft
  • 2007年10月29日 20:52
  • 165

JAVA设计模式之Visitor模式

一个集合(Collection)中,可以包含一个Car,也可以包含一个Cat,对于不同类型的元素,他们的行为也不尽相同,比如,Car可能有start()行为,而Cat可能有eat()的行为。可是对于C...
  • chenjie19891104
  • chenjie19891104
  • 2011年05月04日 13:46
  • 13507

Java设计模式(三) Visitor(访问者)模式及多分派场景应用

基本概念Visitor 封装一些作用于数据结构中的各元素的操作,不同的操作可以借助新的visitor实现,降低了操作间的耦合性 访问者可以将数据结构和对数据的操作解耦,使得增加对数据结构的操作不需要取...
  • qq_24451605
  • qq_24451605
  • 2016年04月14日 15:32
  • 5198

JAVA设计模式十四--Visitor(访问者模式)

访问者模式(Visitor Pattern)是GoF提出的23种设计模式中的一种,属于行为模式。 据《大话设计模式》中说算是最复杂也是最难以理解的一种模式了。    定义(源于GoF《Design...
  • hfmbook
  • hfmbook
  • 2012年06月22日 10:20
  • 8931

浅谈JAVA设计模式之——访问者模式(Visitor)

一、概述 表示一个作用于某对象结构中的各元素的操作。 它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 二、适用性 1.一个对象结构包含很多类对象,它们有不同的接口,而你想对这些对象实...
  • l1028386804
  • l1028386804
  • 2015年05月09日 14:27
  • 1072

设计模式:Visitor模式

Visitor模式是一个用起来很简单,理解起来可能稍微有一点困难的模式。不过明白了之后就清楚了,其实也是非常的简单。问题需要向对象结构中增加新的方法,但是增加起来会很费劲或者会破坏设计。 案例举一个例...
  • superbeck
  • superbeck
  • 2010年02月25日 14:02
  • 10970

设计模式总结之Visitor Pattern(访问者模式)

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。...
  • cooldragon
  • cooldragon
  • 2016年08月12日 12:10
  • 4124

我所理解的设计模式(C++实现)——访问者模式(Visitor Pattern)

我们去银行柜台办业务,一般情况下会开几个个人业务柜台的,你去其中任何一个柜台办理都是可以的。我们的访问者模式可以很好付诸在这个场景中:对于银行柜台来说,他们是不用变化的,就是说今天和明天提供个人业务的...
  • LCL_data
  • LCL_data
  • 2013年09月12日 16:07
  • 18415

Java进阶之reflection(反射机制)——反射概念与基础

这里写链接内容  反射机制是Java动态性之一,而说到动态性首先得了解动态语言。那么何为动态语言?一、动态语言动态语言,是指程序在运行时可以改变其结构:新的函数可以引进,已有的函数可以被删除等结构上的...
  • xu__cg
  • xu__cg
  • 2016年10月20日 22:00
  • 2608

设计模式(行为型)之访问者模式(Visitor Pattern)

访问者模式是一种较为复杂的行为型设计模式,它包含访问者和被访问元素两个主要组成部分,这些被访问的元素通常具有不同的类型,且不同的访问者可以对它们进行不同的访问操作。访问者模式使得用户可以在不修改现有系...
  • yanbober
  • yanbober
  • 2015年05月06日 17:11
  • 3230
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java Tip: 用Reflection实现Visitor模式
举报原因:
原因补充:

(最多只允许输入30个字)