设计模式:组合模式

组合模式  


一、引子 
    在大学的数据结构这门课上，树是最重要的章节之一。还记得树是怎么定义的吗？树 
(Tree)是n(n≥0)个结点的有限集T，T 为空时称为空树，否则它满足如下两个条件： 
1)  有且仅有一个特定的称为根(Root)的结点； 
2)  其余的结点可分为m(m≥0)个互不相交的子集Tl，T2，…，Tm，其中每个子集本身又 
    是一棵树，并称其为根的子树(SubTree)。 
    上面给出的递归定义刻画了树的固有特性：一棵非空树是由若干棵子树构成的，而子树 
又可由若干棵更小的子树构成。而这里的子树可以是叶子也可以是分支。 
    今天要学习的组合模式就是和树型结构以及递归有关系。 


二、定义与结构 
    组合(Composite)模式的其它翻译名称也很多，比如合成模式、树模式等等。在《设计 
模式》一书中给出的定义是：将对象以树形结构组织起来，以达成“部分－整体”的层次结构， 
使得客户端对单个对象和组合对象的使用具有一致性。 
    从定义中可以得到使用组合模式的环境为：在设计中想表示对象的“部分－整体”层次结 
构；希望用户忽略组合对象与单个对象的不同，统一地使用组合结构中的所有对象。 
    看下组合模式的组成。 
1)  抽象构件角色(Component)：它为组合中的对象声明接口，也可以为共有接口实现缺省 
    行为。 
2)  树叶构件角色(Leaf)：在组合中表示叶节点对象——没有子节点，实现抽象构件角色声 
    明的接口。 
3)  树枝构件角色(Composite)：在组合中表示分支节点对象——有子节点，实现抽象构件 
    角色声明的接口；存储子部件。 
    下图为组合模式的类图表示。 


    如图所示，不管你使用的是Leaf 类还是Composite 类，对于客户程序来说都是一样的 
——客户仅仅知道Component 这个抽象类。而且在Composite 类中还持有对Component 
抽象类的引用，这使得Composite 中可以包含任何Component 抽象类的子类。 

                                aComposite 


          aLeaf              aLeaf               aComposite 


                                        aLeaf                  aLeaf 


    就向上图表示的那样，Composite 对象和leaf 对象组成了树型结构，而且符合树的定义。 


三、安全性与透明性 
    组合模式中必须提供对子对象的管理方法，不然无法完成对子对象的添加删除等等操 
作，也就失去了灵活性和扩展性。但是管理方法是在Component 中就声明还是在Composite 
中声明呢？ 
    一种方式是在 Component         里面声明所有的用来管理子类对象的方法，以达到 
Component 接口的最大化（如下图所示）。目的就是为了使客户看来在接口层次上树叶和分 
支没有区别——透明性。但树叶是不存在子类的，因此Component 声明的一些方法对于树 
叶来说是不适用的。这样也就带来了一些安全性问题。 


                            Component 


                         defaultMethod() 
                         getChild() 
                         addComponent() 
                         removeComponent() 


                   Leaf                  Composite 


              defaultMethod()         defaultMethod() 
                                      getChild() 
                                      addComponent() 
                                      removeComponent() 


    另一种方式就是只在Composite  里面声明所有的用来管理子类对象的方法（如下图所 
示）。这样就避免了上一种方式的安全性问题，但是由于叶子和分支有不同的接口，所以又 
失去了透明性。 

                              Component 


                              defaultMethod() 


                    Leaf                     Composite 


                defaultMethod()          defaultMethod() 
                                         getChild() 
                                         addComponent() 
                                         removeComponent() 


    《设计模式》一书认为：在这一模式中，相对于安全性，我们比较强调透明性。对于第 
一种方式中叶子节点内不需要的方法可以使用空处理或者异常报告的方式来解决。 


四、举例 
    这里以JUnit 中的组合模式的应用为例。 
    JUnit 是一个单元测试框架，按照此框架下的规范来编写测试代码，就可以使单元测试 
自动化。为了达到“ 自动化”的目的，JUnit 中定义了两个概念：TestCase 和TestSuite。TestCase 
是编写的测试类；而TestSuite 是一个不同TestCase 的集合，当然这个集合里面也可以包含 
TestSuite 元素，这样运行一个TestSuite 会将其包含的TestCase 全部运行。 
    然而在真实运行测试程序的时候，是不需要关心这个类是TestCase 还是TestSuite，我 
们只关心测试运行结果如何。这就是为什么JUnit 使用组合模式的原因。 
    JUnit 为了采用组合模式将TestCase 和TestSuite 统一起来，创建了一个Test 接口来扮 
演抽象构件角色，这样原来的TestCase 扮演组合模式中树叶构件角色，而TestSuite 扮演组 
合模式中的树枝构件角色。下面将这三个类的有关代码分析如下： 


    //Test 接口——抽象构件角色 


    public interface Test { 
         /** 
          * Counts the number of test cases that will be run by this test. 
          */ 
         public abstract int countTestCases(); 
         /** 
          * Runs a test and collects its result in a TestResult instance. 
          */ 
         public abstract void run(TestResult result); 
    } 

  //TestSuite 类的部分有关源码——Composite 角色，它实现了接口Test 


  public class TestSuite implements Test { 
       //用了较老的Vector 来保存添加的test 


       private Vector fTests= new Vector(10); 
       private String fName; 
       …… 
       /** 
        * Adds a test to the suite. 
        */ 
       public void addTest(Test test) { 
           //注意这里的参数是Test 类型的。这就意味着TestCase 和TestSuite 以及以后 
       实现Test 接口的任何类都可以被添加进来 


            fTests.addElement(test); 
       } 
       …… 
       /** 
        * Counts the number of test cases that will be run by this test. 
        */ 
       public int countTestCases() { 
            int count= 0; 
            for (Enumeration e= tests(); e.hasMoreElements(); ) { 
                Test test= (Test)e.nextElement(); 
                count= count + test.countTestCases(); 
            } 
            return count; 
       } 
       /** 
        * Runs the tests and collects their result in a TestResult. 
        */ 
       public void run(TestResult result) { 
            for (Enumeration e= tests(); e.hasMoreElements(); ) { 
                if (result.shouldStop() ) 
                     break; 
                Test test= (Test)e.nextElement(); 
                 //关键在这个方法上面 


                runTest(test, result); 
            } 
       } 
         //这个方法里面就是递归的调用了，至于你的Test 到底是什么类型的只有在运行 
的时候得知 


         public void runTest(Test test, TestResult result) { 
              test.run(result); 
         } 
       …… 

    } 


    //TestCase 的部分有关源码——Leaf 角色，你编写的测试类就是继承自它 


    public abstract class TestCase extends Assert implements Test { 
        …… 
        /** 
         * Counts the number of test cases executed by run(TestResult result). 
         */ 
        public int countTestCases() { 
            return 1; 
        } 
        /** 
         * Runs the test case and collects the results in TestResult. 
         */ 
        public void run(TestResult result) { 
            result.run(this); 
        } 
        …… 
    } 


    可以看出这是一个偏重安全性的组合模式。因此在使用TestCase 和TestSuite 时，不能 
使用Test 来代替。 


五、优缺点 
    从上面的举例中可以看到，组合模式有以下优点： 
1)  使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关心 
    自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。 
2)  更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。这 
    一点符合开闭原则的要求，对系统的二次开发和功能扩展很有利！ 
    当然组合模式也少不了缺点：组合模式不容易限制组合中的构件。 


六、总结 
    组合模式是一个应用非常广泛的设计模式，在前面已经介绍过的解释器模式、享元模式 
中都是用到了组合模式。它本身比较简单但是很有内涵，掌握了它对你的开发设计有很大的 

帮助。 

下载：

http://download.csdn.net/detail/undoner/5335717

深入浅出设计模式-中文版

http://www.lsoft.cn

LSOFT.CN (琅软中国) - 创造玉石般的软件,完美的用户体验！