一、中介者模式的核心思想

中介者模式属于行为型设计模式，其主要目标是通过引入一个中间对象——即“中介者”，来管理多个对象之间的交互。原本彼此直接通信的多个对象不再相互依赖，而是将所有交互逻辑交由中介者统一处理，从而将复杂的网状结构转变为清晰的星型结构。这种结构显著降低了对象间的耦合性，增强了系统的可维护性和可扩展性。

以家具制造流程为例：若没有统一调度机制，木材供应方需直接对接切割车间确认材料规格，切割完成后又要通知组装环节，组装完毕再联系油漆部门……各环节之间频繁交叉沟通，极易造成信息延迟或错漏。而一旦设立生产调度员作为中介者，所有单位只需与其单线联系，由调度员统一分配指令与协调进度，实现高效有序运作。

#include <iostream>
#include <string>
#include <memory>
// 前向声明：抽象同事类，供中介者接口使用
class Colleague;

// 抽象中介者：生产调度接口
class FurnitureMediator {
public:
    virtual ~FurnitureMediator() = default;
    // 注册同事（生产环节）
    virtual void registerColleague(std::shared_ptr<Colleague> colleague) = 0;
    // 接收同事反馈的状态信息
    virtual void receiveStatus(const std::string& department, const std::string& status) = 0;
    // 向同事下发指令
    virtual void sendInstruction(const std::string& department, const std::string& instruction) = 0;
};

// 抽象同事类：生产环节
class Colleague {
protected:
    std::shared_ptr<FurnitureMediator> mediator; // 持有中介者引用
    std::string departmentName; // 部门名称（如"木材供应商"）

public:
    Colleague(std::shared_ptr<FurnitureMediator> med, std::string name) 
        : mediator(med), departmentName(name) {}
    virtual ~Colleague() = default;

    // 反馈状态给中介者
    virtual void feedbackStatus(const std::string& status) {
        std::cout << "[" << departmentName << "] 反馈状态：" << status << std::endl;
        mediator->receiveStatus(departmentName, status);
    }

    // 接收并执行中介者指令
    virtual void executeInstruction(const std::string& instruction) = 0;

    // 获取部门名称
    std::string getName() const { return departmentName; }
};

// 具体同事类1：木材供应商（负责原料供应）
class WoodSupplier : public Colleague {
public:
    WoodSupplier(std::shared_ptr<FurnitureMediator> med) 
        : Colleague(med, "木材供应商") {}

    // 执行中介者指令（如"供应红橡木10立方米"）
    void executeInstruction(const std::string& instruction) override {
        std::cout << "[" << departmentName << "] 执行指令：" << instruction << std::endl;
        // 模拟原料供应完成
        if (instruction.find("供应") != std::string::npos) {
            feedbackStatus("原料已送达仓库，数量规格符合要求");
        }
    }
};

// 具体同事类2：切割车间（负责木材切割加工）
class CuttingWorkshop : public Colleague {
public:
    CuttingWorkshop(std::shared_ptr<FurnitureMediator> med) 
        : Colleague(med, "切割车间") {}

    void executeInstruction(const std::string& instruction) override {
        std::cout << "[" << departmentName << "] 执行指令：" << instruction << std::endl;
        // 模拟切割加工完成
        if (instruction.find("切割") != std::string::npos) {
            feedbackStatus("板材切割完成，尺寸误差≤0.5mm，已转运至组装车间");
        }
    }
};

// 具体同事类3：组装车间（负责部件组装）
class AssemblyWorkshop : public Colleague {
public:
    AssemblyWorkshop(std::shared_ptr<FurnitureMediator> med) 
        : Colleague(med, "组装车间") {}

    void executeInstruction(const std::string& instruction) override {
        std::cout << "[" << departmentName << "] 执行指令：" << instruction << std::endl;
        // 模拟组装完成
        if (instruction.find("组装") != std::string::npos) {
            feedbackStatus("家具框架组装完成，榫卯连接牢固，待涂装");
        }
    }
};

// 具体同事类4：质检部门（负责质量检验）
class QualityInspection : public Colleague {
public:
    QualityInspection(std::shared_ptr<FurnitureMediator> med) 
        : Colleague(med, "质检部门") {}

    void executeInstruction(const std::string& instruction) override {
        std::cout << "[" << departmentName << "] 执行指令：" << instruction << std::endl;
        // 模拟质检完成
        if (instruction.find("检验") != std::string::npos) {
            feedbackStatus("质检合格，外观无瑕疵，结构符合标准，可入库");
        }
    }
};

// 具体中介者：生产调度中心
class ProductionDispatcher : public FurnitureMediator {
private:
    // 维护各生产环节的引用（实际项目中可用容器管理更多同事）
    std::shared_ptr<WoodSupplier> woodSupplier;
    std::shared_ptr<CuttingWorkshop> cuttingWorkshop;
    std::shared_ptr<AssemblyWorkshop> assemblyWorkshop;
    std::shared_ptr<QualityInspection> qualityInspection;

public:
    // 注册同事对象，建立调度关系
    void registerColleague(std::shared_ptr<Colleague> colleague) override {
        if (auto supplier = std::dynamic_pointer_cast<WoodSupplier>(colleague)) {
            woodSupplier = supplier;
        } else if (auto cutter = std::dynamic_pointer_cast<CuttingWorkshop>(colleague)) {
            cuttingWorkshop = cutter;
        } else if (auto assembler = std::dynamic_pointer_cast<AssemblyWorkshop>(colleague)) {
            assemblyWorkshop = assembler;
        } else if (auto inspector = std::dynamic_pointer_cast<QualityInspection>(colleague)) {
            qualityInspection = inspector;
        }
    }

    // 接收各环节状态，执行协调逻辑
    void receiveStatus(const std::string& department, const std::string& status) override {
        std::cout << "[调度中心] 收到" << department << "状态：" << status << std::endl;
        // 根据上游状态下发下游指令，实现流程衔接
        if (department == "木材供应商" && status.find("原料已送达") != std::string::npos) {
            sendInstruction("切割车间", "对红橡木板材按图纸尺寸切割");
        } else if (department == "切割车间" && status.find("切割完成") != std::string::npos) {
            sendInstruction("组装车间", "使用切割后的板材组装实木衣柜框架");
        } else if (department == "组装车间" && status.find("组装完成") != std::string::npos) {
            sendInstruction("质检部门", "对组装后的衣柜进行全面质量检验");
        } else if (department == "质检部门" && status.find("质检合格") != std::string::npos) {
            std::cout << "[调度中心] 全流程完成：家具生产合格，可安排入库销售" << std::endl;
        }
    }

    // 向指定部门下发指令
    void sendInstruction(const std::string& department, const std::string& instruction) override {
        if (department == "木材供应商" && woodSupplier) {
            woodSupplier->executeInstruction(instruction);
        } else if (department == "切割车间" && cuttingWorkshop) {
            cuttingWorkshop->executeInstruction(instruction);
        } else if (department == "组装车间" && assemblyWorkshop) {
            assemblyWorkshop->executeInstruction(instruction);
        } else if (department == "质检部门" && qualityInspection) {
            qualityInspection->executeInstruction(instruction);
        }
    }
};

二、在家具生产中的角色对应关系

结合家具生产的典型流程（原料采购 → 切割加工 → 组装成型 → 油漆涂装 → 质检入库），可以将中介者模式中的标准角色映射到实际生产单元中：

• 抽象中介者（Mediator）：定义生产协调的通用接口，包含状态上报和任务下发的方法，对应“生产调度接口”。
• 具体中介者（ConcreteMediator）：实现上述接口，持有所有生产环节的引用，并负责具体的协调流程控制，对应“生产调度中心”。
• 抽象同事类（Colleague）：封装各生产环节共有的行为特征，包含对中介者的引用以及状态反馈机制，对应“生产环节”这一通用角色。
• 具体同事类（ConcreteColleague）：继承抽象同事类，实现各自业务功能并通过中介者进行通信，包括“木材供应商”、“切割车间”、“组装车间”、“油漆车间”和“质检部门”等具体执行单元。

三、C++代码实现示例（基于家具生产场景）

3.1 头文件定义：角色接口与类声明

该部分定义了抽象中介者、具体同事类及其实现方式，构建出完整的交互框架。

int main() {
    // 1. 创建中介者（调度中心）
    std::shared_ptr<FurnitureMediator> dispatcher = std::make_shared<ProductionDispatcher>();

    // 2. 创建各生产环节（同事对象）并注册到调度中心
    auto supplier = std::make_shared<WoodSupplier>(dispatcher);
    auto cutter = std::make_shared<CuttingWorkshop>(dispatcher);
    auto assembler = std::make_shared<AssemblyWorkshop>(dispatcher);
    auto inspector = std::make_shared<QualityInspection>(dispatcher);

    dispatcher->registerColleague(supplier);
    dispatcher->registerColleague(cutter);
    dispatcher->registerColleague(assembler);
    dispatcher->registerColleague(inspector);

    // 3. 调度中心发起生产流程（下达初始指令）
    std::cout << "===================== 实木衣柜生产开始 =====================" << std::endl;
    dispatcher->sendInstruction("木材供应商", "供应红橡木10立方米（含水率8%-12%）");

    return 0;
}

3.2 主函数测试：模拟完整生产流程

通过主函数调用模拟从原料供应到最终质检的全过程，验证各环节通过中介者正确传递消息并执行相应操作，体现解耦后的协作效率。

四、模式优势分析

交互逻辑解耦：每个生产单元仅依赖于调度中心，无需了解其他环节的具体实现。例如木材供应商不必知晓切割车间的技术细节，即使更换设备或工艺，也只需调整内部逻辑，不影响整体系统。

集中式流程控制：整个生产链条的衔接规则（如切割完成触发组装准备）都集中在调度中心处理。当需要新增工序（如加入打磨环节），只需在中介者中扩展注册与协调逻辑，无需修改已有模块，符合“开放-封闭原则”。

提升系统可维护性：若某项规则变更（如原料质量判定标准更新），只需修改中介者中的判断条件，无需逐个修改所有相关生产单元的代码，极大简化了维护工作。

五、适用场景总结

根据本案例的应用效果，当下列情况出现时，推荐采用中介者模式：

1. 系统内存在多个对象且相互间有多对多的复杂交互，形成密集的依赖网络；
2. 希望将分散的交互逻辑集中管理，避免规则碎片化；
3. 需要降低对象之间的耦合程度，以便独立地扩展或替换某个组件；
4. 期望简化各个对象的设计，使其专注于自身核心职责（如切割车间只关注切割任务，不干预后续组装安排）。