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

这篇具有很好参考价值的文章主要介绍了【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(组合节点):表示组合对象中的组合节点,它可以包含其他组合对象或叶子对象。

案例一

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

// Component(抽象构件)
interface FileSystem {
    void display();
}

// Leaf(叶子节点)-- 文件
class File implements FileSystem {
    private String name;
    
    public File(String name) {
        this.name = name;
    }
    
    @Override
    public void display() {
        System.out.println("File: " + name);
    }
}

// Composite(组合节点) -- 文件夹
class Folder implements FileSystem {
    // 文件夹里面有 -- 文件、文件夹
    private String name;
    private List<FileSystem> children; 
    
    public Folder(String name) {
        this.name = name;
        children = new ArrayList<>();
    }
    
    public void add(FileSystem fileSystem) {
        children.add(fileSystem);
    }
    
    public void remove(FileSystem fileSystem) {
        children.remove(fileSystem);
    }
    
    @Override
    public void display() {
        System.out.println("Folder: " + name);
        for (FileSystem fileSystem : children) {
            fileSystem.display();
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 文件
        FileSystem file1 = new File("file1.txt");
        FileSystem file2 = new File("file2.txt");

        // 文件夹
        Folder folder1 = new Folder("folder1");
        folder1.add(file1);
        folder1.add(file2);
        
        FileSystem file3 = new File("file3.txt");
        FileSystem file4 = new File("file4.txt");
        
        Folder folder2 = new Folder("folder2");
        folder2.add(file3);
        folder2.add(file4);
        folder2.add(folder1);
        
        folder2.display();
    }
}

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

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

案例一(进阶)

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

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

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

我这里给出了这个类的骨架代码,在下面的代码实现中,我们把文件目录统一用 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();
        for (int i = 0; i < size; ++i) {
            if (subNodes.get(i).getPath().equalsIgnoreCase(fileOrDir.getPath())) {
                subNodes.remove(i);
                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 `
    }
}

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) {
        Directory fileSystemTree = new Directory("/");
        Directory nodeYdlclass = new Directory("/ydlclass/");
        Directory nodeYdl = new Directory("/ydl/");
        fileSystemTree.addSubNode(nodeYdlclass);
        fileSystemTree.addSubNode(nodeYdl);

        File nodeYdlclassA = new File("/ydlclass/a.txt");
        File nodeYdlclassB = new File("/ydlclass/b.txt");
        Directory nodeYdlclassMovies = new Directory("/ydlclass/movies/");
        nodeYdlclass.addSubNode(nodeYdlclassA);
        nodeYdlclass.addSubNode(nodeYdlclassB);
        nodeYdlclass.addSubNode(nodeYdlclassMovies);
        File nodeYdlclassMoviesC = new File("/ydlclass/movies/c.avi");
        nodeYdlclassMovies.addSubNode(nodeYdlclassMoviesC);
        
        System.out.println("/ files num:" + fileSystemTree.countNumOfFiles());
        System.out.println("/wz/ files num:" + node_wz.countNumOfFiles());
    }
}

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

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

案例二

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

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

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

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

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

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

二、组合模式优缺点

优点

  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。

【23种设计模式】组合模式【⭐】,23种设计模式,组合模式,java,设计模式,结构型模式,接口

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

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

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

再次感谢各位小伙伴儿们的支持!!!文章来源地址https://www.toymoban.com/news/detail-708161.html

到了这里,关于【23种设计模式】组合模式【⭐】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【地铁上的设计模式】--结构型模式:组合模式

    什么是组合模式 组合模式是一种结构型设计模式,将对象组合成树形结构,以表示部分整体的层次结构,让用户对单个对象和组合对象的使用具有一致性。 在组合模式中,抽象构件定义了一个统一的接口,用于管理所有对象,叶子节点和组合节点都实现了该接口。叶子节点

    2024年02月02日
    浏览(38)
  • 【Java 设计模式】结构型之桥接模式

    桥接模式(Bridge Pattern)是一种结构型设计模式, 它将抽象部分与实现部分分离,使它们可以独立变化,从而降低它们之间的耦合 。桥接模式通过将抽象部分和实现部分分离,使得它们可以独立地变化,同时在它们之间建立一个桥梁。在本文中,我们将介绍 Java 中桥接模式的

    2024年01月19日
    浏览(45)
  • Java学习——设计模式——结构型模式2

    结构型模式主要涉及如何组合各种对象以便获得更好、更灵活的结构。虽然面向对象的继承机制提供了最基本的子类扩展父类的功能,但结构型模式不仅仅简单地使用继承,而更多地通过组合与运行期的动态组合来实现更灵活的功能。 包括: 1、适配器 2、桥接 3、组合 4、装

    2024年02月03日
    浏览(45)
  • 【Java 设计模式】结构型之外观模式

    外观模式(Facade Pattern)是一种结构型设计模式, 它为复杂系统提供了一个简化的接口,隐藏了系统的复杂性,使得客户端更容易使用系统 。外观模式通过创建一个包装类(外观类),将系统的复杂性封装起来,对客户端提供一个简单的接口。在本文中,我们将深入研究Ja

    2024年01月21日
    浏览(44)
  • 【Java 设计模式】结构型之代理模式

    代理模式(Proxy Pattern)是一种结构型设计模式, 它允许通过一个代理对象控制对其他对象的访问 。代理模式在访问对象时引入了一定程度的间接性,使得可以在访问对象前后进行一些额外的操作。在本文中,我们将深入研究Java中代理模式的定义、结构、使用场景以及如何在

    2024年01月21日
    浏览(47)
  • 【十】设计模式~~~结构型模式~~~享元模式(Java)

    【学习难度:★★★★☆,使用频率:★☆☆☆☆】         面向对象技术可以很好地解决一些灵活性或可扩展性问题,但在很多情况下需要在系统中增加类和对象的个数。当对象数量太多时,将导致运行代价过高,带来性能下降等问题。 享元模式正是为解决这一类问题

    2024年02月08日
    浏览(49)
  • Java设计模式-结构型-适配器模式

    ​ 与电源适配器相似,在适配器模式中引入了一个被称为适配器(Adapter)的包装类,而它所包装的对象称为适配者(Adaptee),即被适配的类。适配器的实现就是把客户类的请求转化为对适配者的相应接口的调用。也就是说:当客户类调用适配器的方法时,在适配器类的内部将调用

    2024年02月20日
    浏览(54)
  • 【Java 设计模式】结构型之适配器模式

    适配器模式(Adapter Pattern)是一种结构型设计模式, 用于将一个类的接口转换成客户端期望的另一个接口 。这种模式使得原本由于接口不兼容而不能一起工作的类可以一起工作。在本文中,我们将介绍 Java 中适配器模式的定义、结构、使用场景以及如何在实际开发中应用。

    2024年01月19日
    浏览(45)
  • 【Java 设计模式】结构型之享元模式

    享元模式(Flyweight Pattern)是一种结构型设计模式,它旨在减少对象的数量以节省内存和提高性能。享元模式通过共享大量相似对象的状态,使得这些对象可以共享,而不需要在每个对象中都存储相同的数据。在本文中,我们将深入研究Java中享元模式的定义、结构、使用场景

    2024年01月22日
    浏览(52)
  • Java设计模式之结构型-桥接模式(UML类图+案例分析)

    目录 一、基础概念 二、UML类图 三、角色设计 四、案例分析 4.1、支付方式 4.2、支付渠道  五、总结 桥接模式(Bridge Pattern)是一种结构型设计模式,其主要目的是“将抽象部分与实现部分分离,使它们都可以独立地变化”。 桥接模式的核心思想是把抽象(abstraction)与实现

    2024年02月13日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包