跳至主要內容

组合模式

AruNi_Lu设计模式设计模式与范式约 1834 字大约 6 分钟
本文内容

前言

当你头一次看到组合模式时，可能会联想到组合关系，但其实 组合模式跟面向对象设计中的 “组合关系” 完全是两码事。

组合模式 在平时开发中不常使用，因为它的应用场景非常特殊，主要用来 处理树形结构数据。

1. 什么是组合模式

组合模式 的定义是：将一组对象组织成树形结构，以表示一种 “部分 - 整体” 的层次结构，让使用者可以统一单个对象和组合对象的处理逻辑。

组合模式一个典型的应用就是处理文件系统，下面也通过这个例子来理解下上面的定义。

假设我们需要设计一个类来表示文件系统中的目录，能方便的提供下面的功能：

  • 动态地添加、删除某个目录下的子目录或文件；
  • 统计指定目录下的文件个数；
  • 统计指定目录下的文件总大小。

为了提高文件目录系统的可扩展性、可读性，我们将文件和目录（文件夹）进行区分设计，分别定义为 File 类和 Directory 类。

非要只用一个大类来表示文件目录也可以，添加一个 isFile 字段来表示文件即可。

首先定义一个顶层的 文件系统节点抽象类 FileSystemNode，提供路径属性、以及计算文件数量和总大小的方法：

public abstract class FileSystemNode {
  protected String path;

  public FileSystemNode(String path) {
    this.path = path;
  }

  public abstract int countNumOfFiles();
  public abstract long countSizeOfFiles();

  public String getPath() {
    return path;
  }
}

接着定义 文件类 File，继承自 FileSystemNode，重写上述两个方法，具体实现逻辑就是：

  • 计算文件数量：因为是文件类，所以表示一个文件，返回 1 即可；
  • 计算文件总大小：通过 Java 的 File 类，直接返回 file 对象的长度即可。
public class File extends FileSystemNode {
  public File(String path) {
    super(path);
  }

  @Override
  public int countNumOfFiles() {
    return 1;
  }

  @Override
  public long countSizeOfFiles() {
    java.io.File file = new java.io.File(path);
    if (!file.exists()) return 0;
    return file.length();
  }
}

接着定义 目录（文件夹）类 Directory，继承自 FileSystemNode，再额外提供一个 List，用于保存所有的目录和文件。

也要重写上述两个方法，具体实现逻辑就是：

  • 计算文件数量：因为是目录，所以需要 递归遍历 所有文件目录节点，遇到文件自然会返回 1，遇到目录则继续递归下一个节点；
  • 计算文件总大小：逻辑与计算文件数量类似，递归遍历统计即可。

除此之外，由于还需要支持动态地添加、删除某个目录下的子目录或文件，所以在 Directory 类中还需要增加添加、删除目录文件的方法。

public class Directory extends FileSystemNode {
  private List<FileSystemNode> subNodes = new ArrayList<>();

  public Directory(String path) {
    super(path);
  }

  @Override
  public int countNumOfFiles() {
    int numOfFiles = 0;
    for (FileSystemNode fileOrDir : subNodes) {
      // 递归遍历
      numOfFiles += fileOrDir.countNumOfFiles();
    }
    return numOfFiles;
  }

  @Override
  public long countSizeOfFiles() {
    long sizeofFiles = 0;
    for (FileSystemNode fileOrDir : subNodes) {
      // 递归遍历
      sizeofFiles += fileOrDir.countSizeOfFiles();
    }
    return sizeofFiles;
  }

  public void addSubNode(FileSystemNode fileOrDir) {
    subNodes.add(fileOrDir);
  }

  public void removeSubNode(FileSystemNode fileOrDir) {
    int size = subNodes.size();
    int i = 0;
    for (; i < size; ++i) {
      if (subNodes.get(i).getPath().equalsIgnoreCase(fileOrDir.getPath())) {
        break;
      }
    }
    if (i < size) {
      subNodes.remove(i);
    }
  }
}

此时文件和目录就都设计好了，下面来看看如何用它们来表示一个文件系统中的目录树结构。代码如下：

public class Demo {
  public static void main(String[] args) {
    /**
     * /
     * /wz/
     * /wz/a.txt
     * /wz/b.txt
     * /wz/movies/
     * /wz/movies/c.avi
     * /xzg/
     * /xzg/docs/
     * /xzg/docs/d.txt
     */
    Directory fileSystemTree = new Directory("/");
    Directory node_wz = new Directory("/wz/");
    Directory node_xzg = new Directory("/xzg/");
    fileSystemTree.addSubNode(node_wz);
    fileSystemTree.addSubNode(node_xzg);

    File node_wz_a = new File("/wz/a.txt");
    File node_wz_b = new File("/wz/b.txt");
    Directory node_wz_movies = new Directory("/wz/movies/");
    node_wz.addSubNode(node_wz_a);
    node_wz.addSubNode(node_wz_b);
    node_wz.addSubNode(node_wz_movies);

    File node_wz_movies_c = new File("/wz/movies/c.avi");
    node_wz_movies.addSubNode(node_wz_movies_c);

    Directory node_xzg_docs = new Directory("/xzg/docs/");
    node_xzg.addSubNode(node_xzg_docs);

    File node_xzg_docs_d = new File("/xzg/docs/d.txt");
    node_xzg_docs.addSubNode(node_xzg_docs_d);

    System.out.println("/ files num:" + fileSystemTree.countNumOfFiles());
    System.out.println("/wz/ files num:" + node_wz.countNumOfFiles());
  }
}

对者这个例子，再来看看组合模式的定义：将一组对象（文件和目录）组织成树形结构，以表示一种 “部分 - 整体” 的层次结构（目录与子目录的嵌套结构），让使用者可以统一单个对象（文件）和组合对象（目录）的处理逻辑 (递归遍历)。

2. 应用场景

组合模式的应用场景其实就在其定义当中，即 一组对象能组织成树形结构，使用者可以统一单个对象和组合对象的处理逻辑。

除了上面的文件目录系统外，还有一些可以表示为树形结构的数据。

比如部门和员工系统，它们在数据库中可能用如下结构表示：

image-20230416202009212

当我们需要对某个部门（这个部门可能还有子部门）求出所有员工的工资和时，员工和部门可以组织成树形结构，部门与子部门嵌套构成 “部分 - 整体” 的层次结构。利用组合模式可以让使用者统一单个对象（员工）和组合对象（部门）的处理逻辑（递归遍历求工资和）。

由于这里的逻辑和上面的文件目录系统相似，所以就不给出代码实现了。

除此之外，还有比如需要对数据进行过滤，将满足一定条件的数据收集起来，而过滤的条件可以使用类似于树形结构（比如二叉树）的形式来组织，也可以使用组合模式。

比如下面这个例子，使用一颗规则树来对性别、年龄进行过滤，最底层的节点表示果实，即过滤后的满足条件的结果。用组合模式的定义来说，就是 将一组对象（果实和节点）组织成树形结构，以表示一种 “部分 - 整体” 的层次结构（节点与子节点的嵌套结构），让使用者可以统一单个对象（果实节点）和组合对象（节点）的处理逻辑 (遍历节点进行过滤)：

其实前缀树也可以看作是组合模式，它的定义就是 将一组对象（叶子节点 [isEnd = true 的节点] 和普通节点）组织成树形结构，以表示一种 “整部 - 整体” 的层次结构（普通节点之间的嵌套结构），让使用者可以统一单个对象（叶子节点）和组合对象（普通节点）的处理逻辑 (遍历节点)。

3. 总结

关于组合模式的定义，在每个例子中都重新理解了一遍，这里就不再赘述了。

最后再强调一下，组合模式的应用场景很有限，需要你的业务场景必须能够表示成树形结构，业务需求可以通过在树上的递归遍历算法来实现。

因此组合模式在实际开发中不是很常用，但是也需要掌握，一旦有类似的需求，使用组合模式就可以很好的解决。

上次编辑于: