组合模式

一、引子
在大学的数据结构这门课上，树是最重要的章节之一。还记得树是怎么定义的吗？树
(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 抽象类的子类。

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


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


《设计模式》一书认为：在这一模式中，相对于安全性，我们比较强调透明性。对于第
一种方式中叶子节点内不需要的方法可以使用空处理或者异常报告的方式来解决。
四、举例
这里以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 来代替。

五、组合模式（Composite）属于结构性模式，它描述了对象间的组合关系。

对象间常常通过树结构来组织（包含）起来，以实现整体-部分的层次结构。整体上可以看做是一个组合对象。

抛却各种复杂的术语，组合模式的特点是：

对象通过实现（继承）统一的接口（抽象类），调用者对单一对象和组合对象的操作具有一致性。

组合模式很常见，Java的容器类（比如ArrayList）都实现了组合模式。

我们平常操作最多的文件（夹）就是组合模式的最好例子。文件系统是树形层次结构，并且文件和文件夹提供给用户的一些操作是相同的，比如复制。于是，可以通过一个统一的接口将文件和文件夹统一起来，对用户提供一致的操作，屏蔽不同的复制实现过程。我们在复制文件夹的时候，操作系统实现了对文件夹内的所有文件和文件夹的复制，即实现了组合对象的整体复制，而不是一个空的文件夹；这和我们复制单个文件的体验是一致的。这便是组合模式的妙处。

完整的模拟代码如下：

package com.csufox.Composite;  
 
import java.util.ArrayList;  
 
interface Node{  
    public void copy(); //定义统一的接口：复制  

}  
 
class Folder implements Node{  
    private String folderName;  
    private ArrayList nodeList =new ArrayList(); //用于存储文件夹下的文件夹或文件的信息 
 
    public Folder(String folderName){  
        this.folderName = folderName;  
    }  
 
    public void add(Node node){ //增加文件或文件夹  
        nodeList.add(node);  
    }  
 
    public void copy(){  //文件夹复制操作实现递归  
        System.out.println("复制文件夹：" + folderName);  
        for(int i=0;i
            Node node = (Node)nodeList.get(i);  
            node.copy();  
        }  
    }  
}  
 
class File implements Node{  
    private String fileName;  
 
    public File(String fileName){  
        this.fileName = fileName;  
    }  
 
    public void copy(){  
        System.out.println("复制文件：" + fileName);  
    }  
}  
 
public class Composite{  
    public static void main(String[] args){  
        Folder document = new Folder("我的资料"); //我的资料文件夹  
        File book = new File("Java编程思想.pdf");  //文档文件  
        Folder music = new Folder("我的音乐");   //我的音乐文件夹  
        File music1 = new File("你是我的眼.mp3");   //音乐文件1  
        File music2 = new File("Without You.mp3");  //音乐文件2  
        //确定树形结构关系  
        document.add(book);  
        document.add(music);  
        music.add(music1);  
        music.add(music2);  
 
        document.copy(); //复制“我的资料”文件夹，递归地复制了其下所有文件夹和文件。 
    }  
} 
运行结果如下：

复制文件夹：我的资料  
复制文件：Java编程思想.pdf  
复制文件夹：我的音乐  
复制文件：你是我的眼.mp3  
复制文件：Without You.mp3 
由以上的代码和运行结果可知：

通过实现组合模式，用户对文件夹的操作与对普通文件的操作并无差异。用户完全不用关心这是文件夹还是文件，也不用关心文件夹内部的具体结构，就可以完成相关操作。

同样的道理，我们可以表达如下：

通过实现组合模式，调用者对组合对象的操作与对单一对象的操作具有一致性。调用者不用关心这是组合对象还是文件，也不用关心组合对象内部的具体结构，就可以调用相关方法，实现功能。

仔细分析copy()方法的代码，我们会发现，如果从面向过程的角度思考，组合模式通过递归原理实现了树结构（组合对象）的深度优先遍历。