Java 23 种设计模式：从踩坑到精通 | 组合模式 —— 树形结构处理，部分与整体一视同仁

Java 23 种设计模式：从踩坑到精通 | 组合模式 —— 树形结构处理，部分与整体一视同仁

摘要：业务代码里充斥着 if-else 来判断是“文件”还是“文件夹”？每次新增一种节点类型都要修改十几处逻辑？在 2026 年的微服务架构中，这种“面条代码”往往是性能下降的隐形杀手。本文带你用组合模式彻底消灭这些重复判断——通过透明式与安全式的深度剖析，结合 Spring Security 源码实录与 AI 辅助编程演示，让你彻底掌握树形结构处理的终极奥义。

📖 《Java 23 种设计模式：从踩坑到精通》 开篇：系列介绍与目录　｜　上一篇：桥接模式　｜　当前：组合模式　｜　下一篇：装饰器模式 🔗 返回系列总目录

1. 你还在写“面条代码”吗？

假设你正在开发一个 2026 年的低代码平台，需要处理复杂的页面组件树：

if (component.isContainer()) {
for (Component child : component.getChildren()) {
// 递归处理
}
} else {
// 渲染组件
}

当产品说“我们要增加一种循环容器”时，你必须去改所有写过 if-else 的地方。这不仅违背了开闭原则，更让代码变得像面条一样纠缠不清。在微服务架构中，复杂的树形菜单或权限结构处理往往成为服务性能的隐形杀手。

组合模式（Composite Pattern）正是为解决这种“部分-整体层次结构”的访问一致性而生的：它将对象组合成树形结构以表示“部分-整体”的层次关系，使得客户端对单个对象和组合对象的使用具有一致性。

💡 核心逻辑：组合模式 = 树形结构 + 一致接口。

1.1 你的场景该不该用组合模式？

2. 模式定义与 UML 结构

组合模式 将对象组合成树形结构以表示“部分-整体”的层次关系，使得用户对单个对象和组合对象的使用具有一致性。它属于 结构型设计模式。

标准组合模式的 UML 类图：

三个角色：

• Component（抽象构件）：定义叶子构件和容器构件的公共接口，可以是抽象类或接口；
• Leaf（叶子构件）：表示树中的叶子节点，没有子节点；
• Composite（容器构件）：包含子节点（可以是叶子或其他容器），提供管理子节点的方法和统一的 operation()。

💡 根据管理子节点方法（add/remove）的位置，可分为透明式组合和安全式组合两种。

3. 透明组合与安全组合

3.1 透明组合

将所有管理方法（add/remove）定义在抽象 Component 中，让 Leaf 和 Composite 都实现它们。Leaf 的方法抛出异常或不处理。这样客户端完全一致，但运行时可能抛出异常。

3.2 安全组合

只在 Composite 中定义管理方法，Component 中只定义业务方法。这样更安全，不会在 Leaf 上调用无意义的方法，但客户端必须区分 Leaf 和 Composite，牺牲了部分透明性。

⚠️ 避坑指南：在实际项目中，除非你有极强的统一接口需求，否则强烈建议使用安全组合。否则后期维护时，Leaf 节点上不断抛出的 UnsupportedOperationException 会让你头疼不已。安全组合更符合单一职责原则。

4. 代码实现：文件系统（透明组合）

4.1 抽象构件

public abstract class FileSystemNode {
protected String name;

public FileSystemNode(String name) {
this.name = name;
}

public abstract void show(int depth);

// 管理子节点方法（透明组合）
public void add(FileSystemNode node) {
throw new UnsupportedOperationException();
}

public void remove(FileSystemNode node) {
throw new UnsupportedOperationException();
}
}

4.2 叶子构件：文件

public class FileNode extends FileSystemNode {
public FileNode(String name) {
super(name);
}

@Override
public void show(int depth) {
// 建议在此处打断点，观察递归过程中 depth 的变化
System.out.println(" ".repeat(depth) + "📄 文件：" + name);
}
}

4.3 容器构件：文件夹

public class FolderNode extends FileSystemNode {
private List<FileSystemNode> children = new ArrayList<>();

public FolderNode(String name) {
super(name);
}

@Override
public void add(FileSystemNode node) {
children.add(node);
}

@Override
public void remove(FileSystemNode node) {
children.remove(node);
}

@Override
public void show(int depth) {
// 建议在 show() 处打断点，观察 children 的递归压栈过程
System.out.println(" ".repeat(depth) + "📁 文件夹：" + name);
for (FileSystemNode child : children) {
child.show(depth + 1); // 递归调用，深度+1
}
}
}

4.4 客户端调用

public class Client {
public static void main(String[] args) {
FileSystemNode root = new FolderNode("root");
FileSystemNode home = new FolderNode("home");
FileSystemNode docs = new FolderNode("docs");
FileSystemNode file1 = new FileNode("readme.txt");
FileSystemNode file2 = new FileNode("image.png");

root.add(home);
root.add(docs);
docs.add(file1);
docs.add(file2);

root.show(0);
}
}

运行结果：

📁 文件夹：root
📁 文件夹：home
📁 文件夹：docs
📄 文件：readme.txt
📄 文件：image.png

客户端完全不用区分文件和文件夹，统一调用 show() 即可递归展示整棵树。

🔧 调试技巧：在 FolderNode.show() 处打断点，观察 children 的递归压栈过程，你会对组合模式的执行流程有更直观的理解。

5. 代码实现：组织架构（安全组合，推荐）

5.1 抽象构件

public interface Employee {
void showDetail();
}

5.2 叶子构件：员工

public class IndividualEmployee implements Employee {
private String name;
private String position;

public IndividualEmployee(String name, String position) {
this.name = name;
this.position = position;
}

@Override
public void showDetail() {
System.out.println(" 员工：" + name + "，职位：" + position);
}
}

5.3 容器构件：部门

public class Department implements Employee {
private String name;
private List<Employee> members = new ArrayList<>();

public Department(String name) {
this.name = name;
}

// 子节点管理方法只在 Composite 中定义（安全组合）
public void add(Employee e) {
members.add(e);
}

public void remove(Employee e) {
members.remove(e);
}

@Override
public void showDetail() {
System.out.println("部门：" + name);
for (Employee member : members) {
member.showDetail();
}
}
}

5.4 客户端调用

Department company = new Department("总公司");
Department devDept = new Department("研发部");
Employee alice = new IndividualEmployee("Alice", "高级工程师");
Employee bob = new IndividualEmployee("Bob", "实习生");

devDept.add(alice);
devDept.add(bob);
company.add(devDept);

company.showDetail();

输出：

部门：总公司
部门：研发部
员工：Alice，职位：高级工程师
员工：Bob，职位：实习生

如果新增一个“子公司”部门，它同样是 Employee 类型，只需将子部门加入总公司，无需修改现有代码。

6. 优缺点一览

⚠️ 避坑：如果树深度过大或节点过多，递归遍历可能导致栈溢出或性能瓶颈。此时可考虑懒加载（只加载当前层，展开时再加载子节点）或迭代器模式替代递归。

7. 进阶：Spring Security 源码中的组合模式

Spring Security 的配置构建器是组合模式的经典应用。HttpSecurity 作为容器，SecurityConfigurer 的各种子类作为叶子或容器，通过组合形成安全配置树。

核心源码（AbstractConfiguredSecurityBuilder 简化版）：

public abstract class AbstractConfiguredSecurityBuilder<O, B extends SecurityBuilder<O>>
extends AbstractSecurityBuilder<O> {

// 配置器列表（组合模式的 children）
private final LinkedHashMap<Class<? extends SecurityConfigurer<O, B>>,
List<SecurityConfigurer<O, B>>> configurers = new LinkedHashMap<>();

// 添加配置器（组合模式的 add）
public <C extends SecurityConfigurer<O, B>> C apply(C configurer) throws Exception {
configurer.init(this); // 初始化
configurer.configure(this); // 配置
return configurer;
}

// 构建时遍历所有配置器（组合模式的递归处理）
@Override
protected final O doBuild() throws Exception {
for (SecurityConfigurer<O, B> configurer : getConfigurers()) {
configurer.configure(this); // 统一调用
}
return performBuild();
}
}

对应关系：

客户端调用：

http
.cors().and() // 添加 CorsConfigurer
.csrf().disable() // 修改 CsrfConfigurer
.authorizeRequests()
.anyRequest().authenticated();

💡 HttpSecurity 通过 and() 方法返回父级容器，形成配置链。最终调用 build() 时，递归遍历所有子配置器，统一应用安全规则——这正是组合模式的“统一处理”思想的体现。

8. 组合模式 vs 解释器模式（面试连环炮）

面试官：“组合模式和解释器模式都用到了树，它们有什么关系？”

答：虽然都用树，但解释器模式通常建立在组合模式的基础上（如 Spring Expression Language 解析表达式时，先构建组合树，再递归求值）。组合模式关注 “结构”（统一处理部分与整体），解释器关注 “计算”（递归求值语法树）。

9. AI 时代的组合模式

9.1 AI 辅助生成组合模式代码

推荐 Prompt： “我有一个 FileSystemNode 抽象类，它有 FolderNode 容器和 FileNode 叶子两种实现。请帮我新增一个 ShortcutNode 叶子节点，它指向另一个 FileSystemNode，并在 show() 方法中显示 ‘快捷方式 -> 目标文件名’。遵循透明组合模式，保持客户端调用一致。”

AI 会快速生成符合组合模式的类结构，无需手动复制粘贴现有代码。你还可以进一步要求：

“请在这段代码中增加 isLeaf() 方法，方便客户端判断当前节点是否为叶子，并给出使用示例。”

9.2 常见 AI 交互场景

10. 常见误区与面试高频题

❌ 误区1：组合模式就是树结构 组合模式不仅提供树结构，更强调客户端对叶子和容器使用的一致性，这是它区别于普通树的核心。

❌ 误区2：透明组合一定比安全组合好 透明组合牺牲了安全性，增加了运行时错误风险。在多数业务场景中，安全组合更符合单一职责原则。

❌ 误区3：组合模式适用于所有树形场景 如果树深度过大或节点过多，递归遍历可能导致栈溢出。此时应配合懒加载或迭代器模式使用。

💡 面试高频追问

• 组合模式的好处？ → 客户端无需区分叶子与容器，统一操作，易于扩展。
• 透明组合与安全组合的区别？ → 管理子节点方法的位置不同，前者放在抽象构件，后者只放在容器构件。
• 如果只想遍历叶子节点，不想遍历容器，怎么办？ → 在 Component 接口中定义 isLeaf() 方法，或使用访问者模式对不同节点类型分别处理。
• 组合模式会导致大对象产生吗？如何解决？ → 会。解决方式是懒加载（只加载当前层，展开时再加载子节点）或分页处理。
• Java 中哪里用了组合模式？ → AWT/Swing 的 Container 和 Component、Spring Security 的 SecurityConfigurer。

🎉 恭喜：如果你能立刻画出文件系统的树形结构，说出透明组合与安全组合的区别，并理解 Spring Security 为什么用 HttpSecurity.apply() 统一处理配置，你已经掌握了组合模式的核心。面试中遇到“如何统一处理树形结构”的问题，这将是你的完美答案。

11. 六大设计原则在组合模式中的体现

12. 总结

组合模式是处理树形层次结构的首选方案，它通过统一叶子与容器的接口，让客户端可以一致地处理单个对象和对象集合。在文件系统、菜单、权限树等场景中，组合模式能大幅简化递归操作，提升系统的可扩展性。

✅ 最终建议：遇到“部分-整体”层次结构时，优先使用安全组合模式，将管理子节点的方法放在容器中；只有在需要完全透明且能容忍运行时异常时，才采用透明组合。如果树深度过大，配合懒加载或迭代器模式使用，避免栈溢出。

🧭 《Java 23 种设计模式：从踩坑到精通》快速导航

• 开篇：系列介绍与目录
• 上一篇：Java 23 种设计模式：从踩坑到精通 | 桥接模式 —— 类爆炸？试试分离抽象与实现
• 当前：Java 23 种设计模式：从踩坑到精通 | 组合模式 —— 树形结构处理，部分与整体一视同仁（你在这里）
• 下一篇：Java 23 种设计模式：从踩坑到精通 | 装饰器模式 —— 比继承更灵活的扩展方式，你用过吗？ 🚧 即将发布
• 创建型模式汇总：单例、工厂、建造者、原型
• 结构型模式汇总：适配器、装饰器、代理……
• 行为型模式汇总：观察者、策略、模板方法……

🔔 关注《Java 23 种设计模式：从踩坑到精通》，用 25 篇文章彻底吃透设计模式。 📦 福利预告：全系列代码及 UML 源码将在完结时统一打包开放，点击「关注」「收藏」第一时间获取。 🚀 下一篇：装饰器模式 —— 比继承更灵活的扩展方式，你用过吗？🚧 即将发布，敬请关注！

📌 除了设计模式，我也在深挖智能物流实战（WMS、托盘调度、机器学习落地）。欢迎点击头像，看看专栏 《出版社物流WMS智能调度实战》。技术相通，思路可鉴。