Java设计模式系列——组合模式

1、什么是组合模式（Composite Pattern）

组合模式是一种对象结构型模式，将对象组合成树形结果以表示“部分-整体”的层次结构。Composite使得用户对单个和组合对象的使用具有一致性。 以上是《设计模式》中文译版的一书中的定义，听上去不是很好理解。下面我们结合Windows文件目录系统来看一下组合模式应用实例。

2、组合模式详解

2.1、组合模式解决的问题

以下情况下均适用组合模式来解决问题：

• 对于树形结构，当容器对象（如文件夹）的某一个方法被调用时，将遍历整个树形结构，寻找也包含这个方法的成员对象并调用执行（递归）。
• 客户端希望一致地处理容器对象和叶子对象。
• 描述了如何将容器对象和叶子对象进行递归组合，使得用户在使用时无须对它们进行区分。可以一致地对待容器对象和叶子对象。

2.2、组合模式设计类图

典型的组合模式类图如下图所示：

2.3、组合模式角色构成

结合上面的类图我们可以看到，组合模式中的基本角色构成：

• Component（抽象组件类）
  —— 为组合中的对象声明接口；
  —— 在适当的情况下，实现所有类共有接口的缺省行为；
  —— 声明一个接口用于访问和管理Component的子组件；
  ——（可选）在递归结构中定义一个接口，用于访问一个父部件，并在合适的情况下实现它。
• Leaf（叶子节点）
  —— 在组合中表示叶子节点对象，叶节点没有子节点。
• Composite（组件集合类）
  —— 定义有子部件的那些部件的行为；
  —— 存储子部件；
  —— 在Component接口中实现与子部件相关的操作。

3、组合模式实现步骤

假定现在需要输出Windows某一文件下所有内容，我们按照以下步骤来一步一步实现。

3.1、定义抽象组件接口

package com.example.demo.composite;

public abstract class AbstractComponent {

    protected String name;

    public abstract void add(AbstractComponent component);

    public abstract void remove(AbstractComponent component);

    public abstract void listFiles(int depth);

}

3.2、实现叶子节点

package com.example.demo.composite;

public class DocLeaf extends AbstractComponent {

    public DocLeaf(String name) {
        this.name = name;
    }

    @Override
    public void add(AbstractComponent component) {
        System.out.println("不能向叶子节点添加子节点");
    }

    @Override
    public void remove(AbstractComponent component) {
        System.out.println("叶子节点没有可以移除的子节点");
    }

    @Override
    public void listResult(int depth) {
        System.out.println("节点深度" + depth + "叶子节点" + name);
    }
}

3.3、定义实现组件集合类

package com.example.demo.composite;

import java.util.ArrayList;
import java.util.List;

public class Files extends AbstractComponent {

    List<AbstractComponent> children = new ArrayList<>();

    public Files(String name) {
        this.name = name;
    }

    @Override
    public void add(AbstractComponent component) {
        this.children.add(component);
    }

    @Override
    public void remove(AbstractComponent component) {
        this.children.remove(component);
    }

    @Override
    public void listResult(int depth) {
        System.out.println("节点深度" + depth + "叶子节点" + name);
        for (AbstractComponent c: children) {
            c.listResult(depth + 2);
        }
    }
}

现在我们模拟客户端对文件系统的访问与构建

public static void main(String[] args) {
        Files rootFiles = new Files("根目录");
        rootFiles.add(new DocLeaf("根目录下的文件A"));
        rootFiles.add(new DocLeaf("根目录下的文件B"));
        Files comp = new Files("根目录下的文件夹FA");
        comp.add(new DocLeaf("文件夹FA中的文件FAA"));
        comp.add(new DocLeaf("文件夹FA中的文件FBB"));
        rootFiles.add(comp);
        Files comp1 = new Files("文件夹FA下的文件夹FAX");
        comp1.add(new DocLeaf("文件夹FAX中的文件AXA"));
        comp1.add(new DocLeaf("文件夹FA中的文件BXB"));
        comp.add(comp1);
        rootFiles.add(new DocLeaf("根目录下文件C"));
        DocLeaf leafD = new DocLeaf("根目录下文件D");
        rootFiles.add(leafD);
        rootFiles.remove(leafD);
        rootFiles.remove(leafD);
        rootFiles.listResult(1);
    }

运行结果

4、组合模式解决的问题

• 定义了包含基本对象和组合对象的类层次结构。 基本对象可以被组合成更复杂的组合对象，而这个组合对象又可以被组合，这样不断地递归下去。客户端代码中，任何用到基本对象的地方都可以使用组合对象。
• 简化客户端代码 客户端可以一致地使用组合结构和单个对象。通常客户端不知道（也不关心）处理的是一个叶子节点还是一个组合件。这就简化了客户端代码，因为在定义组合的那些类中不需要写一些充斥者选择语句的函数。
• 使得更容易增加新类型的组件 新定义的Composite或Leaf子类自动地与已有的结构和客户端代码一起工作，客户端程序不需要因新的Component类而改变。