架构设计模式组合模式

树形结构在软件中随处可见，例如操作系统中的目录结构、应用软件中的菜单、办公系统中的公司组织结构等等，如何运用面向对象的方式来处理这种树形结构是组合模式需要解决的问题。

组合模式为处理树形结构提供了一种较为完美的解决方案，它描述了如何将容器和叶子进行递归组合，使得用户在使用时无须对它们进行区分，可以一致地对待容器和叶子。

对于树形结构，当容器对象（如文件夹）的某一个方法被调用时，将遍历整个树形结构，寻找也包含这个方法的成员对象（可以是容器对象，也可以是叶子对象）并调用执行，牵一而动百，其中使用了递归调用的机制来对整个结构进行处理。由于容器对象和叶子对象在功能上的区别，在使用这些对象的代码中必须有区别地对待容器对象和叶子对象，而实际上大多数情况下我们希望一致地处理它们，因为对于这些对象的区别对待将会使得程序非常复杂。组合模式为解决此类问题而诞生，它可以让叶子对象和容器对象的使用具有一致性。

组合模式定义如下：

组合模式 (Composite Pattern)：组合多个对象形成树形结构以表示具有“整体—部分”关系的层次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致性，组合模式又可以称为“整体—部分”(Part-Whole) 模式，它是一种对象结构型模式。

在组合模式中引入了抽象构件类 Component，它是所有容器类和叶子类的公共父类，客户端针对 Component 进行编程。组合模式结构如图所示：

在组合模式结构图中包含如下几个角色：

Component（抽象构件）：它可以是接口或抽象类，为叶子构件和容器构件对象声明接口，在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的子构件的方法，如增加子构件、删除子构件、获取子构件等。
Leaf（叶子构件）：它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。
Composite（容器构件）：它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

如果不使用组合模式，客户端代码将过多地依赖于容器对象复杂的内部实现结构，容器对象内部实现结构的变化将引起客户代码的频繁变化，带来了代码维护复杂、可扩展性差等弊端。组合模式的引入将在一定程度上解决这些问题。

下面通过简单的示例代码来分析组合模式的各个角色的用途和实现。对于组合模式中的抽象构件角色，其典型代码如下所示：

abstract class Component {public abstract function add(Component $c); // 增加成员
    public abstract function remove(Component $c); // 删除成员
    public abstract function getChild(int $i): Component; // 获取成员
    public abstract function operation();  // 业务方法}

一般将抽象构件类设计为接口或抽象类，将所有子类共有方法的声明和实现放在抽象构件类中。对于客户端而言，将针对抽象构件编程，而无须关心其具体子类是容器构件还是叶子构件。

如果继承抽象构件的是叶子构件，则其典型代码如下所示：

class Leaf extends Component
{public function add(Component $c)
    {// 异常处理或错误提示}

    public function remove(Component $c)
    {// 异常处理或错误提示}

    public function getChild(int $i): Component
    {// 异常处理或错误提示}

    public function operation()
    {// 叶子构件具体业务方法的实现}
}

作为抽象构件类的子类，在叶子构件中需要实现在抽象构件类中声明的所有方法，包括业务方法以及管理和访问子构件的方法，但是叶子构件不能再包含子构件，因此 在叶子构件中实现子构件管理和访问方法时需要提供异常处理或错误提示。当然，这无疑会给叶子构件的实现带来麻烦。

如果继承抽象构件的是容器构件，则其典型代码如下所示：

class Composite extends Component
{private $list = [];

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

    public function remove(Component $c)
    {unset($this->list[array_search($c, $this->list)]);
    }

    public function getChild(int $i): Component
    {return $this->list[$i];
    }

    public function operation()
    {
        // 容器构件具体业务方法的实现
        // 递归调用成员构件的业务方法
        foreach ($this->list as $item) {$item->operation();
        }
    }
}

在容器构件中实现了在抽象构件中声明的所有方法，需要注意的是在实现具体业务方法时，由于容器构件充当的是容器角色，包含成员构件，因此它将调用其成员构件的业务方法。在组合模式结构中，由于容器构件中仍然可以包含容器构件，因此在对容器构件进行处理时需要使用递归算法，即在容器构件的 operation()方法中递归调用其成员构件的 operation()方法。

Sunny 软件公司欲开发一个杀毒 (AntiVirus) 软件，该软件既可以对某个文件夹 (Folder) 杀毒，也可以对某个指定的文件 (File) 进行杀毒。该杀毒软件还可以根据各类文件的特点，为不同类型的文件提供不同的杀毒方式，例如图像文件 (ImageFile) 和文本文件 (TextFile) 的杀毒方式就有所差异。现需要提供该杀毒软件的整体框架设计方案。

为了让系统具有更好的灵活性和可扩展性，客户端可以一致地对待文件和文件夹，Sunny 公司开发人员使用组合模式来进行杀毒软件的框架设计，其基本结构如图所示：

AbstractFile 充当抽象构件类，Folder 充当容器构件类，ImageFile、TextFile 和 VideoFile 充当叶子构件类。完整代码如下所示：

<?php

// 抽象文件类：抽象构件
abstract class AbstractFile
{public abstract function add(AbstractFile $file);

    public abstract function remove(AbstractFile $file);

    public abstract function getChild(int $i): AbstractFile;

    public abstract function killVirus();}

// 图像文件类：叶子构件
class ImageFile extends AbstractFile
{
    private $name;

    public function __construct(string $name)
    {$this->name = $name;}

    public function add(AbstractFile $file)
    {throw new Exception('No supported method');
    }

    public function remove(AbstractFile $file)
    {throw new Exception('No supported method');
    }

    public function getChild(int $i): AbstractFile
    {throw new Exception('No supported method');
    }

    public function killVirus()
    {
        // 模拟杀毒
        echo '---- 对图像文件' . $this->name . '进行杀毒';
    }
}

// 文本文件类：叶子构件
class TextFile extends AbstractFile
{
    private $name;

    public function __construct(string $name)
    {$this->name = $name;}

    public function add(AbstractFile $file)
    {throw new Exception('No supported method');
    }

    public function remove(AbstractFile $file)
    {throw new Exception('No supported method');
    }

    public function getChild(int $i): AbstractFile
    {throw new Exception('No supported method');
    }

    public function killVirus()
    {
        // 模拟杀毒
        echo '---- 对文本文件' . $this->name . '进行杀毒';
    }
}

// 视频文件类：叶子构件
class VideoFile extends AbstractFile
{
    private $name;

    public function __construct(string $name)
    {$this->name = $name;}

    public function add(AbstractFile $file)
    {throw new Exception('No supported method');
    }

    public function remove(AbstractFile $file)
    {throw new Exception('No supported method');
    }

    public function getChild(int $i): AbstractFile
    {throw new Exception('No supported method');
    }

    public function killVirus()
    {
        // 模拟杀毒
        echo '---- 对图视频文件' . $this->name . '进行杀毒';
    }
}

// 文件夹类：容器构件
class Folder extends AbstractFile
{
    // 定义 fileList，用于存储 AbstractFile 类型的成员
    private $fileList = [];
    private $name;

    public function __construct(string $name)
    {$this->name = $name;}

    public function add(AbstractFile $file)
    {$this->fileList[] = $file;
    }

    public function remove(AbstractFile $file)
    {unset($this->fileList[array_search($file, $this->fileList)]);
    }

    public function getChild(int $i): AbstractFile
    {return $this->fileList[$i];
    }

    public function killVirus()
    {
        // 模拟杀毒
        echo '**** 对文件夹文件' . $this->name . '进行杀毒';

        // 递归调用成员构件的 killVirus()方法
        foreach ($this->fileList as $item) {$item->killVirus();
        }
    }
}

由于在抽象构件类中声明了所有方法，包括用于管理和访问子构件的方法，如 add()方法和 remove()方法等，因此在 ImageFile 等叶子构件类中实现这些方法时必须进行相应的异常处理或错误提示。在容器构件类 Folder 的 killVirus()方法中将递归调用其成员对象的 killVirus()方法，从而实现对整个树形结构的遍历。

如果需要更换操作节点，客户端代码只需修改想要进行杀毒的节点名即可。在具体实现时，我们可以创建图形化界面让用户选择所需操作的根节点，无须修改源代码，符合“开闭原则”，客户端无须关心节点的层次结构，可以对所选节点进行统一处理，提高系统的灵活性。

通过引入组合模式，Sunny 公司设计的杀毒软件具有良好的可扩展性，在增加新的文件类型时，无须修改现有类库代码，只需增加一个新的文件类作为 AbstractFile 类的子类即可，但是由于在 AbstractFile 中声明了大量用于管理和访问成员构件的方法，例如 add()、remove()等方法，我们不得不在新增的文件类中实现这些方法，提供对应的错误提示和异常处理。为了简化代码，我们有以下两个解决方案：

透明组合模式

将叶子构件的 add()、remove()等方法的实现代码移至 AbstractFile 类中，由 AbstractFile 提供统一的默认实现。如果客户端代码针对抽象类 AbstractFile 编程，在调用文件对象的这些方法时将出现错误提示。如果不希望出现任何错误提示，我们可以在客户端定义文件对象时不使用抽象层，而直接使用具体叶子构件本身。

透明组合模式中，抽象构件 Component 中声明了所有用于管理成员对象的方法，包括 add()、remove()以及 getChild()等方法，这样做的好处是确保所有的构件类都有相同的接口。在客户端看来，叶子对象与容器对象所提供的方法是一致的，客户端可以相同地对待所有的对象。透明组合模式也是组合模式的标准形式，虽然客户端可以有不透明的实现方法，但是由于在抽象构件中包含 add()、remove()等方法，因此它还是透明组合模式。

透明组合模式的缺点是不够安全，因为叶子对象和容器对象在本质上是有区别的。叶子对象不可能有下一个层次的对象，即不可能包含成员对象，因此为其提供 add()、remove()以及 getChild()等方法是没有意义的，在运行阶段如果调用这些方法可能会出错（如果没有提供相应的错误处理代码）。

安全组合模式

在抽象构件 AbstractFile 中不声明任何用于访问和管理成员构件的方法。此时，由于在 AbstractFile 中没有声明 add()、remove()等访问和管理成员的方法，其叶子构件子类无须提供实现。而且无论客户端如何定义叶子构件对象都无法调用到这些方法，不需要做任何错误和异常处理，容器构件再根据需要增加访问和管理成员的方法。

但这时候也存在一个问题：客户端不得不使用容器类本身来声明容器构件对象，否则无法访问其中新增的 add()、remove()等方法，如果客户端一致性地对待叶子和容器，将会导致容器构件的新增对客户端不可见，客户端代码对于容器构件无法再使用抽象构件来定义。

安全组合模式的缺点是不够透明，因为叶子构件和容器构件具有不同的方法，且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义，因此客户端不能完全针对抽象编程，必须有区别地对待叶子构件和容器构件。在实际应用中，安全组合模式的使用频率也非常高。

组合模式使用面向对象的思想来实现树形结构的构建与处理，描述了如何将容器对象和叶子对象进行递归组合，实现简单，灵活性好。由于在软件开发中存在大量的树形结构，因此组合模式是一种使用频率较高的结构型设计模式。

主要优点

组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽略了层次的差异，方便对整个层次结构进行控制。
客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端代码。
在组合模式中增加新的容器构件和叶子构件都很方便，无须对现有类库进行任何修改，符合“开闭原则”。
组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和容器对象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。

主要缺点

在增加新构件时很难对容器中的构件类型进行限制。有时候我们希望一个容器中只能有某些特定类型的对象，例如在某个文件夹中只能包含文本文件，使用组合模式时，不能依赖类型系统来施加这些约束，因为它们都来自于相同的抽象层，在这种情况下，必须通过在运行时进行类型检查来实现，这个实现过程较为复杂。

适用场景

在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以一致地对待它们。
在一个使用面向对象语言开发的系统中需要处理一个树形结构。
在一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新的类型。

架构设计模式组合模式

概述

案例

透明组合模式与安全组合模式

透明组合模式

安全组合模式

总结

主要优点

主要缺点

适用场景

Just My Socks（注册教程内含优惠码）

架构设计模式组合模式

概述

案例

透明组合模式与安全组合模式

透明组合模式

安全组合模式

总结

主要优点

主要缺点

适用场景

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）