设计模式 17 组合模式 Composite Pattern

1.定义

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。它允许你将对象组合成树形结构，以表示“部分-整体”层次关系。它将单个对象和组合对象都视为相同类型的对象，从而使你能够统一地处理它们

核心思想:

将单个对象和组合对象都视为相同类型的对象，即它们都实现相同的接口或抽象类。
组合对象可以包含其他对象，形成树形结构。
客户端代码可以统一地处理单个对象和组合对象。

2.内涵

组合模式的内涵在于它提供了一种统一处理单个对象和组合对象的方法，从而简化代码、提高可扩展性和可重用性。

核心内涵

树形结构: 组合模式的核心是构建一个树形结构，以表示“部分-整体”层次关系。树的节点可以是单个对象（叶子节点）或组合对象（非叶子节点）。
统一接口: 组合模式要求所有组件（包括单个对象和组合对象）都实现相同的接口或抽象类。这使得客户端代码可以统一地处理所有组件，而无需关心它们是单个对象还是组合对象。
递归操作: 组合模式通常使用递归来处理组合对象。当对组合对象进行操作时，它会递归地对它的子组件进行相同操作。
简化代码: 由于所有组件都具有相同的接口，客户端代码可以统一地处理它们，避免了对不同类型对象的特殊处理。
提高可扩展性: 可以轻松地添加新的组件类型，而无需修改现有代码。因为新的组件只需要实现相同的接口即可。
增强灵活性和可重用性: 可以灵活地组合不同的组件，以创建不同的结构，并可以将这些结构重用在不同的场景中

3.案例分析


#include <algorithm>
#include <iostream>
#include <list>
#include <string>


class Component {
  /**
   * @var Component
   */
 protected:
  Component *parent_;
  
 public:
  virtual ~Component() {}
  void SetParent(Component *parent) {
    this->parent_ = parent;
  }
  Component *GetParent() const {
    return this->parent_;
  }
  
  
  
  virtual void Add(Component *component) {}
  virtual void Remove(Component *component) {}
  
  virtual bool IsComposite() const {
    return false;
  }
  
  virtual std::string Operation() const = 0;
};


class Leaf : public Component {
 public:
  std::string Operation() const override {
    return "Leaf";
  }
};

class Composite : public Component {


 protected:
  std::list<Component *> children_;

 public:


  void Add(Component *component) override {
    this->children_.push_back(component);
    component->SetParent(this);
  }

  void Remove(Component *component) override {
    children_.remove(component);
    component->SetParent(nullptr);
  }
  
  bool IsComposite() const override {
    return true;
  }


  std::string Operation() const override {
    std::string result;
    for (const Component *c : children_) {
      if (c == children_.back()) {
        result += c->Operation();
      } else {
        result += c->Operation() + "+";
      }
    }
    return "Branch(" + result + ")";
  }
};

void ClientCode(Component *component) {
  // ...
  std::cout << "RESULT: " << component->Operation();
  // ...
}

void ClientCode2(Component *component1, Component *component2) {
  // ...
  if (component1->IsComposite()) {
    component1->Add(component2);
  }
  std::cout << "RESULT: " << component1->Operation();
  // ...
}


int main() {
  Component *simple = new Leaf;
  std::cout << "Client: I've got a simple component:\n";
  ClientCode(simple);
  std::cout << "\n\n";

  Component *tree = new Composite;
  Component *branch1 = new Composite;

  Component *leaf_1 = new Leaf;
  Component *leaf_2 = new Leaf;
  Component *leaf_3 = new Leaf;
  branch1->Add(leaf_1);
  branch1->Add(leaf_2);
  Component *branch2 = new Composite;
  branch2->Add(leaf_3);
  tree->Add(branch1);
  tree->Add(branch2);
  std::cout << "Client: Now I've got a composite tree:\n";
  ClientCode(tree);
  std::cout << "\n\n";

  std::cout << "Client: I don't need to check the components classes even when managing the tree:\n";
  ClientCode2(tree, simple);
  std::cout << "\n";

  delete simple;
  delete tree;
  delete branch1;
  delete branch2;
  delete leaf_1;
  delete leaf_2;
  delete leaf_3;

  return 0;
}

以上代码UML图如下所示：

4.注意事项

在使用组合模式进行开发时，需要考虑以下几个注意事项：

1. 避免循环引用:

组合模式中，组件之间可以相互嵌套，形成树形结构。如果出现循环引用，会导致无限递归，最终导致程序崩溃。
例如，文件夹 A 包含文件夹 B，文件夹 B 又包含文件夹 A，就会形成循环引用。
避免循环引用的方法是仔细设计组件之间的关系，确保没有相互依赖的循环。
2. 谨慎使用递归:

组合模式中，通常使用递归来处理组合对象。递归虽然方便，但可能会导致栈溢出，尤其是在处理大型树形结构时。
为了避免栈溢出，可以考虑使用迭代的方式来代替递归，或者使用尾递归优化。
3. 考虑性能:

组合模式中，对组合对象的访问可能会涉及多个子组件的访问，因此需要考虑性能问题。
为了提高性能，可以考虑使用缓存机制，或者使用更轻量级的结构来代替树形结构。
4. 确保接口的完整性:

组合模式中，所有组件都必须实现相同的接口。因此，需要确保接口的完整性，包含所有必要的操作方法。
接口应该尽可能地抽象，避免与具体实现细节相关联。
5. 避免过度使用:

组合模式是一种强大的模式，但它并不适合所有场景。如果你的系统结构比较简单，或者没有明显的“部分-整体”层次关系，则不需要使用组合模式。
在选择设计模式时，需要权衡利弊，选择最适合的模式

5.最佳实践

组合模式是一个强大的工具，但要有效地运用它，需要遵循一些最佳实践：

1. 明确“部分-整体”层次关系:

首先，要确保你的系统中存在明显的“部分-整体”层次关系。例如，文件系统中的文件夹和文件，组织结构中的部门和员工，图形界面中的容器和组件等。
只有在存在这种层次关系的情况下，组合模式才能发挥其优势。
2. 设计清晰的组件接口:

定义一个抽象的 Component 接口，所有组件（包括单个对象和组合对象）都必须实现这个接口。
接口应该包含所有必要的操作方法，例如 add(), remove(), getChild(), getName(), getSize() 等，这些方法应该能够适用于所有类型的组件。
3. 确保接口的完整性:

接口应该尽可能地抽象，避免与具体实现细节相关联。
同时，接口应该包含所有必要的操作方法，以支持所有可能的用例。
4. 谨慎使用递归:

递归是处理组合对象的一种常见方式，但它可能会导致栈溢出，尤其是在处理大型树形结构时。
可以考虑使用迭代的方式来代替递归，或者使用尾递归优化。
5. 考虑性能:

在处理大型树形结构时，性能是一个重要因素。
可以考虑使用缓存机制，或者使用更轻量级的结构来代替树形结构。
6. 避免过度使用:

组合模式并不适合所有场景。如果你的系统结构比较简单，或者没有明显的“部分-整体”层次关系，则不需要使用组合模式。
在选择设计模式时，需要权衡利弊，选择最适合的模式。
7. 使用示例代码进行验证:

在实际应用中，可以使用示例代码来验证组合模式的实现是否符合预期。
通过测试用例，可以确保组合模式能够正确地处理各种情况。