设计模式学习笔记 - 设计模式与范式 -结构型:6.组合模式

概述

结构性设计模式,还剩下两个不那么常用的:组合模式和享元模式。本章介绍下组合模式

组合模式和之前讲的面向对象设计中的 "组合关系(通过组合来组装两个类)",完全是两码事。这里讲的 "组合模式",主要是用来处理树形结构数据。这里的 "数据",可以简单理解为一组对象集合。

正因为其应用场景的特殊性,数据必须能表示成树形结构,这也导致了这种模式在实际的项目开发中不那么常用。但是,一旦满足树形结构,应用这种设计模式就能发挥很大的作用,能让代码变得非常简洁。


组合模式的原理与实现

在 GoF 《设计模式》中,组合模式是这样定义的:

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

翻译成中文:将一组对象组织(Compose) 成树形结构,以表示一种 "部分 - 整体" 的层次结构。组合让客户端(代码使用者)可以统一单个对象和组合对象的处理逻辑。

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

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

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

java 复制代码
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() {
        int numOfFiles = 0;
        // ...
        return numOfFiles;
    }

    public long countSizeOfFiles() {
        long sizeOfFiles = 0L;
        //...
        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);
        }
    }
}

countNumOfFiles()countSizeOfFiles() 这两个函数,实际上就是树上的递归遍历算法。对于文件,我们直接返回文件的个数(返回 1)或大小。对于目录,遍历目录中每个子目录或者文件,递归计算它们的个数胡哦大小。然后求和,就是这个目录下的文件个数和文件大小。

这两个函数的代码实现贴在了下面。

java 复制代码
    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 = 0L;
        for (FileSystemNode fileOrDir : subNodes) {
            sizeOfFiles += fileOrDir.countSizeOfFiles();
        }
        return sizeOfFiles;
    }

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

按照这个设计思路,对代码进行重构。重构之后的代码如下所示:

java 复制代码
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 = 0L;
        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);
        }
    }
}

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

java 复制代码
public class Demo {
    public static void main(String[] args) {
        /**
         * /
         * /a/
         * /a/1.txt
         * /a/2.txt
         * /a/aa/
         * /a/aa/3.xml
         * /b/
         * /b/docs/
         * /b/docs/4.txt
         */
        Directory fileSystemTree = new Directory("/");
        Directory node_a = new Directory("/a/");
        Directory node_b = new Directory("/b/");
        fileSystemTree.addSubNode(node_a);
        fileSystemTree.addSubNode(node_b);

        File node_a_1 = new File("/a/1.txt");
        File node_a_2 = new File("/a/2.txt");
        Directory node_a_aa = new Directory("/a/aa/");
        node_a.addSubNode(node_a_1);
        node_a.addSubNode(node_a_2);
        node_a.addSubNode(node_a_aa);

        File node_a_aa_3 = new File("/a/aa/3.xml");
        node_a_aa.addSubNode(node_a_aa_3);


        Directory node_b_docs = new Directory("/b/docs/");
        node_b.addSubNode(node_b_docs);

        File node_b_docs_4 = new File("/b/docs/4.txt");
        node_b_docs.addSubNode(node_b_docs_4);

        System.out.println("/ file num: " + fileSystemTree.countNumOfFiles());
        System.out.println("/ a num: " + node_a.countNumOfFiles());
    }
}

照着这个例子,再重新看一下组合模式的定义:"将一组对象(文件和目录)组装成树状结构,以标识一种 '部分 - 整体' 的层次结构(目录与子目录的嵌套结构)。组合模式让客户端可以统一单个对象(文件)和组合对象(目录)的处理逻辑(递归遍历)。"

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

组合模式的应用场景举例

刚刚讲了文件系统的例子,对于组合模式,再举一个例子。搞懂了这两个例子,你基本上就算掌握了组合模式。在实际项目中,遇到类似的可以表示成树形结构的业务场景,你只要 "照葫芦画瓢" 去设计就可以了。

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

部门ID 隶属上级部门ID ... ... ...
id parent_department_id ... ... ...
员工ID 隶属上级部门ID 薪资 ... ... ...
id department_id salary ... ... ...

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

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

这个例子的代码结构跟上一个例子的很相似,代码如下所示。其中 HumanResource 是部门类(Department)和员工类(Employee)抽象出来的父类,为的是能统一薪资的处理逻辑。Demo 中的代码负责从数据库中读取数据并在内存中构建组织架构图。

java 复制代码
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 Demo {
    private static final  long ORGANIZATION_ROOT_ID = 1001;
    private DepartmentRepo departmentRepo; // 依赖注入
    private EmployeeRepo employeeRepo; // 依赖注入

    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));
        }
    }
}

再拿组合模式的定义跟这个例子对照一下:"将一组对象(员工和部门)组装成树状结构,以标识一种 '部分 - 整体' 的层次结构(部门与子部门的嵌套结构)。组合模式让客户端可以统一单个对象(员工)和组合对象(部门)的处理逻辑(递归遍历)。"

总结

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

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

相关推荐
捕鲸叉7 小时前
MVC(Model-View-Controller)模式概述
开发语言·c++·设计模式
wrx繁星点点7 小时前
享元模式:高效管理共享对象的设计模式
java·开发语言·spring·设计模式·maven·intellij-idea·享元模式
凉辰7 小时前
设计模式 策略模式 场景Vue (技术提升)
vue.js·设计模式·策略模式
菜菜-plus7 小时前
java设计模式之策略模式
java·设计模式·策略模式
暗黑起源喵7 小时前
设计模式-迭代器
设计模式
lexusv8ls600h9 小时前
微服务设计模式 - 网关路由模式(Gateway Routing Pattern)
spring boot·微服务·设计模式
sniper_fandc11 小时前
抽象工厂模式
java·设计模式·抽象工厂模式
无敌岩雀14 小时前
C++设计模式结构型模式———外观模式
c++·设计模式·外观模式
hxj..15 小时前
【设计模式】观察者模式
java·观察者模式·设计模式
XYX的Blog17 小时前
设计模式09-行为型模式2(状态模式/策略模式/Java)
设计模式·状态模式·策略模式