组合模式

引言

在软件开发中，常需处理具有树形层次结构的对象（如文件系统、UI组件）。传统方法需分别处理叶节点（单个对象）和容器节点（对象集合），导致代码冗余和逻辑分裂。组合模式通过统一叶节点和容器的接口，实现“部分-整体”结构的一致性操作，简化了复杂层次结构的处理。

诞生背景

组合模式由GoF（Gang of Four）在《设计模式：可复用面向对象软件的基础》中提出，旨在解决以下问题：

• 树形结构复杂性：处理嵌套对象时需递归遍历，代码重复且易出错。
• 接口不统一：客户端需区分叶节点和容器节点，违反开闭原则。
• 扩展性差：新增节点类型需修改客户端逻辑。

演进过程

• GoF定义（1994）：确立核心角色（组件、叶节点、容器）。
• 框架集成：Java AWT/Swing的Component-Container结构、前端框架（如React的虚拟DOM）广泛应用。
• 现代扩展：支持异步操作（如并发遍历）、动态组合（运行时增减节点）。

核心概念

组合模式通过统一接口处理层次结构：

1. 组件（Component）
   • 定义所有节点的通用接口（如operation()）。
2. 叶节点（Leaf）
   • 无子节点的原子对象，实现组件接口。
3. 容器（Composite）
   • 包含子节点的集合，管理子组件并实现组件接口。

通用实现

Java 实现

// 组件接口
interface Component {
    void operation();
}

// 叶节点
class Leaf implements Component {
    @Override
    public void operation() {
        System.out.println("Leaf operation");
    }
}

// 容器
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    public void add(Component c) {
        children.add(c);
    }

    @Override
    public void operation() {
        System.out.println("Composite operation");
        for (Component child : children) {
            child.operation(); // 递归调用子节点
        }
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Component leaf = new Leaf();
        Composite composite = new Composite();
        composite.add(leaf);
        composite.operation(); // 统一调用
    }
}

PHP 实现

// 组件接口
interface Component {
    public function operation();
}

// 叶节点
class Leaf implements Component {
    public function operation() {
        echo "Leaf operation\n";
    }
}

// 容器
class Composite implements Component {
    private $children = [];

    public function add(Component $c) {
        $this->children[] = $c;
    }

    public function operation() {
        echo "Composite operation\n";
        foreach ($this->children as $child) {
            $child->operation(); // 递归调用
        }
    }
}

// 客户端
$leaf = new Leaf();
$composite = new Composite();
$composite->add($leaf);
$composite->operation();

应用场景

1. UI组件库：按钮（叶节点）与面板（容器）统一渲染。
2. 文件系统：文件（叶节点）与文件夹（容器）递归遍历。
3. 组织架构：员工（叶节点）与部门（容器）统计薪资。
4. 菜单系统：菜单项（叶节点）与子菜单（容器）嵌套展示。

案例：文件系统扫描

Java 实现

// 组件
interface FileSystemComponent {
    void display();
}

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

// 文件夹（容器）
class Folder implements FileSystemComponent {
    private String name;
    private List<FileSystemComponent> children = new ArrayList<>();
    
    public Folder(String name) { this.name = name; }
    public void add(FileSystemComponent comp) {
        children.add(comp);
    }
    
    @Override
    public void display() {
        System.out.println("Folder: " + name);
        for (FileSystemComponent child : children) {
            child.display(); // 递归扫描
        }
    }
}

// 客户端
Folder root = new Folder("Root");
root.add(new File("File1.txt"));
Folder subFolder = new Folder("SubFolder");
subFolder.add(new File("File2.txt"));
root.add(subFolder);
root.display();

PHP 实现

// 组件接口
interface FileSystemComponent {
    public function display();
}

// 文件（叶节点）
class File implements FileSystemComponent {
    private $name;
    public function __construct($name) { $this->name = $name; }
    public function display() {
        echo "File: {$this->name}\n";
    }
}

// 文件夹（容器）
class Folder implements FileSystemComponent {
    private $name;
    private $children = [];
    
    public function __construct($name) { $this->name = $name; }
    public function add(FileSystemComponent $comp) {
        $this->children[] = $comp;
    }
    
    public function display() {
        echo "Folder: {$this->name}\n";
        foreach ($this->children as $child) {
            $child->display(); // 递归扫描
        }
    }
}

// 客户端
$root = new Folder("Root");
$root->add(new File("File1.txt"));
$subFolder = new Folder("SubFolder");
$subFolder->add(new File("File2.txt"));
$root->add($subFolder);
$root->display();

优点

1. 简化客户端：统一处理叶节点和容器，无需条件判断。
2. 开闭原则：新增节点类型不影响现有代码。
3. 层次结构灵活性：动态增减节点（如文件夹嵌套）。

缺点

1. 接口过度泛化：叶节点被迫实现无意义方法（如add()）。
2. 类型安全弱化：客户端可能误调容器方法（需运行时检查）。
3. 性能开销：递归遍历可能影响效率（如深层次树）。

扩展

1. 安全模式：分离叶节点和容器的接口（叶节点无add()）。
2. 缓存优化：容器缓存遍历结果，避免重复计算。
3. 异步操作：并行处理子节点（如并发扫描文件）。

模式协作

• 与迭代器模式：组合模式常搭配迭代器递归遍历树形结构。
• 与访问者模式：对组合结构执行统一操作（如统计文件大小）。
• 与装饰器模式：动态扩展节点功能（如加密文件节点）。

延伸思考

1. 函数式替代方案：
   • 通过递归函数处理树形结构（如JavaScript的Array.prototype.flat()）。
2. 不可变数据结构：
   • 在函数式编程中，使用持久化数据结构避免副作用。
3. 现代框架应用：
   • React/Vue的虚拟DOM本质是组合模式（组件嵌套）。

总结

组合模式通过统一接口处理树形结构中的叶节点与容器节点，完美契合“部分-整体”场景。尽管存在接口泛化问题，但其简化层次操作、增强扩展性的优势，使其成为处理嵌套结构的核心模式。在文件系统、UI框架等场景中，组合模式能显著提升代码的简洁性与可维护性。