组合模式（超详细）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

前言

在软件开发中，我们经常需要处理复杂对象的组织结构，例如文件系统中的目录和文件、公司组织中的部门与员工、图形编辑器中的形状组合等。这些场景通常具有明显的层次化特征，如何高效地管理这些结构并统一操作它们，是开发者面临的重要挑战。组合模式（Composite Pattern）正是为解决这类问题而设计的经典设计模式，它通过将对象组合成树形结构，使客户端可以一致地对待单个对象和组合对象。本文将从基础概念到实战应用，深入剖析组合模式的设计思想与实现方法，帮助读者掌握这一模式的核心价值。

核心概念：树形结构的统一操作

组合模式的核心在于“整体-部分”（Whole-Part）的递归结构。它允许开发者将单个对象（Leaf）和包含多个对象的容器（Composite）视为同一类型，从而通过统一的接口进行操作。这种设计避免了因对象类型不同而引发的条件判断，简化了代码逻辑。

1. 核心角色解析

• Component（抽象组件）：定义对象的公共接口，声明所有对象（叶子和容器）的通用行为。
• Leaf（叶子节点）：代表不可再分解的个体对象，例如文件系统中的具体文件或公司中的普通员工。
• Composite（容器节点）：包含其他对象（叶子或容器），实现与叶子节点相同的接口，并通过递归调用管理子节点。

比喻：想象一个俄罗斯套娃，最外层的“大娃”可以包含多个“小娃”，而每个小娃可能又是另一个套娃的容器。无论层级如何嵌套，外部用户只需通过“打开套娃”的统一动作即可操作所有层级。

核心实现：从抽象到具体

组合模式的实现需要遵循“接口统一、递归操作”的原则。以下通过一个简单的文件系统案例，逐步展示其代码结构。

2.1 定义抽象组件接口

// Component.java  
public interface FileSystemNode {  
    void add(FileSystemNode node); // 容器节点专用方法  
    void remove(FileSystemNode node);  
    void display(); // 统一操作接口  
}  

说明：抽象接口FileSystemNode定义了所有节点（文件或目录）的公共行为，包括添加/删除子节点（仅容器支持）和显示自身信息。

2.2 实现叶子节点

// File.java  
public class File implements FileSystemNode {  
    private String name;  
    public File(String name) { this.name = name; }  
    // 叶子节点无需子节点管理，方法抛出异常或返回空  
    @Override  
    public void add(FileSystemNode node) {  
        throw new UnsupportedOperationException("文件不可添加子节点");  
    }  
    @Override  
    public void remove(FileSystemNode node) {  
        throw new UnsupportedOperationException("文件不可删除子节点");  
    }  
    @Override  
    public void display() {  
        System.out.println("文件：" + name);  
    }  
}  

2.3 实现容器节点

// Directory.java  
public class Directory implements FileSystemNode {  
    private String name;  
    private List<FileSystemNode> children = new ArrayList<>();  
    public Directory(String name) { this.name = name; }  
    @Override  
    public void add(FileSystemNode node) {  
        children.add(node);  
    }  
    @Override  
    public void remove(FileSystemNode node) {  
        children.remove(node);  
    }  
    @Override  
    public void display() {  
        System.out.println("目录：" + name);  
        for (FileSystemNode node : children) {  
            node.display(); // 递归调用子节点的display()  
        }  
    }  
}  

2.4 客户端调用示例

// Client.java  
public class Client {  
    public static void main(String[] args) {  
        // 创建根目录  
        Directory root = new Directory("根目录");  
        // 添加子目录  
        Directory docs = new Directory("文档");  
        root.add(docs);  
        // 添加文件  
        docs.add(new File("报告.doc"));  
        docs.add(new File("代码.txt"));  
        // 递归显示所有节点  
        root.display();  
    }  
}  

输出结果：

目录：根目录  
  目录：文档  
    文件：报告.doc  
    文件：代码.txt  

案例分析：组合模式的多场景应用

3.1 图形编辑器中的形状组合

在图形编辑器中，用户可能需要将多个图形（如矩形、圆形）组合成一个整体，以便统一移动、缩放。组合模式可轻松实现这一功能：

// Shape.java（抽象组件）  
public interface Shape {  
    void draw();  
    void add(Shape shape); // 容器专用  
    void remove(Shape shape);  
}  

// Circle.java（叶子节点）  
public class Circle implements Shape {  
    @Override  
    public void draw() { System.out.println("绘制圆形"); }  
    @Override  
    public void add(Shape shape) { throw new UnsupportedOperationException(); }  
    @Override  
    public void remove(Shape shape) { throw new UnsupportedOperationException(); }  
}  

// GroupShape.java（容器节点）  
public class GroupShape implements Shape {  
    private List<Shape> shapes = new ArrayList<>();  
    @Override  
    public void draw() {  
        for (Shape s : shapes) { s.draw(); }  
    }  
    @Override  
    public void add(Shape shape) { shapes.add(shape); }  
    @Override  
    public void remove(Shape shape) { shapes.remove(shape); }  
}  

3.2 公司组织架构管理

公司中部门（Composite）可以包含子部门或员工（Leaf），组合模式可统一管理薪资计算、权限分配等操作：

// OrganizationComponent.java  
public interface OrganizationComponent {  
    void add(OrganizationComponent component);  
    void remove(OrganizationComponent component);  
    void display(); // 打印组织结构  
    double calculateTotalSalary(); // 计算总薪资  
}  

// Department.java（容器）  
public class Department implements OrganizationComponent {  
    private String name;  
    private List<OrganizationComponent> members = new ArrayList<>();  
    @Override  
    public double calculateTotalSalary() {  
        double total = 0;  
        for (OrganizationComponent m : members) {  
            total += m.calculateTotalSalary(); // 递归计算  
        }  
        return total;  
    }  
}  

// Employee.java（叶子）  
public class Employee implements OrganizationComponent {  
    private double salary;  
    @Override  
    public double calculateTotalSalary() { return salary; }  
}  

设计原则与扩展思考

4.1 遵循开闭原则

组合模式通过抽象接口隔离了客户端与具体实现，新增节点类型时无需修改现有代码。例如，若需添加“链接文件”类型，只需实现FileSystemNode接口即可无缝集成。

4.2 与继承模式的对比

传统继承方式可能导致类爆炸问题，例如为每个组合类型定义独立类。组合模式通过“组合优于继承”的原则，用对象组合替代复杂的类层次结构，显著降低代码耦合度。

4.3 注意事项

• 递归深度问题：过深的树形结构可能引发栈溢出，需考虑迭代实现或优化算法。
• 操作一致性：容器节点需确保所有操作（如display()）能正确递归调用子节点。

结论

组合模式通过“整体-部分”结构，为复杂对象的统一管理提供了优雅的解决方案。它不仅简化了客户端代码，还增强了系统的扩展性和可维护性。无论是文件系统、图形编辑器，还是企业架构管理，组合模式都能帮助开发者构建灵活且易于扩展的树形结构。掌握这一模式，将使你在面对层次化数据时，能够游刃有余地设计出简洁高效的应用。

在实际开发中，建议结合具体场景选择是否使用组合模式。例如，当需要统一操作单个对象与组合对象时，或希望避免因类型差异导致的条件判断时，组合模式都是理想的选择。通过本文的案例分析与代码示例，相信读者已能初步掌握这一模式的核心思想，并在实践中灵活应用。