复合模式精讲-优快云博客

在面向对象的系统中，我们经常会遇到一类具有“容器”特征的对象，即它们在充当对象的同时，又是其他对象的容器。

举例：在操作系统中，文件的概念很广泛，其中文件可以是普通文件，也可以是目录(在Unix中，设备也是文件)，目录中可以存放文件。如下图：

图1

File ：抽象的文件类

PhysicalFile ：普通文件

Directory ：目录

// File.java

package com.pnft.patterns.composite;

public abstract class File

{

public abstract void process();

}

// PhysicalFile.java

package com.pnft.patterns.composite;

public class PhysicalFile extends File

{

@Override

public void process()

{

System.out.println("Method process() in PhysicalFile...");

}

// Directory.java

package com.pnft.patterns.composite;

import java.util.ArrayList;

public class Directory extends File

{

private ArrayList<File> arrayList;

@Override

public void process()

{

System.out.println("Method process() in Directory...");

}

public Directory()

{

arrayList = new ArrayList<File>();

}

public ArrayList<File> getFiles()

{

return arrayList;

}

public void add(File file)

{

arrayList.add(file);

}

public void remove(File file)

{

if(file != null)

{

arrayList.remove(file);

}

// PatternClient.java

package com.pnft.patterns.composite;

import java.util.ArrayList;

import java.util.Iterator;

public class PatternClient

{

private void recursiveProcess(ArrayList<File> arrayList)

{

if (arrayList != null)

{

for(Iterator<File> iter = arrayList.iterator(); iter.hasNext();)

{

File f = iter.next();

if(f instanceof Directory)

{

((File)f).process();

recursiveProcess(((Directory) f).getFiles());

}

else

{

f.process();

}

public static void main(String[] args)

{

PatternClient pc = new PatternClient();

File f = new Directory();

f.process();

File f1 = new Directory();

File f2 = new PhysicalFile();

((Directory)f1).add(f2);

((Directory)f).add(f1);

File f3 = new Directory();

File f4 = new Directory();

File f5 = new Directory();

File f6 = new PhysicalFile();

((Directory)f5).add(f6);

((Directory)f4).add(f5);

((Directory)f3).add(f4);

((Directory)f).add(f3);

ArrayList<File> arrayList = ((Directory)f).getFiles();

pc.recursiveProcess(arrayList);

}

上述程序运行结果：

Method process() in Directory...

Method process() in PhysicalFile...

Method process() in Directory...

Method process() in PhysicalFile...

上面程序存在的问题：

在容器类Directory中存在一个getFiles方法，而该方法的存在直接导致了客户程序PatternClient中的recursiveProcess方法的存在，这说明Directory类和客户程序PatternClient的耦合太紧(另外还有，在PatternClient中要判断一个对象是Directory还是PhysicalFile，以便采取不同的处理方式等等，都说明了耦合过紧这一情况)，而且recursiveProcess方法是递归的，这于程序的维护不甚合适。因此，问题的根源在于：客户代码过多地依赖对象容器的内部实现结构，对象容器内部实现结构(而非抽象接口)的变化将引起客户端嗲吗的频繁变化，从而带来了代码的维护性和扩展性等方面的弊端。

Composite设计模式就是将“客户代码与复杂的对象昂容器结构”解耦，让对象容器自己来实现自身的复杂结构，从而使得客户代码就像处理简单对象(PhysicalFile)一样来处理复杂的对象容器(Directory)。

Composite设计模式的意图就是，将对象组合成属性结构以表示“部分-整体”的层次结构。它使得客户对单个对象和组合对象的使用具有一致性。-GoF

下面我们用Composite设计模式来解决上面的问题，具体代码如下，其中被注解的部分是未采用Composite设计模式之前的代码：

// File.java

package com.pnft.patterns.composite;

public abstract class File

{

public abstract void process();

public abstract void add(File file); // 将add方法抽象出来

public abstract void remove(File file); // 将remove方法抽象出来

}

// PhysicalFile.java

package com.pnft.patterns.composite;

public class PhysicalFile extends File

{

@Override

public void process()

{

System.out.println("Method process() in PhysicalFile...");

}

@Override

public void add(File file)

{

// add方法在本类中完全没有必要，但是为了将Directory类中的add方法抽取到File中，

// 因此必须在本类override这个add方法，这是为了在客户程序中不需要区分到底是

// Directory类还是PhysicalFile类，从而减少客户程序的依赖。

// 这个方法可以为空，或者抛出一个自定义的异常。

// 不很完美，因为在本类中被迫增加了这个方法。

}

@Override

public void remove(File file)

{

// remove方法在本类中完全没有必要，但是为了将Directory类中的remove方法抽取到File中，

// 因此必须在本类override这个add方法，这是为了在客户程序中不需要区分到底是

// Directory类还是PhysicalFile类，从而减少客户程序的依赖。

// 这个方法可以为空，或者抛出一个自定义的异常。

// 不很完美，因为在本类中被迫增加了这个方法。

}

// Directory.java

package com.pnft.patterns.composite;

import java.util.ArrayList;

import java.util.Iterator;

public class Directory extends File

{

private ArrayList<File> arrayList;

@Override

public void process()

{

System.out.println("Method process() in Directory...");

// 下面if块是按照Composite设计模式的要求新增加的代码

if(arrayList != null)

{

for(Iterator<File> iter = arrayList.iterator(); iter.hasNext();)

{

File f = (File)iter.next();

f.process();

}

public Directory()

{

arrayList = new ArrayList<File>();

}

// public ArrayList<File> getFiles() // 注释掉

// {

// return arrayList;

// }

public void add(File file)

{

arrayList.add(file);

}

public void remove(File file)

{

if(file != null)

{

arrayList.remove(file);

}

// PatternClient.java

package com.pnft.patterns.composite;

//import java.util.ArrayList; // 注释掉

//import java.util.Iterator;

public class PatternClient

{

// private void recursiveProcess(ArrayList<File> arrayList)

// {

// if (arrayList != null)

// {

// for(Iterator<File> iter = arrayList.iterator(); iter.hasNext();)

// {

// File f = iter.next();

// if(f instanceof Directory)

// {

// ((File)f).process();

// recursiveProcess(((Directory) f).getFiles());

// }

// else

// {

// f.process();

// }

public static void main(String[] args)

{

// PatternClient pc = new PatternClient();

File f = new Directory();

// f.process();

File f1 = new Directory();

File f2 = new PhysicalFile();

// ((Directory)f1).add(f2); // 注释掉这2行代码，

// ((Directory)f).add(f1); // 用下面两行代码代替

f1.add(f2);

f.add(f1);

File f3 = new Directory();

File f4 = new Directory();

File f5 = new Directory();

File f6 = new PhysicalFile();

// ((Directory)f5).add(f6); // 注释掉这4行代码，

// ((Directory)f4).add(f5);

// ((Directory)f3).add(f4);

// ((Directory)f).add(f3); // 用下面4行代码代替

f5.add(f6);

f4.add(f5);

f3.add(f4);

f.add(f3);

f.process();

// ArrayList<File> arrayList = ((Directory)f).getFiles(); // 注释掉

// pc.recursiveProcess(arrayList);

}

各对象之间的关系：

图2

从上面程序看，PatternClient已经被简化了许多，而且仅对抽象类File有依赖(创建对象除外，创建对象可以用诸如Simple Factory设计模式来解决，在此不赘述)。上面程序运行结果：

Method process() in Directory...

Method process() in PhysicalFile...

Method process() in Directory...

Method process() in PhysicalFile...

可以看到，该结果和前面程序的结果是一致的。前后两个程序的重要区别：

1. 递归并没有消除，后者将递归移动到了Directory类中的process方法，同时虽然是递归，但是非常自然，易于理解；而前者需要客户程序来处理递归，从而从代码维护的角度而言存在很大的差别。

2. 后者将add方法和remove方法抽象到了File类中，从而保证在客户程序中不需要进行转型(Type Casting)处理，从而大幅度降低了客户程序代码复杂程度和对外部依赖程序。这样做的一个glitch就是，在PhysicalFile类中被迫增加了add方法和remove方法。

下面是后者的UML类图：

图3

实际上严格的Composite静态结构图如下：

图4

同时一定要记住：

Leaf中的add方法和remove方法，必须为空(即不存在任何代码)或者只抛出异常即可。因为Leaf类是叶子类，不能作为容器，因此也就无从add或者remove了。

我们可以看到，图1的大致结构看起来和图2、图3没有太大的不同，它们之间的主要区别是：

1. 一些方法是否需要存在

2. 这些方法所处的位置

3. 方法内容不同

因此不能仅从静态结构图比较类似，就判定对应图1是实现的项目代码就符合Composite设计模式的。通过前面两个不同的Java项目的代码，可以非常清楚地看出这一点。

Composite模式