专栏：设计模式-组合模式

Posted 2021-04-25 EAIPLUS

图片 | Google

文章 | 靳天

校对 | 靳天

组合模式的原理与实现

组合模式(Composite Pattern)是将一组对象组织（Compose）成树形结构，以表示一种“部分 - 整体”的层次结构。组合让客户端（在很多设计模式书籍中，“客户端”代指代码的使用者。）可以统一单个对象和组合对象的处理逻辑。

接下来，对于组合模式，我举个例子来给你解释一下。

假设我们有这样一个需求：设计一个类来表示文件系统中的目录，能方便地实现下面这些功能：

1. 动态地添加、删除某个目录下的子目录或文件；

   
   

2. 统计指定目录下的文件个数；

   
   

3. 统计指定目录下的文件总大小。

我这里给出了这个类的代码，如下所示。在下面的代码实现中，我们把文件和目录统一用 FileSystemNode 类来表示，并且通过 isFile 属性来区分。

public class FileSystemNode { private String path; private boolean isFile; private List<FileSystemNode> subNodes = new ArrayList<>();
 public FileSystemNode(String path, boolean isFile) { this.path = path; this.isFile = isFile; }
 public int countNumOfFiles() {     if (isFile) {           return 1;         }         int numOfFiles = 0;         for (FileSystemNode fileOrDir : subNodes) {        numOfFiles += fileOrDir.countNumOfFiles();         }           return numOfFiles;    }    public long countSizeOfFiles() {      if (isFile) {         File file = new File(path);         if (!file.exists()) return 0;          return file.length();        }    long sizeofFiles = 0;        for (FileSystemNode fileOrDir : subNodes) {           sizeofFiles += fileOrDir.countSizeOfFiles();        }        return sizeofFiles;    }
 public String getPath() { return path; }
 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); } }}

通过组合模式重构

单纯从功能实现角度来说，上面的代码没有问题，已经实现了我们想要的功能。

但是，如果我们开发的是一个大型系统，从扩展性（文件或目录可能会对应不同的操作）、业务建模（文件和目录从业务上是两个概念）、代码的可读性（文件和目录区分对待更加符合人们对业务的认知）的角度来说，我们最好对文件和目录进行区分设计，定义为 File 和 Directory 两个类。

按照这个设计思路，我们对代码进行重构。重构之后的代码如下所示：

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; }}
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(); }}
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 Example { 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()); }}

组合模式的应用场景举例

我们希望在内存中构建整个公司的人员架构图（部门、子部门、员工的隶属关系），并且提供接口计算出部门的薪资成本（隶属于这个部门的所有员工的薪资和）。

部门包含子部门和员工，这是一种嵌套结构，可以表示成树这种数据结构。计算每个部门的薪资开支这样一个需求，也可以通过在树上的遍历算法来实现。

所以，从这个角度来看，这个应用场景可以使用组合模式来设计和实现。

这个例子的代码结构跟上一个例子的很相似，代码实现我直接贴在了下面，你可以对比着看一下。

其中，HumanResource 是部门类（Department）和员工类（Employee）抽象出来的父类，为的是能统一薪资的处理逻辑。Example 中的代码负责从数据库中读取数据并在内存中构建组织架构图。

public abstract class HumanResource { protected long id; protected double salary;
 public HumanResource(long id) { this.id = id; }
 public long getId() { return id; }
 public abstract double calculateSalary();}
public class Employee extends HumanResource { public Employee(long id, double salary) { super(id); this.salary = salary; }
 @Override public double calculateSalary() { return salary; }}
public class Department extends HumanResource { private List<HumanResource> subNodes = new ArrayList<>();
 public Department(long id) { super(id); }
 @Override public double calculateSalary() { double totalSalary = 0; for (HumanResource hr : subNodes) { totalSalary += hr.calculateSalary(); } this.salary = totalSalary; return totalSalary; }
 public void addSubNode(HumanResource hr) { subNodes.add(hr); }}
// 构建组织架构的代码public class Example { private static final long ORGANIZATION_ROOT_ID = 1001;  private DepartmentRepo departmentRepo; // dependency injection  private EmployeeRepo employeeRepo; // dependency injection
 public void buildOrganization() { Department rootDepartment = new Department(ORGANIZATION_ROOT_ID); buildOrganization(rootDepartment); }
 private void buildOrganization(Department department) { List<Long> subDepartmentIds = departmentRepo.getSubDepartmentIds(department.getId()); for (Long subDepartmentId : subDepartmentIds) { Department subDepartment = new Department(subDepartmentId); department.addSubNode(subDepartment); buildOrganization(subDepartment); } List<Long> employeeIds = employeeRepo.getDepartmentEmployeeIds(department.getId()); for (Long employeeId : employeeIds) { double salary = employeeRepo.getEmployeeSalary(employeeId); department.addSubNode(new Employee(employeeId, salary)); } }}

我们再拿组合模式的定义跟这个例子对照一下：“将一组对象（员工和部门）组织成树形结构，以表示一种‘部分 - 整体’的层次结构（部门与子部门的嵌套结构）。组合模式让客户端可以统一单个对象（员工）和组合对象（部门）的处理逻辑（递归遍历）。”

总结

组合模式的设计思路，与其说是一种设计模式，倒不如说是对业务场景的一种数据结构和算法的抽象。其中，数据可以表示成树这种数据结构，业务需求可以通过在树上的递归遍历算法来实现。

组合模式，将一组对象组织成树形结构，将单个对象和组合对象都看做树中的节点，以统一处理逻辑，并且它利用树形结构的特点，递归地处理每个子树，依次简化代码实现。

使用组合模式的前提在于，你的业务场景必须能够表示成树形结构。所以，组合模式的应用场景也比较局限，它并不是一种很常用的设计模式。

文末小问题

在文件系统那个例子中，countNumOfFiles() 和 countSizeOfFiles() 这两个函数实现的效率并不高，因为每次调用它们的时候，都要重新遍历一遍子树。有没有什么办法可以提高这两个函数的执行效率呢?

（注意：文件系统还会涉及频繁的删除、添加文件操作，也就是对应 Directory 类中的 addSubNode() 和 removeSubNode() 函数)？（可以从递归重复计算角度回答）

留一个小问题，希望你在后台留言给我答案。

参考资料

[1]. [设计模式之美-geektime]

(https://time.geekbang.org/column/article/199674) 

[2]. [CSDN]

(https://blog.csdn.net/jason0539/article/details/44992733)

[3].[博客园]

(https://www.cnblogs.com/chenssy/p/3299719.html)

还可以看

如果本文有什么笔误、错误，请您在订阅号后台直接留言，作者看到后会及时勘误的！（蟹蟹）

点在看好不好，喵~