一、中介者模式核心概念

中介者模式是一种行为型设计模式，其核心思想是通过引入一个"中介者"对象，封装一系列对象之间的交互逻辑，使原本错综复杂的网状交互关系转化为清晰的星型结构。在这种结构中，各个交互对象（称为"同事类"）不再直接相互通信，而是通过中介者传递信息并协调行为，从而降低对象间的耦合度，提高系统的可维护性和扩展性。

类比到日常的家具生产场景：如果没有专门的生产调度员，木材供应商需要直接联系切割车间确认用料需求，切割车间要对接组装车间告知加工进度，组装车间又要通知油漆车间准备作业，各环节形成的交叉沟通会导致信息混乱、响应滞后。而生产调度员就扮演了中介者的角色，所有环节只需向调度员反馈信息并接收其指令，实现高效协同。

二、家具生产中的中介者模式角色映射

根据中介者模式的标准结构，结合家具生产流程（原料采购→切割加工→组装成型→油漆涂装→质检入库），各角色对应关系如下：

• 抽象中介者（Mediator）：定义生产协调的接口，包含各环节状态通知和指令下发的抽象方法，对应"生产调度接口"。

• 具体中介者（ConcreteMediator）：实现抽象中介者接口，维护所有生产环节的引用，封装具体协调逻辑，对应"生产调度中心"。

• 抽象同事类（Colleague）：定义生产环节的通用接口，持有中介者引用，提供状态反馈和指令执行的抽象方法，对应"生产环节"。

• 具体同事类（ConcreteColleague）：实现抽象同事类接口，完成自身业务逻辑并通过中介者交互，对应"木材供应商、切割车间、组装车间、油漆车间、质检部门"等具体生产单元。

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

3.1 头文件定义（角色接口与实现）

#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);
        }
    }
};

3.2 主函数测试（模拟生产流程）

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;
}

四、模式解析

1. 解耦交互逻辑：各生产环节（同事类）仅与调度中心（中介者）通信，木材供应商无需知道切割车间的存在，即使更换切割设备或工艺，只需修改切割车间内部逻辑，不影响其他环节。

2. 集中协调控制：生产流程的衔接逻辑（如原料到切割、组装到质检）全部封装在调度中心，若需调整流程（如新增"打磨车间"），仅需扩展中介者的注册和协调逻辑，符合"开放-封闭原则"。

3. 提高可维护性：当需要修改交互规则（如原料合格标准变更）时，只需修改中介者中对应的状态判断逻辑，无需改动所有相关生产环节的代码。

五、中介者模式适用场景总结

结合本次家具生产案例，当中存在以下特征时，适合使用中介者模式：

1. 系统中多个对象存在复杂的多对多交互关系，形成网状依赖； 2. 需集中管理交互逻辑，避免交互规则散落在各个对象中； 3. 希望降低对象耦合度，便于独立扩展或替换单个对象； 4. 需简化对象设计，使对象专注于自身核心业务（如切割车间仅负责切割，无需关注后续组装安排）。