职责链模式 (Chain of Responsibility Pattern)

职责链模式 (Chain of Responsibility Pattern)

意图：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。

基础组件

• Handler (处理器)：定义处理请求的接口，并实现后继链（可选）
• ConcreteHandler (具体处理器)：处理它所负责的请求，可以访问其后继者

继承/实现关系

Handler <|-- ConcreteHandler
Handler --> Handler (后继链)

应用场景

• 有多个对象可以处理请求，但具体由哪个对象处理在运行时自动确定
• 需要在不明确接收者的情况下向多个对象提交请求
• 可动态指定处理请求的对象集合

C++ 实现（审批流程场景）

#include <iostream>
#include <string>

/*
* 职责链模式
* 意图：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
* 基础组件：
* Handler (处理器)：定义处理请求的接口，并实现后继链（可选）
* ConcreteHandler (具体处理器)：处理它所负责的请求，可以访问其后继者
* 继承/实现关系：
* ConcreteHandler继承自Handler，并实现处理请求的逻辑。每个ConcreteHandler都可以选择是否处理请求，如果不能处理，则将请求传递给后继者。
* Handler类通常包含一个指向后继Handler的指针或引用，以便在处理请求时可以将请求传递给下一个处理器。
*/

// 请求类：报销申请
class ExpenseReport {
public:
    ExpenseReport(double amount, const std::string& description)
        : amount_(amount), description_(description) {}

    double getAmount() const { return amount_; }
    const std::string& getDescription() const { return description_; }

private:
    double amount_;
    std::string description_;
};

// 抽象处理器，其中包含一个指向下一个处理器的指针
class Approver {
public:
    explicit Approver(double limit) : limit_(limit), next_(nullptr) {}

    void setNext(std::shared_ptr<Approver> next) {
        next_ = next;
    }

    virtual void processRequest(const ExpenseReport& report) {
		// 对于职责链上的每个处理器，检查报销金额是否在其处理范围内
        if (report.getAmount() <= limit_) {
            approve(report);
        }
        else if (next_ != nullptr) {
			// 如果当前处理器不能处理请求，则将请求传递给下一个处理器
            next_->processRequest(report);
        }
        else {
			// 如果没有处理器可以处理该请求，则输出一条消息
            std::cout << "Request for $" << report.getAmount()
                << " requires executive approval!\n";
        }
    }

    virtual ~Approver() = default;

protected:
	// 纯虚函数，具体处理器需要实现该函数来处理报销申请
    virtual void approve(const ExpenseReport& report) = 0;

private:
    double limit_;
    std::shared_ptr<Approver> next_;
};

// 具体处理器：主管
class Supervisor : public Approver {
public:
    Supervisor() : Approver(1000) {}

protected:
    void approve(const ExpenseReport& report) override {
        std::cout << "Supervisor approved $" << report.getAmount()
            << " for: " << report.getDescription() << "\n";
    }
};

// 具体处理器：部门经理
class DepartmentManager : public Approver {
public:
    DepartmentManager() : Approver(5000) {}

protected:
    void approve(const ExpenseReport& report) override {
        std::cout << "Department Manager approved $" << report.getAmount()
            << " for: " << report.getDescription() << "\n";
    }
};

// 具体处理器：财务总监
class FinanceDirector : public Approver {
public:
    FinanceDirector() : Approver(20000) {}

protected:
    void approve(const ExpenseReport& report) override {
        std::cout << "Finance Director approved $" << report.getAmount()
            << " for: " << report.getDescription() << "\n";
    }
};

// 具体处理器：首席执行官
class CEO : public Approver {
public:
	CEO() : Approver(std::numeric_limits<double>::max()) {}

protected:
	void approve(const ExpenseReport& report) override {
		std::cout << "CEO approved $" << report.getAmount()
			<< " for: " << report.getDescription() << "\n";
	}
};

void ChainOfResponsibilityPattern()
{
	std::cout << std::string(6, '-') << " Chain of Responsibility Pattern " << std::string(6, '-') << "\n";
    // 创建审批链
	auto supervisor = std::make_shared<Supervisor>();
	auto departmentManager = std::make_shared<DepartmentManager>();
	auto financeDirector = std::make_shared<FinanceDirector>();
	auto ceo = std::make_shared<CEO>();

    // 设置链
	supervisor->setNext(departmentManager);
	departmentManager->setNext(financeDirector);
    financeDirector->setNext(ceo);

    // 创建报销申请
    ExpenseReport report1(800, "Office supplies");
    ExpenseReport report2(3500, "Conference attendance");
    ExpenseReport report3(15000, "Team building event");
    ExpenseReport report4(25000, "New equipment");

    // 处理请求
    supervisor->processRequest(report1);
    supervisor->processRequest(report2);
    supervisor->processRequest(report3);
    supervisor->processRequest(report4);
}

组件对应关系

• Approver → 处理器
• Supervisor/DepartmentManager/FinanceDirector → 具体处理器
• ExpenseReport → 请求对象