• 【23种设计模式】组合模式【⭐】

    个人主页：金鳞踏雨

    个人简介：大家好，我是金鳞，一个初出茅庐的Java小白

    目前状况：22届普通本科毕业生，几经波折了，现在任职于一家国内大型知名日化公司，从事Java开发工作

    我的博客：这里是CSDN，是我学习技术，总结知识的地方。希望和各位大佬交流，共同进步 ~

    本篇博客内容来自"IT楠老师的设计模式~"，出品时结合了个人理解~

    比较特殊，所适用的场景比较狭窄！只有在构建树形结构的时候才可能用到。

    一、组合模式的原理与实现

    在 GoF 的《设计模式》一书中，组合模式是这样定义的：

    Compose objects into tree structure to represent part-whole hierarchies.Composite lets client treat individual objects and compositions of objects uniformly.

    翻译过来就是：将一组对象组织（Compose）成树形结构，以表示一种“部分 - 整体”的层次结构。组合让客户端可以统一单个对象和组合对象的处理逻辑。

    组合模式（Composite Pattern）是一种结构型设计模式。在组合模式中，每个对象都有相同的接口，这使得客户端不需要知道对象的具体类型，而只需要调用对象的通用接口即可。

    组合模式涉及到的角色

    1. Component（抽象构件）：定义组合对象的通用接口，可以包含其他组合对象或叶子对象。
    2. Leaf（叶子节点）：表示组合对象中的叶子节点，它没有子节点。
    3. Composite（组合节点）：表示组合对象中的组合节点，它可以包含其他组合对象或叶子对象。

    案例一

    下面是一个简单的组合模式示例代码，用于表示文件系统中的文件和文件夹：

    1. // Component（抽象构件）
    2. interface FileSystem {
    3.     void display();
    4. }
    5.  
    6. // Leaf（叶子节点）-- 文件
    7. class File implements FileSystem {
    8.     private String name;
    9.     
    10.     public File(String name) {
    11.         this.name = name;
    12.     }
    13.     
    14.     @Override
    15.     public void display() {
    16.         System.out.println("File: " + name);
    17.     }
    18. }
    19.  
    20. // Composite（组合节点） -- 文件夹
    21. class Folder implements FileSystem {
    22.     // 文件夹里面有 -- 文件、文件夹
    23.     private String name;
    24.     private List children; 
    25.     
    26.     public Folder(String name) {
    27.         this.name = name;
    28.         children = new ArrayList<>();
    29.     }
    30.     
    31.     public void add(FileSystem fileSystem) {
    32.         children.add(fileSystem);
    33.     }
    34.     
    35.     public void remove(FileSystem fileSystem) {
    36.         children.remove(fileSystem);
    37.     }
    38.     
    39.     @Override
    40.     public void display() {
    41.         System.out.println("Folder: " + name);
    42.         for (FileSystem fileSystem : children) {
    43.             fileSystem.display();
    44.         }
    45.     }
    46. }
    47.  
    48. // 客户端代码
    49. public class Client {
    50.     public static void main(String[] args) {
    51.         // 文件
    52.         FileSystem file1 = new File("file1.txt");
    53.         FileSystem file2 = new File("file2.txt");
    54.  
    55.         // 文件夹
    56.         Folder folder1 = new Folder("folder1");
    57.         folder1.add(file1);
    58.         folder1.add(file2);
    59.         
    60.         FileSystem file3 = new File("file3.txt");
    61.         FileSystem file4 = new File("file4.txt");
    62.         
    63.         Folder folder2 = new Folder("folder2");
    64.         folder2.add(file3);
    65.         folder2.add(file4);
    66.         folder2.add(folder1);
    67.         
    68.         folder2.display();
    69.     }
    70. }

    在这个示例中，FileSystem 是抽象构件，它定义了组合对象的通用接口 display。File 是叶子节点，表示文件，它实现了 FileSystem 接口，并在 display 方法中输出文件名。Folder 是组合节点，表示文件夹，它实现了 FileSystem 接口，并维护了一个子节点列表 children，可以添加和删除子节点。在 display 方法中，它首先输出文件夹名，然后依次调用子节点的 display 方法输出子节点信息。

    在客户端代码中，我们创建了一些文件和文件夹，然后将它们组合成了一个树形结构，最后调用根最后调用根节点（即 folder2）的 display 方法，输出了整个文件系统的信息。这样，我们就可以通过组合模式，使用相同的方式来处理单个文件和整个文件系统。

    案例一（进阶）

    那接下来我们将文件目录的案例做一个升级，如何设计实现支持递归遍历的文件系统目录树结构？

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

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

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

    1. // 文件 与 目录
    2. public class FileSystemNode {
    3.     private String path;
    4.     // 标识区分（文件 -- 目录）
    5.     private boolean isFile;
    6.     private List subNodes = new ArrayList<>();
    7.     
    8.     public FileSystemNode(String path, boolean isFile) {
    9.         this.path = path;
    10.         this.isFile = isFile;
    11.     }
    12.     
    13.     public int countNumOfFiles() {
    14.         if (isFile) {
    15.             return 1;
    16.         }
    17.         int numOfFiles = 0;
    18.         for (FileSystemNode fileOrDir : subNodes) {
    19.             numOfFiles += fileOrDir.countNumOfFiles();
    20.         }
    21.         return numOfFiles;
    22.     }
    23.     
    24.     public long countSizeOfFiles() {
    25.         if (isFile) {
    26.             File file = new File(path);
    27.             if (!file.exists()) return 0;
    28.             return file.length();
    29.         }
    30.         long sizeofFiles = 0;
    31.         for (FileSystemNode fileOrDir : subNodes) {
    32.             sizeofFiles += fileOrDir.countSizeOfFiles();
    33.         }
    34.         return sizeofFiles;
    35.     }
    36.     
    37.     public String getPath() {
    38.         return path;
    39.     }
    40.     
    41.     public void addSubNode(FileSystemNode fileOrDir) {
    42.         subNodes.add(fileOrDir);
    43.     }
    44.     
    45.     public void removeSubNode(FileSystemNode fileOrDir) {
    46.         int size = subNodes.size();
    47.         for (int i = 0; i < size; ++i) {
    48.             if (subNodes.get(i).getPath().equalsIgnoreCase(fileOrDir.getPath())) {
    49.                 subNodes.remove(i);
    50.                 i--;
    51.             }
    52.         }
    53.     }
    54. }

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

    按照这个设计思路，我们对代码进行重构。

    重构之后的代码如下所示：

    1. public abstract class FileSystemNode {
    2.     protected String path;
    3.     public FileSystemNode(String path) {
    4.         this.path = path;
    5.     }
    6.     public abstract int countNumOfFiles();
    7.     public abstract long countSizeOfFiles();
    8.     public String getPath() {
    9.         return path;
    10.     }
    11. }
    12.  
    13. public class File extends FileSystemNode {
    14.     public File(String path) {
    15.         super(path);
    16.     }
    17.     @Override
    18.     public int countNumOfFiles() {
    19.         return 1;
    20.     }
    21.     @Override
    22.     public long countSizeOfFiles() {
    23.         java.io.File file = new java.io.File(path);
    24.         if (!file.exists()) return 0;
    25.         return `
    26.     }
    27. }
    28.  
    29. public class Directory extends FileSystemNode {
    30.     private List subNodes = new ArrayList<>();
    31.     public Directory(String path) {
    32.         super(path);
    33.     }
    34.     @Override
    35.     public int countNumOfFiles() {
    36.         int numOfFiles = 0;
    37.         for (FileSystemNode fileOrDir : subNodes) {
    38.             numOfFiles += fileOrDir.countNumOfFiles();
    39.         }
    40.         return numOfFiles;
    41.     }
    42.     @Override
    43.     public long countSizeOfFiles() {
    44.         long sizeofFiles = 0;
    45.         for (FileSystemNode fileOrDir : subNodes) {
    46.             sizeofFiles += fileOrDir.countSizeOfFiles();
    47.         }
    48.         return sizeofFiles;
    49.     }
    50.  
    51.     public void addSubNode(FileSystemNode fileOrDir) {
    52.         subNodes.add(fileOrDir);
    53.     }
    54.     
    55.     public void removeSubNode(FileSystemNode fileOrDir) {
    56.         int size = subNodes.size();
    57.         int i = 0;
    58.         for (; i < size; ++i) {
    59.             if (subNodes.get(i).getPath().equalsIgnoreCase(fileOrDir.getPath())) {
    60.                 break;
    61.             }
    62.         }
    63.         if (i < size) {
    64.             subNodes.remove(i);
    65.         }
    66.     }
    67. }

    文件和目录类都设计好了，我们来看，如何用它们来表示一个文件系统中的目录树结构。

    具体的代码示例如下所示：

    1. public class Demo {
    2.     public static void main(String[] args) {
    3.         Directory fileSystemTree = new Directory("/");
    4.         Directory nodeYdlclass = new Directory("/ydlclass/");
    5.         Directory nodeYdl = new Directory("/ydl/");
    6.         fileSystemTree.addSubNode(nodeYdlclass);
    7.         fileSystemTree.addSubNode(nodeYdl);
    8.  
    9.         File nodeYdlclassA = new File("/ydlclass/a.txt");
    10.         File nodeYdlclassB = new File("/ydlclass/b.txt");
    11.         Directory nodeYdlclassMovies = new Directory("/ydlclass/movies/");
    12.         nodeYdlclass.addSubNode(nodeYdlclassA);
    13.         nodeYdlclass.addSubNode(nodeYdlclassB);
    14.         nodeYdlclass.addSubNode(nodeYdlclassMovies);
    15.         File nodeYdlclassMoviesC = new File("/ydlclass/movies/c.avi");
    16.         nodeYdlclassMovies.addSubNode(nodeYdlclassMoviesC);
    17.         
    18.         System.out.println("/ files num:" + fileSystemTree.countNumOfFiles());
    19.         System.out.println("/wz/ files num:" + node_wz.countNumOfFiles());
    20.     }
    21. }

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

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

    案例二

    假设我们在开发一个 OA 系统（办公自动化系统）。公司的组织结构包含部门和员工两种数据类型。其中，部门又可以包含子部门和员工。在数据库中的表结构如下所示：

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

    部门包含子部门和员工，这是一种嵌套结构，可以表示成树这种数据结构。计算每个部门的薪资开支这样一个需求，也可以通过在树上的遍历算法来实现。所以，从这个角度来看，这个应用场景可以使用组合模式来设计和实现。

    这个例子的代码结构跟上一个例子的很相似，代码实现我直接贴在了下面，你可以对比着看一下。其中，HumanResource 是部门类（Department）和员工类（Employee）抽象出来的父类，为的是能统一薪资的处理逻辑。Demo 中的代码负责从数据库中读取数据并在内存中构建组织架构图。

    1. public abstract class HumanResource {
    2.     protected long id;
    3.     protected double salary;
    4.     public HumanResource(long id) {
    5.         this.id = id;
    6.     }
    7.     public long getId() {
    8.         return id;
    9.     }
    10.     public abstract double calculateSalary();
    11. }
    12.  
    13. public class Employee extends HumanResource {
    14.     public Employee(long id, double salary) {
    15.         super(id);
    16.         this.salary = salary;
    17.     }
    18.     @Override
    19.     public double calculateSalary() {
    20.         return salary;
    21.     }
    22. }
    23.  
    24. public class Department extends HumanResource {
    25.     private List subNodes = new ArrayList<>();
    26.     public Department(long id) {
    27.         super(id);
    28.     }
    29.     @Override
    30.     public double calculateSalary() {
    31.         double totalSalary = 0;
    32.         for (HumanResource hr : subNodes) {
    33.             totalSalary += hr.calculateSalary();
    34.         }
    35.         this.salary = totalSalary;
    36.         return totalSalary;
    37.     }
    38.     public void addSubNode(HumanResource hr) {
    39.         subNodes.add(hr);
    40.     }
    41. }
    42. // 构建组织架构的代码
    43. public class Demo {
    44.     private static final long ORGANIZATION_ROOT_ID = 1001;
    45.     private DepartmentRepo departmentRepo; // 依赖注入
    46.     private EmployeeRepo employeeRepo; // 依赖注入
    47.     public void buildOrganization() {
    48.         Department rootDepartment = new Department(ORGANIZATION_ROOT_ID);
    49.         buildOrganization(rootDepartment);
    50.     }
    51.     private void buildOrganization(Department department) {
    52.         List subDepartmentIds = departmentRepo.getSubDepartmentIds(department.getId());
    53.         for (Long subDepartmentId : subDepartmentIds) {
    54.             Department subDepartment = new Department(subDepartmentId);
    55.             department.addSubNode(subDepartment);
    56.             buildOrganization(subDepartment);
    57.         }
    58.         List employeeIds = employeeRepo.getDepartmentEmployeeIds(department.getId());
    59.         for (Long employeeId : employeeIds) {
    60.             double salary = employeeRepo.getEmployeeSalary(employeeId);
    61.             department.addSubNode(new Employee(employeeId, salary));
    62.         }
    63.     }
    64. }

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

    二、组合模式优缺点

    优点

    1. 可以使用相同的方式来处理单个对象和组合对象，客户端无需知道对象的具体类型。
    2. 可以方便地增加新的组合对象或叶子对象，同时也可以方便地对组合对象进行遍历和操作。
    3. 可以使代码更加简洁和易于维护，因为使用组合模式可以避免大量的 if-else 或 switch-case 语句。

    缺点

    1. 在组合对象中，可能会包含大量的叶子对象，这可能会导致系统的性能下降。
    2. 可能会使设计过于抽象化，使得代码难以理解和维护。

    总之，组合模式在处理树形结构等层次结构时非常有用，可以方便地处理单个对象和组合对象，使得代码更加简洁和易于维护。

    三、重点回顾

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

    组合模式，将一组对象组织成树形结构，将单个对象和组合对象都看做树中的节点，以统一处理逻辑，并且它利用树形结构的特点，递归地处理每个子树，依次简化代码实现。使用组合模式的前提在于，你的业务场景必须能够表示成树形结构。所以，组合模式的应用场景也比较局限，它并不是一种很常用的设计模式。

    四、源码应用

    1、JDK源码

    组合模式在 JDK 源码中也有很多应用。以下是一些常见的使用场景：

    1. Java Collection 框架：在 Java Collection 框架中，Collection 接口就是一个抽象构件，它定义了集合对象的通用接口。List、Set 和 Map 等具体集合类就是组合节点或叶子节点，用于存储和操作集合中的元素。
    2. Servlet API：在 Servlet API 中，ServletRequest 和 ServletResponse 接口就是一个抽象构件，它定义了 Servlet 的通用接口。HttpServletRequest 和 HttpServletResponse 等具体类就是组合节点或叶子节点，用于处理 Web 请求和响应。

    总之，组合模式在 JDK 源码中也有着广泛的应用，可以帮助开发者更加方便地操作各种层次结构。

    2、SSM源码

    在 SSM（Spring + Spring MVC + MyBatis）框架中，组合模式也有一些应用场景，以下是一些常见的使用场景：

    1. Spring MVC：在 Spring MVC 中，Controller 就是一个组合节点，它可以包含其他组合对象或叶子对象，用于处理 Web 请求和响应。对于复杂的请求处理逻辑，可以将一个 Controller 分解成多个子 Controller，然后通过组合的方式将它们组合起来，使得请求处理逻辑更加清晰和易于维护。
    2. MyBatis：在 MyBatis 中，SqlNode 就是一个抽象构件，它定义了 SQL 节点的通用接口。WhereSqlNode、ChooseSqlNode、IfSqlNode 等具体类就是组合节点或叶子节点，用于构建 SQL 语句，解析动态sql。

    总之，组合模式可以帮助开发者更加方便地管理和组织各种组件和模块。

    文章到这里就结束了，如果有什么疑问的地方，可以在评论区指出~

    希望能和大佬们一起努力，诸君顶峰相见

    再次感谢各位小伙伴儿们的支持！！！

  • 相关阅读:
    面试题005-Java-JVM(上)
    ​数据库查询进阶--多表查询
    深度学习的模型剪枝
    数仓面试题（1）
    【LeetCode】寻找两个正序数组的中位数 [H]（二分法）
    记录链接方法概述总结
    LVGL V8.2 嵌入式Linux平台使用tslib实现输入接口(以SSD212为例)
    在Linux中使用shell指令完成文件打包、压缩、解压缩
    java计算机毕业设计菜谱宣传系统源码+系统+lw文档+mysql数据库+部署
    MySQL之函数
  • 原文地址：https://blog.csdn.net/weixin_43715214/article/details/132764656