Java 组合模式 详解

组合模式详解

一、组合模式概述

组合模式(Composite Pattern)是一种结构型设计模式，它允许你将对象组合成树形结构来表示"部分-整体"的层次结构。组合模式使得客户端对单个对象和组合对象的使用具有一致性。

核心特点

• 统一处理：叶子对象和组合对象具有一致的接口
• 递归结构：组合对象可以包含其他组合对象，形成树形结构
• 透明性：客户端无需知道处理的是单个对象还是组合对象
• 灵活性：可以方便地增加新的组件类型

二、组合模式的结构

主要角色

1. Component：组件抽象类或接口
2. Leaf：叶子节点类
3. Composite：组合节点类

三、组合模式的实现

1. 透明式实现（推荐）

// 组件接口
public interface Component {void operation();void add(Component component);void remove(Component component);Component getChild(int index);
}// 叶子节点
public class Leaf implements Component {private String name;public Leaf(String name) {this.name = name;}public void operation() {System.out.println("叶子节点 " + name + " 执行操作");}// 叶子节点不支持这些方法public void add(Component component) {throw new UnsupportedOperationException();}public void remove(Component component) {throw new UnsupportedOperationException();}public Component getChild(int index) {throw new UnsupportedOperationException();}
}// 组合节点
public class Composite implements Component {private List<Component> children = new ArrayList<>();private String name;public Composite(String name) {this.name = name;}public void operation() {System.out.println("组合节点 " + name + " 执行操作");for (Component component : children) {component.operation();}}public void add(Component component) {children.add(component);}public void remove(Component component) {children.remove(component);}public Component getChild(int index) {return children.get(index);}
}// 使用示例
Component root = new Composite("根节点");
Component branch1 = new Composite("分支1");
Component branch2 = new Composite("分支2");
Component leaf1 = new Leaf("叶子1");
Component leaf2 = new Leaf("叶子2");root.add(branch1);
root.add(branch2);
branch1.add(leaf1);
branch2.add(leaf2);root.operation();

2. 安全式实现

// 组件接口（简化版）
public interface Component {void operation();
}// 组合节点接口
public interface Composite extends Component {void add(Component component);void remove(Component component);Component getChild(int index);
}// 叶子节点实现
public class Leaf implements Component {public void operation() {System.out.println("叶子节点操作");}
}// 组合节点实现
public class ConcreteComposite implements Composite {private List<Component> children = new ArrayList<>();public void operation() {System.out.println("组合节点操作");for (Component component : children) {component.operation();}}public void add(Component component) {children.add(component);}public void remove(Component component) {children.remove(component);}public Component getChild(int index) {return children.get(index);}
}

四、组合模式的应用场景

1. 文件系统实现

// 文件系统组件
public abstract class FileSystemComponent {protected String name;public FileSystemComponent(String name) {this.name = name;}public abstract void display(int depth);public abstract long getSize();
}// 文件（叶子节点）
public class File extends FileSystemComponent {private long size;public File(String name, long size) {super(name);this.size = size;}public void display(int depth) {System.out.println(StringUtils.repeat("  ", depth) + "- " + name);}public long getSize() {return size;}
}// 目录（组合节点）
public class Directory extends FileSystemComponent {private List<FileSystemComponent> children = new ArrayList<>();public Directory(String name) {super(name);}public void add(FileSystemComponent component) {children.add(component);}public void remove(FileSystemComponent component) {children.remove(component);}public void display(int depth) {System.out.println(StringUtils.repeat("  ", depth) + "+ " + name);for (FileSystemComponent component : children) {component.display(depth + 1);}}public long getSize() {long totalSize = 0;for (FileSystemComponent component : children) {totalSize += component.getSize();}return totalSize;}
}

2. 菜单系统实现

// 菜单组件
public abstract class MenuComponent {public void add(MenuComponent component) {throw new UnsupportedOperationException();}public void remove(MenuComponent component) {throw new UnsupportedOperationException();}public MenuComponent getChild(int i) {throw new UnsupportedOperationException();}public String getName() {throw new UnsupportedOperationException();}public String getDescription() {throw new UnsupportedOperationException();}public double getPrice() {throw new UnsupportedOperationException();}public void print() {throw new UnsupportedOperationException();}
}// 菜单项（叶子节点）
public class MenuItem extends MenuComponent {private String name;private String description;private double price;public MenuItem(String name, String description, double price) {this.name = name;this.description = description;this.price = price;}public String getName() {return name;}public String getDescription() {return description;}public double getPrice() {return price;}public void print() {System.out.println("  " + getName() + ", " + getPrice());System.out.println("    -- " + getDescription());}
}// 菜单（组合节点）
public class Menu extends MenuComponent {private List<MenuComponent> menuComponents = new ArrayList<>();private String name;private String description;public Menu(String name, String description) {this.name = name;this.description = description;}public void add(MenuComponent component) {menuComponents.add(component);}public void remove(MenuComponent component) {menuComponents.remove(component);}public MenuComponent getChild(int i) {return menuComponents.get(i);}public String getName() {return name;}public String getDescription() {return description;}public void print() {System.out.println("\n" + getName() + ", " + getDescription());System.out.println("---------------------");for (MenuComponent component : menuComponents) {component.print();}}
}

五、组合模式的变体

1. 带父节点引用的实现

public abstract class Component {protected Component parent;public void setParent(Component parent) {this.parent = parent;}public Component getParent() {return parent;}// 其他方法...
}

2. 支持遍历的实现

public interface IterableComponent extends Component, Iterable<Component> {
}public class Composite implements IterableComponent {// ...其他代码public Iterator<Component> iterator() {return children.iterator();}
}

六、组合模式的优缺点

优点

1. 简化客户端代码：统一处理叶子对象和组合对象
2. 易于扩展：新增组件类型不影响现有结构
3. 灵活的结构：可以构建复杂的树形结构
4. 符合开闭原则：无需修改现有代码即可新增组件

缺点

1. 设计抽象较难：需要合理设计组件接口
2. 类型检查问题：可能需要运行时类型检查
3. 限制性较强：要求所有组件遵循同一接口

七、最佳实践

1. 合理设计组件接口：平衡透明性和安全性
2. 考虑缓存优化：对频繁访问的操作结果进行缓存
3. 实现遍历功能：为组合结构提供迭代器
4. 文档化结构：明确组件之间的关系和约束
5. 异常处理：对不支持的操作提供清晰的错误提示

八、总结

组合模式是处理树形结构的有效方案，特别适用于：

• 表示对象的部分-整体层次结构
• 希望客户端忽略组合对象与单个对象的不同
• 需要处理递归或嵌套结构的场景

在实际开发中，组合模式常见于：

• 文件/目录系统
• GUI组件系统
• 组织结构表示
• 菜单系统
• XML/JSON文档处理

正确使用组合模式可以简化复杂结构的处理，但需要注意不要过度使用，在确实存在树形结构需求时才采用此模式。