组合模式（Composite Pattern）详解

1. 什么是组合模式？

组合模式是一种结构型设计模式，它允许你将对象组合成树形结构来表示"部分-整体"的层次结构。组合模式使得客户端可以统一对待单个对象和组合对象，无需区分它们之间的差异。

在软件开发中，我们经常会遇到处理树形结构（如文件系统、组织结构、菜单系统等）的情况，组合模式正是为了解决这类问题而设计的。

2. 为什么需要组合模式？

在以下情况下，组合模式特别有用：

1. 当需要表示对象的部分-整体层次结构时：例如，树形结构中的节点可以包含子节点，这些子节点又可以包含其他子节点
2. 当希望客户端忽略单个对象和组合对象的差异时：客户端代码可以统一处理所有对象，而不需要编写不同的代码来处理不同类型的对象
3. 当系统需要与树形结构交互，同时保持结构的灵活性时：可以动态地添加或删除组件

3. 组合模式的核心概念

组合模式的核心是创建一个能够表示层次结构的类层次结构：

• 组件（Component）：为所有对象（包括组合对象和叶节点对象）定义共同的接口，可以是抽象类或接口
• 叶节点（Leaf）：表示层次结构中的基本对象，没有子节点
• 组合节点（Composite）：包含子节点的对象，提供管理子节点的方法

这种结构允许我们创建一个树形结构，其中每个节点都可以是单个对象（叶节点）或包含其他节点的组合对象。

4. 组合模式的结构

组合模式通常包含以下角色：

1. 抽象组件（Component）：声明组合中所有对象的共同接口，定义了对所有组件都通用的默认行为，包括访问和管理子组件的方法
2. 叶子组件（Leaf）：表示组合中的叶子节点对象，没有子节点，实现了Component接口
3. 组合组件（Composite）：表示组合中的复杂组件，包含子组件，实现了Component接口，并提供了管理子组件的方法
4. 客户端（Client）：通过Component接口操作组合部件对象

5. 组合模式的基本实现

5.1 基础示例：文件系统

考虑一个文件系统，它包含文件和目录，目录可以包含文件和其他目录。我们可以使用组合模式来表示这种结构。

首先，定义组件接口：

// 文件系统组件接口
public interface FileSystemComponent {void printName();void printDetails();long getSize();String getName();
}

然后，实现叶子节点（文件）：

// 文件类（叶节点）
public class File implements FileSystemComponent {private String name;private long size;public File(String name, long size) {this.name = name;this.size = size;}@Overridepublic void printName() {System.out.println(name);}@Overridepublic void printDetails() {System.out.println("文件: " + name + ", 大小: " + size + " KB");}@Overridepublic long getSize() {return size;}@Overridepublic String getName() {return name;}
}

接着，实现组合节点（目录）：

import java.util.ArrayList;
import java.util.List;// 目录类（组合节点）
public class Directory implements FileSystemComponent {private String name;private List<FileSystemComponent> components = new ArrayList<>();public Directory(String name) {this.name = name;}// 添加组件到目录public void addComponent(FileSystemComponent component) {components.add(component);}// 从目录移除组件public void removeComponent(FileSystemComponent component) {components.remove(component);}@Overridepublic void printName() {System.out.println(name);}@Overridepublic void printDetails() {System.out.println("目录: " + name + ", 包含 " + components.size() + " 个项目, 总大小: " + getSize() + " KB");System.out.println("目录 '" + name + "' 内容:");for (FileSystemComponent component : components) {System.out.print("  ");  // 添加缩进component.printDetails();}}@Overridepublic long getSize() {long totalSize = 0;for (FileSystemComponent component : components) {totalSize += component.getSize();}return totalSize;}@Overridepublic String getName() {return name;}
}

最后，客户端代码示例：

public class FileSystemDemo {public static void main(String[] args) {// 创建文件FileSystemComponent file1 = new File("document.txt", 100);FileSystemComponent file2 = new File("image.jpg", 2000);FileSystemComponent file3 = new File("spreadsheet.xlsx", 500);// 创建子目录Directory documentsDir = new Directory("Documents");documentsDir.addComponent(file1);documentsDir.addComponent(file3);Directory picturesDir = new Directory("Pictures");picturesDir.addComponent(file2);// 创建根目录Directory rootDir = new Directory("Root");rootDir.addComponent(documentsDir);rootDir.addComponent(picturesDir);// 打印整个文件系统rootDir.printDetails();// 打印特定目录System.out.println("\n特定目录详情:");documentsDir.printDetails();}
}

输出结果：

目录: Root, 包含 2 个项目, 总大小: 2600 KB
目录 'Root' 内容:目录: Documents, 包含 2 个项目, 总大小: 600 KB目录 'Documents' 内容:文件: document.txt, 大小: 100 KB文件: spreadsheet.xlsx, 大小: 500 KB目录: Pictures, 包含 1 个项目, 总大小: 2000 KB目录 'Pictures' 内容:文件: image.jpg, 大小: 2000 KB特定目录详情:
目录: Documents, 包含 2 个项目, 总大小: 600 KB
目录 'Documents' 内容:文件: document.txt, 大小: 100 KB文件: spreadsheet.xlsx, 大小: 500 KB

在这个例子中：

• 组件（Component）: FileSystemComponent 接口定义了文件和目录共有的方法
• 叶节点（Leaf）: File 类表示文件，没有子节点
• 组合节点（Composite）: Directory 类表示目录，可以包含文件和其他目录

客户端通过统一的接口与文件和目录交互，无需区分它们的具体类型。

5.2 透明组合模式 vs 安全组合模式

组合模式有两种常见的实现方式：

5.2.1 透明组合模式

在透明组合模式中，Component接口中声明了所有用于管理子对象的方法，如add()、remove()等。这样，叶子节点和组合节点都具有相同的接口，客户端可以一致地处理它们。

// 透明组合模式的组件接口
public interface TransparentComponent {void operation();  // 业务方法void add(TransparentComponent component);  // 添加子节点void remove(TransparentComponent component);  // 移除子节点TransparentComponent getChild(int index);  // 获取子节点
}// 透明组合模式的叶节点
public class TransparentLeaf implements TransparentComponent {private String name;public TransparentLeaf(String name) {this.name = name;}@Overridepublic void operation() {System.out.println("叶节点 " + name + " 的操作");}@Overridepublic void add(TransparentComponent component) {// 叶节点不支持添加子节点，抛出异常或忽略throw new UnsupportedOperationException("叶节点不能添加子节点");}@Overridepublic void remove(TransparentComponent component) {// 叶节点不支持移除子节点，抛出异常或忽略throw new UnsupportedOperationException("叶节点不能移除子节点");}@Overridepublic TransparentComponent getChild(int index) {// 叶节点没有子节点，抛出异常或返回nullthrow new UnsupportedOperationException("叶节点没有子节点");}
}// 透明组合模式的组合节点
public class TransparentComposite implements TransparentComponent {private String name;private List<TransparentComponent> children = new ArrayList<>();public TransparentComposite(String name) {this.name = name;}@Overridepublic void operation() {System.out.println("组合节点 " + name + " 的操作");// 调用所有子节点的操作for (TransparentComponent child : children) {child.operation();}}@Overridepublic void add(TransparentComponent component) {children.add(component);}@Overridepublic void remove(TransparentComponent component) {children.remove(component);}@Overridepublic TransparentComponent getChild(int index) {return children.get(index);}
}

优点：客户端可以统一处理组合对象和叶子对象，无需区分。

缺点：叶子节点必须实现一些对它们无意义的方法，破坏了类型安全。

5.2.2 安全组合模式

在安全组合模式中，Component接口只声明所有类共有的行为，而组合对象特有的方法（如add()、remove()等）则只在Composite类中声明。

// 安全组合模式的组件接口
public interface SafeComponent {void operation();  // 只包含共有的业务方法
}// 安全组合模式的叶节点
public class SafeLeaf implements SafeComponent {private String name;public SafeLeaf(String name) {this.name = name;}@Overridepublic void operation() {System.out.println("叶节点 " + name + " 的操作");}
}// 安全组合模式的组合节点
public class SafeComposite implements SafeComponent {private String name;private List<SafeComponent> children = new ArrayList<>();public SafeComposite(String name) {this.name = name;}@Overridepublic void operation() {System.out.println("组合节点 " + name + " 的操作");// 调用所有子节点的操作for (SafeComponent child : children) {child.operation();}}// 以下方法不在接口中声明，只在组合类中定义public void add(SafeComponent component) {children.add(component);}public void remove(SafeComponent component) {children.remove(component);}public SafeComponent getChild(int index) {return children.get(index);}
}

优点：叶子节点不需要实现无意义的方法，保持了类型安全。

缺点：客户端需要区分处理组合对象和叶子对象，因为只有组合对象才有添加和删除子节点的方法。

5.3 实例：公司组织结构

下面是一个表示公司组织结构的组合模式示例。一个公司有多个部门，每个部门有多个员工。我们可以使用组合模式来表示这种结构。

// 组织组件接口
public interface OrganizationComponent {void display();void duty();void add(OrganizationComponent component);void remove(OrganizationComponent component);OrganizationComponent getChild(int index);
}// 组织组件抽象类，提供一些默认实现
public abstract class Organization implements OrganizationComponent {private String name;public Organization(String name) {this.name = name;}public String getName() {return name;}// 默认实现，子类可以根据需要覆盖@Overridepublic void add(OrganizationComponent component) {throw new UnsupportedOperationException();}@Overridepublic void remove(OrganizationComponent component) {throw new UnsupportedOperationException();}@Overridepublic OrganizationComponent getChild(int index) {throw new UnsupportedOperationException();}
}// 员工类（叶节点）
public class Employee extends Organization {private String position;public Employee(String name, String position) {super(name);this.position = position;}@Overridepublic void display() {System.out.println("员工：" + getName() + "，职位：" + position);}@Overridepublic void duty() {System.out.println("员工 " + getName() + " 的职责是完成分配的工作");}
}// 部门类（组合节点）
public class Department extends Organization {private List<OrganizationComponent> subordinates = new ArrayList<>();public Department(String name) {super(name);}@Overridepublic void add(OrganizationComponent component) {subordinates.add(component);}@Overridepublic void remove(OrganizationComponent component) {subordinates.remove(component);}@Overridepublic OrganizationComponent getChild(int index) {return subordinates.get(index);}@Overridepublic