【设计模式 - 结构型模式】3. 组合模式

时间：2021-02-15 11:50:21 阅读：0 评论：0 收藏：0 [点我收藏+]

标签：产品 pop dma 没有 oid pat 复合 remove blank

一、定义与特点

组合（Composite Pattern）模式的定义：有时又叫作整体-部分模式，是用于把一组相似的对象当作一个单一的对象。组合模式是用于整体与部分的结构，当整体与部分有相似的结构，在操作时可以被一致对待时，就可以使用组合模式。例如：

文件夹和子文件夹的关系：文件夹中可以存放文件，也可以新建文件夹，子文件夹也一样。
总公司子公司的关系：总公司可以设立部门，也可以设立分公司，子公司也一
树枝和分树枝的关系：树枝可以长出叶子，也可以长出树枝，分树枝也一样。

在这些关系中，虽然整体包含了部分，但无论整体或部分，都具有一致的行为。对这些简单对象与复合对象的处理，如果用组合模式来实现会很方便。

组合模式的主要优点有：

组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；
更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”。

其主要缺点是：

设计较复杂，客户端需要花更多时间理清类之间的层次关系；
不容易限制容器中的构件；
不容易用继承的方法来增加构件的新功能；

二、结构

组合模式包含以下主要角色：

抽象构件（Component）角色：它的主要作用是为树叶构件和树枝构件声明公共接口，并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口；在安全式的组合模式中不声明访问和管理子类的接口，管理工作由树枝构件完成。（总的抽象类或接口，定义一些通用的方法，比如新增、删除）
树叶构件（Leaf）角色：是组合中的叶节点对象，它没有子节点，用于继承或实现抽象构件。
树枝构件（Composite）角色 / 中间构件：是组合中的分支节点对象，它有子节点，用于继承和实现抽象构件。它的主要作用是存储和管理子部件，通常包含 Add()、Remove()、GetChild() 等方法。

三、具体实现

考虑这样一个实际应用：设计一个公司的人员分布结构，结构如下图所示。

技术图片

我们注意到人员结构中有两种结构，一是管理者，如老板，PM，CFO，CTO，二是职员。其中有的管理者不仅仅要管理职员，还会管理其他的管理者。这就是一个典型的整体与部分的结构。

3.1 不使用组合模式的设计方案

要描述这样的结构，我们很容易想到以下设计方案：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// 职员类
class Employee {
public:
    // 自定义构造函数
    Employee(string position, string job) {
        this->position = position;
        this->job = job;
    }

    // 做自已的本职工作
    void work() {
        cout << "我是" << position << "，我正在" << job << endl;
    }

private:
    // 职位
    string position;
    // 工作内容
    string job;
};

// 管理者类
class Manager {
public:
    // 自定义构造函数
    Manager(string position, string job) {
        this->position = position;
        this->job = job;
    }

    void addManager(Manager *manager) {
        managers.push_back(manager);
    }

    void removeManager() {
        managers.pop_back();
    }

    void addEmployee(Employee *employee) {
        employees.push_back(employee);
    }

    void removeEmployee() {
        employees.pop_back();
    }

    // 做自已的本职工作
    void work() {
        cout << "我是" << position << "，我正在" << job << endl;
    }

    // 检查下属
    void check() {
        work();

        // 遍历employees职员列表
        vector<Employee*>::iterator it = employees.begin();
        for(; it!=employees.end(); ++it) {
            (*it)->work();
        }
        // 遍历managers管理者列表
        vector<Manager*>::iterator it2 = managers.begin();
        for(; it2!=managers.end(); ++it2) {
            (*it2)->check();
        }
    }

private:
    // 职位
    string position;
    // 工作内容
    string job;
    // 管理的管理者
    //list<Manager> *managers = new list<Manager>;
    vector<Manager*> managers;
    // 管理的职员
    //list<Employee> *employees = new list<Employee>;
    vector<Employee*> employees;
};

int main()
{
    Manager *boss = new Manager("老板", "唱怒放的生命");
    Employee *HR = new Employee("人力资源", "聊微信");
    Manager *PM = new Manager("产品经理", "不知道干啥");
    Manager *CFO = new Manager("财务主管", "看剧");
    Manager *CTO = new Manager("技术主管", "划水");
    Employee *UI = new Employee("设计师", "画画");
    Employee *operato = new Employee("运营人员", "兼职客服");
    Employee *webProgrammer = new Employee("程序员", "学习设计模式");
    Employee *backgroundProgrammer = new Employee("后台程序员", "CRUD");
    Employee *accountant = new Employee("会计", "背九九乘法表");
    Employee *clerk = new Employee("文员", "给老板递麦克风");
    boss->addEmployee(HR);
    boss->addManager(PM);
    boss->addManager(CFO);
    PM->addEmployee(UI);
    PM->addManager(CTO);
    PM->addEmployee(operato);
    CTO->addEmployee(webProgrammer);
    CTO->addEmployee(backgroundProgrammer);
    CFO->addEmployee(accountant);
    CFO->addEmployee(clerk);

    boss->check();

    return 0;
}

运行测试方法，输出如下（为方便查看，笔者添加了缩进）：

我是老板，我正在唱怒放的生命
	我是人力资源，我正在聊微信
	我是产品经理，我正在不知道干啥
		我是设计师，我正在画
		我是运营人员，我正在兼职客服
		我是技术主管，我正在划水
			我是程序员，我正在学习设计模式
			我是后台程序员，我正在CRUD
	我是财务主管，我正在看剧
		我是会计，我正在背九九乘法表
		我是文员，我正在给老板递麦克风

这样我们就设计出了公司的结构，但是这样的设计有两个弊端：

name 字段，job 字段，work 方法重复了。
管理者对其管理的管理者和职员需要区别对待。

关于第一个弊端，虽然这里为了讲解，只有两个字段和一个方法重复，实际工作中这样的整体部分结构会有相当多的重复。比如此例中还可能有工号、年龄等字段，领取工资、上下班打卡、开各种无聊的会等方法。

大量的重复显然是很丑陋的代码，分析一下可以发现， Manager 类只比 Employee 类多—个管理人员的列表字段，多几个增加/移除人员的方法，其他的字段和方法全都是一样的。

有读者应该会想到：我们可以将重复的字段和方法提取到个工具类中，让 Employee 和 Manager 都去调用此工具类，就可以消除重复了这样固然可行，但属于 Employee 和 Manager 类自己的东西却要通过其他类调用，并不利于程序的高内聚。

关于第二个弊端，此方案无法解决，此方案中 Employee 和 Manager 类完全是两个不同的对象，两者的相似性被忽略了所以我们有更好的设计方案，那就是组合模式！

3.2 使用组合模式的设计方案

组合模式最主要的功能就是让用户可以一致对待整体和部分结构，将两者都作为一个相同的组件，所以我们先新建一个抽象的组件类：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// 抽象的组件类
class Component{
public:
    Component() {}
    virtual ~Component() {}
    Component(string position, string job) {}

    // 做自已的本明工作
    void work() {
        cout << "我是" << position << "，我正在" << job << endl;
    }

    // 注意要加上函数体{}，否则报错
    virtual void addComponent(Component *component) {}
    virtual void removeComponent() {}
    virtual void check() {}

public:
    // 职位
    string position;
    // 工作内容
    string job;
};

// 职员类
class Employee: public Component {
public:
    // 自定义构造函数
    Employee(string position, string job) {
        this->position = position;
        this->job = job;
    }

    void addComponent(Component *component) {
        cout << "职员没有管理权限" << endl;
    }

    void removeComponent() {
        cout << "职员没有管理权限" << endl;
    }

    // 检查下属
    void check() {
        work();
    }
};

// 管理者类
class Manager: public Component {
public:
    Manager() {}
    ~Manager() {}

    // 自定义构造函数
    Manager(string position, string job) {
        this->position = position;
        this->job = job;
    }

    void addComponent(Component *component) {
        components.push_back(component);
    }

    void removeComponent() {
        components.pop_back();
    }

    // 检查下属
    void check() {
        work();

        // 遍历
        vector<Component*>::iterator it = components.begin();
        for (; it != components.end(); it++){
            (*it)->check();
        }
    }

private:
    // 管理的组件
    vector<Component*> components;
};

int main()
{
    Component *boss = new Manager("老板", "唱怒放的生命");
    Component *HR = new Employee("人力资源", "聊微信");
    Component *PM = new Manager("产品经理", "不知道干啥");
    Component *CFO = new Manager("财务主管", "看剧");
    Component *CTO = new Manager("技术主管", "划水");
    Component *UI = new Employee("设计师", "画画");
    Component *operato = new Employee("运营人员", "兼职客服");
    Component *webProgrammer = new Employee("程序员", "学习设计模式");
    Component *backgroundProgrammer = new Employee("后台程序员", "CRUD");
    Component *accountant = new Employee("会计", "背九九乘法表");
    Component *clerk = new Employee("文员", "给老板递麦克风");
    boss->addComponent(HR);
    boss->addComponent(PM);
    boss->addComponent(CFO);
    PM->addComponent(UI);
    PM->addComponent(CTO);
    PM->addComponent(operato);
    CTO->addComponent(webProgrammer);
    CTO->addComponent(backgroundProgrammer);
    CFO->addComponent(accountant);
    CFO->addComponent(clerk);

    boss->check();

    return 0;
}

运行测试方法，输出结果与之前的结果一模一样。

可以看到，使用组合模式后，我们解决了之前的两个弊端。一是将共有的字段与方法移到了父类中，消除了重复，并且在客户端中，可以一致对待 Manager 和 Employee 类：

Manager 类和 Employee 类统一声明为 Component 对象。
统调用 Component 对象的 addComponent 方法添加子对象即可。

3.3 组合模式中的安全方式与透明方式

读者可能已经注意到了， Employee 类虽然继承了父类的 addComponent 和 remove Component 方法，但是仅仅提供了一个空实现，因为 Employee 类是不支持添加和移除组件的。这样是否违背了接口隔离原则呢？

接口隔离原则：客户端不应依赖它不需要的接口。如果一个接口在实现时，部分方法由于冗余被客户端空实现，则应该将接口拆分，让实现类只需依赖自己需要的接口方法。

答案是肯定的，这样确实违背了接口隔离原则。这种方式在组合模式中被称作透明方式。

透明方式：在 Component 中声明所有管理子对象的方法，包括 add、 remove 等，这样继承自 Component 的子类都具备了 ad、 remove 方法。对于外界来说叶节点和枝节点是透明的，它们具备完全一致的接口。

这种方式有它的优点：让 Manager 类和 Employee 类具备完全一致的行为接口，调用者可以—致对待它们。

但它的缺点也显而易见：Employee 类并不支持管理子对象，不仅违背了接口隔离原则，而且客户端可以用 Employee 类调用 addComponent 和 remove Component 方法，导致程序出错，所以这种方式是不安全的。

那么我们可不可以将 addComponent 和 remove Component 方法移到 Manager 子类中去单独实现，让 Employee 不再实现这两个方法呢？我们来尝试一下。修改为：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

// 抽象的组件类
class Component{
public:
    Component() {}
    virtual ~Component() {}
    Component(string position, string job) {}

    // 做自已的本明工作
    void work() {
        cout << "im" << position << ",doing" << job << endl;
    }

    // 注意要加上函数体{}，否则报错
    virtual void check() {}

public:
    // 职位
    string position;
    // 工作内容
    string job;
};

// 职员类
class Employee: public Component {
public:
    // 自定义构造函数
    Employee(string position, string job) {
        this->position = position;
        this->job = job;
    }

    // 检查下属
    void check() {
        work();
    }
};

// 管理者类
class Manager: public Component {
public:
    Manager() {}
    ~Manager() {}

    // 自定义构造函数
    Manager(string position, string job) {
        this->position = position;
        this->job = job;
    }

    void addComponent(Component *component) {
        components.push_back(component);
    }

    void removeComponent() {
        components.pop_back();
    }

    // 检查下属
    void check() {
        work();

        // 遍历
        vector<Component*>::iterator it = components.begin();
        for (; it != components.end(); it++){
            (*it)->check();
        }
    }

private:
    // 管理的组件
    vector<Component*> components;
};

int main()
{
    Manager *boss = new Manager("老板", "唱怒放的生命");
    Employee *HR = new Employee("人力资源", "聊微信");
    Manager *PM = new Manager("产品经理", "不知道干啥");
    Manager *CFO = new Manager("财务主管", "看剧");
    Manager *CTO = new Manager("技术主管", "划水");
    Employee *UI = new Employee("设计师", "画画");
    Employee *operato = new Employee("运营人员", "兼职客服");
    Employee *webProgrammer = new Employee("程序员", "学习设计模式");
    Employee *backgroundProgrammer = new Employee("后台程序员", "CRUD");
    Employee *accountant = new Employee("会计", "背九九乘法表");
    Employee *clerk = new Employee("文员", "给老板递麦克风");
    boss->addComponent(HR);
    boss->addComponent(PM);
    boss->addComponent(CFO);
    PM->addComponent(UI);
    PM->addComponent(CTO);
    PM->addComponent(operato);
    CTO->addComponent(webProgrammer);
    CTO->addComponent(backgroundProgrammer);
    CFO->addComponent(accountant);
    CFO->addComponent(clerk);

    boss->check();

    return 0;
}

运行程序，输出结果与之前一模一样。

可以看到，我们在父类中去掉了 addComponent 和 removeComponent 这两个抽象方法，Manager 类单独实现了 addComponent 和 remove Component 这两个方法。这种方式在组合模式中称之为安全方式。