Java资源网
首
页		 | JAVA基础 | 环境配置 | JDBC | 线程技术 | Socket编程 | JavaMail | JAVA与XML | 设计模式 | 技术新闻 | Java认证 | 程序人生 软件下载
| JSP&Servlet | Spring | Struts | Hibernate | JBuilder | Eclipse | WebService | EJB技术 | J2ME开发 | 应用服务器 | JXTA | Ajax
Articles search文章搜索
   关键字:
   类　别:
       
New download 最新下载
· [组件]HTML Parser 1.5
· [教程]WebSphere Studio应用教程
· [组件]JDom 1.0
· [工具]Junit3.8.1
· [教程]EJB编程及J2EE系统架构和设计
· [教程]EJB教程
· [教程]J2EE Tutorial中文版
· [教程]Java编程思想2(英文)
· [教程]java编程思想（完整版）
· [教程]Java网络编程
New articles 最新文章
· 设计移动 Web 服务
· 解析XML的时候完全忽略DTD
· 理解XML Schema XML Schema 初步
· 标签库的深入研究
· 提升JSP应用程序的七大绝招
· 如何使用JDOM对XML文件进行操作
· 处理XML字符串中特殊字符
· 利用Digester把XML转换成为Java对象
· 使用WebService 和RMI远程协作
· 使用Axis开发Web Service程序
Articles top 热门文章
· Eclipse基础－－plugin插件安装(6644)
· eclipse+tomcat+lomboz的安装配置说明(4774)
· Java程序员就业前景(4584)
· Windows下JAVA环境变量的设置祥解(3788)
· Tomcat下JSP、Servlet和JavaBean环境的配置(3716)
· 使用links方式安装Eclipse插件(3698)
· 一个老程序员的心理话(3533)
· linux下jdk的安装与配置(3459)
· 初学者入门：Structs中基本配置入门(3334)
· Eclipse 运行命令行参数大全(3084)
您的位置:首页>>设计模式>>在组合（Composite）模式中实现访问者（Visitor）模式
在组合（Composite）模式中实现访问者（Visitor）模式
2007-04-13   来源:www.javaresearch.org  作者:未知

在组合（Composite）模式中实现访问者（Visitor）模式


   本文从一个给定的实现了组合（Composite）模式的例子开始，说明怎么在这个数据结构上实现业务逻辑代码。依次介绍了非面向对象的方式、在组合结构中加入方法、使用访问者（Visitor）模式以及用改进后的访问者（Visitor）模式来实现相同的业务逻辑代码，并且对于每种实现分别给出了优缺点。
读者定位于具有Java程序开发和设计模式经验的开发人员。

读者通过本文可以学到如何在组合（Composite）模式中实现各种不同的业务方法及其优缺点。

组合（Composite）模式



组合模式是结构型模式中的一种。GOF的《设计模式》一书中对使用组合模式的意图描述如下：将对象组合成树形结构以表示"部分-整体"的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。

组合模式应用广泛。根据GOF中对组合模式的定义，Composite模式一般由Component接口、Leaf类和Composite类组成。现在需要对一个软件产品管理系统的实体建模：某公司开发了一系列软件集（SoftwareSet），包含了多种品牌（Brand）的软件产品，就象IBM提供了Lotus、WebsPhere等品牌。每个品牌下面又有各种产品（Product），如IBM的Lotus下面有Domino Server/Client产品等。建模后的类图如下（代码可以参见随本文带的附件中，包com.test.entity下所有的源文件）：
 
如图所示：

(1)接口SoftwareComponent就是对应于组合模式中的Component接口，它定义了所有类共有接口的缺省行为
(2)AbsSoftwareComposite类对应于Composite类，并且是抽象类，所有可以包含子节点的类都扩展这个类。这个类的主要功能是用来存储子部件，实现了接口中的方法，部分可以重用的代码写在此类中
(3)SoftwareSet类继承于AbsSoftwareComposite类，对应于软件集，软件集下直接可以包含品牌（Brand），也可以直接包含不属于任何品牌的产品（Product）
(4)Brand类继承于AbsSoftwareComposite类，对应于品牌，包含了品牌名属性，并且用来存储Product类的实例
(5)Product类就是对应的Leaf类，表示叶子节点，叶子节点没有子节点

用不同的方法实现业务逻辑


数据结构建立好之后，需要在这个数据结构上添加方法实现业务逻辑。比如现在的这个例子中，有这样的需求：给定一些用户选择好的产品，需要计算出这些选中后软件的总价格。下面开始介绍如何使用各种不同的方法来实现这个业务逻辑。

非面向对象的编程方式

这种方式下，编程思路最简单：遍历SoftwareSet实例中的所有节点，如果遍历到的当前对象是Product的话就累加，否则继续遍历下一层直到全部遍历完毕。代码片断如下：
  1. /**
  2.  * 取得某个SoftwareComponent对象下面所有Product的价格
  3.  * @param brand
  4.  * @return
  5.  */
  6. public double getTotalPrice(SoftwareComponent softwareComponent) {
  7.     SoftwareComponent temp = softwareComponent;
  8.     double totalPrice = 0;
  9.     //如果传入的实例是SoftwareSet的类型
  10.     if (temp instanceof SoftwareSet) {
  11.         Iterator it = ((SoftwareSet) softwareComponent).getChilds()
  12.                 .iterator();
  13.         while (it.hasNext()) {//遍历
  14.             temp = (SoftwareComponent) it.next();
  15.             //如果子对象是Product类型的，直接累加
  16.             if (temp instanceof Product) {
  17.                 Product product = (Product) temp;
  18.                 totalPrice += product.getPrice();
  19.             } else if (temp instanceof Brand) { 
  20.             //如果子对象是Brand类型的，则遍历Brand下面所有的产品并累加
  21.                 Brand brand = (Brand) temp;
  22.                 totalPrice += getBrandPrice(brand);
  23.             }
  24.         }
  25.     } else if (temp instanceof Brand) {
  26.         //如果传入的实例是SoftwareSet的类型，则遍历Brand下面所有的产品并累加
  27.         totalPrice += getBrandPrice((Brand) temp);
  28.     } else if (temp instanceof Product) {
  29.         //如果子对象是Product类型的，直接返回价格
  30.         return ((Product) temp).getPrice();
  31.     }
  32.     return totalPrice;
  33. }
  35. /**
  36.  * 取得某个Brand对象下面所有Product的价格
  37.  * @param brand
  38.  * @return
  39.  */
  40. private double getBrandPrice(Brand brand) {
  41.     Iterator brandIt = brand.getChilds().iterator();
  42.     double totalPrice = 0;
  43.     while (brandIt.hasNext()) {
  44.         Product product = (Product) brandIt.next();
  45.         totalPrice += product.getPrice();
  46.     }
  47.     return totalPrice;
  48. }
 
这段代码的好处是实现业务逻辑的时候无需对前面已经定好的数据结构做改动，并且效率比较高；缺点是代码凌乱而且频繁使用了instanceof判断类型和强制类型转换，代码的可读性不强，如果层次多了代码就更加混乱。

面向对象的编程方式（将计算价格的方法加入数据结构中）

下面我们采用面向对象的方式，可以这么做：在接口SoftWareComponent中加入一个方法，名叫getTotalPrice，方法的声明如下：
  1. /**
  2.  * 返回该节点中所有子节点对象的价格之和
  3.  * @return
  4.  */
  5. public double getTotalPrice();

由于类Brand和SoftwareSet都继承了AbsSoftwareComposite，我们只需在类AbsSoftwareComposite中实现该方法getTotalPrice方法即可，如下：
  1. public double getTotalPrice() {
  2.     Iterator it = childs.iterator();
  3.     double price = 0;
  4.     while (it.hasNext()) {
  5.         SoftwareComponent softwareComponent = (SoftwareComponent) it.next();
  6.                        //自动递归调用各个对象的getTotalPrice方法并累加
  7.         price += softwareComponent.getTotalPrice();
  8.     }
  9.     return price;
  10. }


在Product类中实现如下：
  1. public double getTotalPrice(){
  2.     return price;
  3. }
 
在外面需要取得某个对象的总价格的时候只需这样写（在本文的例子com.test.business.SoftwareManager中可以找到这段代码）：
  1. // getMockData()方法返回数据
  2. SoftwareComponent data = getMockData();
  3. //只需直接调用data对象的getTotalPrice 方法就可以返回该对象下所有product对象的价格
  4. double price = data. getTotalPrice();
  5. //找到某个对象后直接调用其getTotalPrice方法也可以返回总价格
  6. price = data. findSoftwareComponentByID("id").getTotalPrice();


现在把业务逻辑的实现都放在了数据结构中（组合模式的结构中），好处很明显，每个类只管理自己相关的业务代码的实现，跟前面举的面向过程方式的实现方式相比，没有了instanceof和强制类型转换。但是不好的地方是如果需要增加新的业务方法的话就很麻烦，必须在接口SoftWareComponent中首先声明该方法，然后在各个子类中实现并且重新编译。

使用访问者模式



使用访问者模式就能解决上面提到的问题：如果要经常增加或者删除业务功能方法的话，需要频繁地对程序进行重新实现和编译。根据面向对象设计原则之一的SRP（单一职责原则）原则，如果一个类承担了多于一个的职责，那么引起该类变化的原因就会有多个，就会导致脆弱的设计，在发生变化时，原有的设计可能会遭到意想不到的破坏。下面我们引入了一个叫做Visitor的接口，该接口中定义了针对各个子类的访问方法，如下所示：
  1. public interface Visitor {
  2.     public void visitBrand(Brand brand);
  3.     public void visitSoftwareSet(SoftwareSet softwareSet);
  4.     public void visitProduct(Product product);
  5. }
 
visitBrand方法是访问Brand对象节点的时候用的，剩下的方法依次类推。并在接口SoftwareComponent中增加一个方法：
  1. public void accept(Visitor visitor);

在SoftwareSet中实现接口中的accept方法，首先直接调用Visitor接口中的visitSoftwareSet方法，传入的参数是本身对象，然后递归调用子对象的accept方法：

  1. public void accept(Visitor visitor) {
  2.     visitor.visitSoftwareSet(this);
  3.     Iterator it = childs.iterator();
  4.     while (it.hasNext()) {
  5.         SoftwareComponent component = (SoftwareComponent)it.next();
  6.         component.accept(visitor);
  7.     }
  8. }
 

在Brand中实现接口中的accept方法，首先直接调用Visitor接口中的visitBrand方法，传入的参数是本身对象，然后递归调用子对象的accept方法：
  1. public void accept(Visitor visitor) {
  2.     visitor.visitBrand(this);
  3.     Iterator it = childs.iterator();
  4.     while (it.hasNext()) {
  5.         SoftwareComponent component = (SoftwareComponent)it.next();
  6.         component.accept(visitor);
  7.     }
  8. }
 

其实在上面的两个类的实现中可以将遍历子节点并调用其accept方法的代码写到父类AbsSoftwareComposite中的某个方法中，然后直接调用父类中的这个方法即可。这里为了解释方便分别写在了两个子类中。

在Product中实现接口中的accept方法，直接调用Visitor接口的visitProduct方法即可：

  1. public void accept(Visitor visitor) {
  2.     visitor.visitProduct(this);
  3. }
 

下面需要实现Visitor接口，类名是CaculateTotalPriceVisitor，实现了计算总价格的业务逻辑，实现代码如下所示：

  1. public class CaculateTotalPriceVisitor implements Visitor {
  2.     private double totalPrice;    
  3.     public void visitBrand(Brand brand) {
  4.     }
  5.     public void visitSoftwareSet(SoftwareSet softwareSet) {
  6.     }
  7.     public void visitProduct(Product product) {
  8.         //每次在组合的结构中碰到Product对象节点的时候，就会调用此方法
  9.         totalPrice += product.getPrice();
  10.     }
  11.     public double getTotalPrice() {
  12.         return totalPrice;
  13.     }
  14. }
 

上面那段代码中，首先在类内定义一个总价格的属性，由于Brand和SoftwareSet都没有价格，因此在实现中，只需在visitProduct方法中累加totalPrice即可。在外面如果需要计算总价格的话这样写（在本文的例子com.test.business.SoftwareManager中可以找到这段代码）：

  1. //建立一个新的Visitor对象
  2. CaculateTotalPriceVisitor visitor = new CaculateTotalPriceVisitor();
  3. //将该visitor对象传到结构中
  4. data.accept(visitor);
  5. //调用visitor对象的getTotalPrice()方法就返回了总价格
  6. double price = visitor.getTotalPrice();
 

下面是它的时序图：在类SoftwareManager中的main方法中，调用软件集对象（data）的accept方法，并将生成的visitor对象传给它。accept方法开始递归调用各个子对象的accept方法。如果当前的对象是SoftwareSet的实例，则调用visitor对象visitSoftwareSet方法，在visitor对象中对该节点的数据进行一些处理，然后返回；依次类推，遍历到Brand对象和Product对象也与此类似。当前的逻辑是计算软件产品的总价格，因此当遍历到Product对象的时候，取出产品的价格并且累加，最后当结构遍历完毕后，调用visitor对象的getTotalPrice方法返回给定软件集对象的（data）的总的价格。如果需要加入一个新的计算逻辑，只实现Visitor接口，并且将该类的实例传给data对象的accept方法就可以实现不同的逻辑方法了。
 
我们可以看到通过访问者模式很好地解决了如何加入新的业务代码而无需重新改动、编译既有代码。但是该模式也不是没有缺点：如果在组合模式中结构加入新的子类的话会导致接口Visitor也跟着改动，导致所有Visitor的子类都需要实现新增的方法。因此这种访问者模式适合于结构不经常变动的情况。

改进访问者模式



前面我们说到了如何使用Visitor模式及使用该模式后的优缺点，下面举具体的例子说明。假设现在客户提出了一个产品集（ProductSet）的概念：随着公司软件版本的增多，需要将同一个版本的产品（Product）都放到产品集（ProductSet）中，而一个品牌包含有多个产品集。因为现在组合结构中增加了一个节点，所以在Visitor接口中也必须随之增加一个叫做visitProductSet的方法，并且会导致原有系统中所有已经实现了Visitor接口的类都需要重新实现并编译。用Java的反射机制可以解决这个问题。

使用Java的Method Reflection机制实现访问者模式

首先我们需要改变一下Visitor接口，接口名叫做ReflectionVisitor，如下所示：

  1. public interface ReflectionVisitor {
  2.     /**
  3.      * 定义了一个访问节点的方法
  4.      * @param softwareComposite
  5.      */
  6.     public void visitSoftwareComposite(Object softwareComposite);
  7. }
 

在现在的接口的方法里，能接受任意的对象（参数是Object）。

下面实现接口ReflectionVisitor，名叫ReflectionVisitorImpl，代码如下所示：
  1. public class ReflectionVisitorImpl implements ReflectionVisitor {
  2.     public void visitSoftwareComposite(Object softwareComposite) {
  3.         //判断是否是null
  4.         if (softwareComposite == null) {
  5.             throw new NullPointerException("The visit node should not be null!");
  6.         }
  7.         //组装class数组，即调用动态方法的时候参数的类型
  8.         Class[] classes = new Class[] { softwareComposite.getClass() };
  9.         //组装与class数组相对应的值
  10.         Object[] objects = new Object[] { softwareComposite };
  11.         try {
  12.             //查找visit方法
  13.             Method m = getClass().getMethod("visit", classes);
  14.             //调用该方法
  15.             m.invoke(this, objects);
  16.         } catch (NoSuchMethodException e) {
  17.             //没有找到相应的方法
  18.             System.out
  19.                     .println("You did not implement the visit method for class:"
  20.                             + softwareComposite.getClass());
  21.         } catch (Exception e) {
  22.             //发生了别的异常
  23.             System.out.println("Catched excepction in visit method.");
  24.             e.printStackTrace();
  25.         }
  26.     }
  27. }
 

这段代码首先判断传入的对象是否是空指针，然后创建class数组和object数组，然后用getMethod方法取得方法名是"visit"、方法的参数是"对象softwareComposite对应的类"的方法，最后调用该方法。调用该方法的时候可能会发生NoSuchMethodException异常，发生这个异常就表明它的子类或者当前类中没有与参数中传入相对应的visit方法。

下面再来写新版本Visitor类，扩展刚写好的那个ReflectionVisitorImpl类，名叫CaculateTotalPriceReflectionVisitor，如下所示：
  1. public class CaculateTotalPriceReflectionVisitor extends ReflectionVisitorImpl {
  2.     private double totalPrice;
  3.     public void visit(Product product) {
  4.         totalPrice += product.getPrice();
  5.     }
  6.     public void visit(SoftwareSet softwareSet) {
  7.         System.out.println("No price for software set.");
  8.     }
  9.     public double getTotalPrice() {
  10.         return totalPrice;
  11.     }
  12. }
 

代码中声明了两个visit方法（因为在类ReflectionVisitorImpl中，查找名为visit、参数与传进去的对象匹配的的方法），一个是给Product的，另外一个是给SoftwareSet的。在这里SoftwareSet中并没有价格，只需当前的对象是类Product的实例的时候将价格累加即可。如果在组合模式的结构中增加了新的类，只需要在ReflectionVisitorImpl的扩展类中声明一个visit方法，该方法的参数是新增加的类，对于文中的例子，只需增加下面的一个方法：

  1. public void visit(ProductSet productSet) {
  2.     //实现的代码
  3. }
 

在组合结构的接口SoftwareComponent中改一下accept方法，参数是修改后的Visitor接口，如下所示：

public void accept(ReflectionVisitor visitor);
 


由于在类SoftwareSet、Brand和ProductSet中实现上面accept方法的代码都一样，因此把代码抽象到上层共有的抽象类AbsSoftwareComposite中，如下所示：

  1. public void accept(ReflectionVisitor visitor) {
  2.     visitor.visitSoftwareComposite(this);
  3.     Iterator it = childs.iterator();
  4.     while (it.hasNext()) {
  5.         SoftwareComponent component = (SoftwareComponent) it.next();
  6.         //递归调用子对象的accept方法
  7.         component.accept(visitor);
  8.     }
  9. }
 


现在如果想在外面要调用的话，代码如下所示（在本文的例子com.test.business.SoftwareManager中可以找到这段代码）：

  1. //建立一个新的Visitor对象
  2. CaculateTotalPriceReflectionVisitor reflectionVisitor 
  3.     = new CaculateTotalPriceReflectionVisitor();
  4. //将该visitor对象传到结构中
  5. data.accept(reflectionVisitor);
  6. //调用visitor对象的getTotalPrice()方法就返回了总价格
  7. double price = reflectionVisitor.getTotalPrice();
 

另外由于没有实现Brand类的visit方法，在组合结构遍历到Brand的节点的时候会抛出NoSuchMethodException异常，就是没有关于该节点方法的实现，在当前的程序中会打印出一句话：
You did not implement the visit method for class:class com.test.entity.Brand
 
如果运行程序时发生了别的异常，请参见相应的Java API文档。

在现在的改进后的访问者模式中，如果在组合的结构中新增或删除节点并不会对已经实现了的Visitor产生任何影响；如果新增了业务方法，只需扩展类ReflectionVisitorImpl就可以了。因此很好地解决了访问者模式的问题。

改进访问者模式实现与既有代码对接

到现在为止，改进后的访问者模式好像已经很好地解决了所有出现的问题，但是考虑到有下面的这种情况：现在需要写一个JSP的标签库（TagLib），这个标签库还必须具有Visitor的功能（就是需要有遍历节点的功能），可以将节点的内容根据需要打印到HTML页面中。由于标签本身需要继承相应的类（如TagSupport），如果继续使用上面提供的方法将无法实现，因为Java不允许多重继承。不过我们可以将原有ReflectionVisitorImpl的代码再改进一下以解决这种情况，新的Visitor的实现类叫NewReflectionVisitorImpl，代码如下所示。

  1. public class NewReflectionVisitorImpl implements ReflectionVisitor {
  2.     // 实现visit方法的类     
  3.     private Object targetObject;    
  4.     //构造方法，传入实现了visit方法的类
  5.     public NewReflectionVisitorImpl(Object targetObject) {
  6.         if (targetObject == null)
  7.             throw new NullPointerException(
  8.                     "The target object should not be null!");
  9.         this.targetObject = targetObject;
  10.     }
  11.     public void visitSoftwareComposite(Object softwareComposite) {
  12.         //……与上个例子相同
  13.         try {
  14.             // 从目标的对象中查找visit方法
  15.             Method m = targetObject.getClass().getMethod("visit", classes);
  16.             // 调用该方法
  17.             m.invoke(targetObject, objects);
  18.         } catch (NoSuchMethodException e) {
  19.             //……与上个例子相同
  20.         } catch (Exception e) {
  21.             //……与上个例子相同
  22.         }
  23.     }
  24. }
 

该类的实现与上面的实现差不多，多了一个构造函数，在该构造函数的参数中传入实现了visit方法的类，并且维护了指向该类的一个引用，另外最重要的地方是下面的两行代码：

  1. // 从目标的对象中查找visit方法
  2. Method m = targetObject.getClass().getMethod("visit", classes);
  3. // 调用该方法
  4. m.invoke(targetObject, objects);
 

本来的代码中从本身的类及其子类中查找visit方法，而现在是从维护的目标类中查找visit方法。

现在需要写Tag类，这个类扩展了TagSupport类，如下所示（为说明的方便，随本文的例子提供了一个模拟的TagSupport类）：
  1. public class MyTag extends TagSupport {
  2.     SoftwareComponent softwareComponent = null;
  3.     private double totalPrice = 0;
  4.     public int doEngTag() {
  5.         //创建一个visitor对象，并且将本身传入visitor对象中
  6.         ReflectionVisitor visitor = new NewReflectionVisitorImpl(this);
  7.         //遍历结构
  8.         softwareComponent.accept(visitor);
  9.         //打印出价格
  10.         out.println(totalPrice);
  11.         return 1;
  12.     }
  13.     //实现了针对Product的visit方法
  14.     public void visit(Product product) {
  15.         totalPrice += product.getPrice();
  16.     }
  17.     public void visit(Brand brand) {
  18.         out.println(brand.getId() + brand.getDescription());
  19.     }
  20.     //别的代码请参见随本文带的源程序
  21.     ……
  22. }
 

如果想测试上面写的那段代码，（在本文的例子com.test.business.SoftwareManager中可以找到这段代码））如下所示：
  1. //getMockData()方法返回数据
  2. SoftwareComponent data = getMockData();
  3. MyTag myTag = new MyTag();
  4. myTag.setSoftwareComponent(data);
  5. //计算总价格，并打印出来
  6. myTag.doEngTag();
 

可以看到通过Java的反射机制很好地解决了多重继承的问题，使该访问者模式能够更好地应用于你的应用中。另外可以看到，那些visit方法所在的类已经不是实现了接口ReflectionVisitor，可以说是访问者模式在Java语言的支持下的一种特殊实现。

如果担心引入类反射机制后带来的效率问题，你可以将Method对象通过某种方式缓冲起来，这样不会每次从传入的对象中找visit方法，可以部分地提高效率。
结论

在给定的组合模式的数据结构中，实现业务逻辑的方法非常多，文中试着介绍了几种实现业务逻辑的方法，并给出了相应的实现方式下的优缺点。读者可以综合考虑应用的需求来决定相应的实现方法。

随本文带的源代码
　　--相关文章--
· 面向对象编程,我的思想 (2007-04-13)
· 面向对象的思维方式 (2007-04-13)
· 通过Javanbsp;Swing看透MVC设计模式 (2007-04-13)
· 适配器模式（Adapternbsp;Pattern） (2007-04-13)
· 追MM与Java的23种设计模式 (2007-04-13)
· 责任链模式（Chainnbsp;ofnbsp;Responsibility） (2007-04-13)

版权所有©2005-2006 JAVA资源网 渝ICP备05007591号 虚拟主机 | 关于我们 | 联系方式 | 广告业务 | 网站地图 | 友情链接