23种设计模式 - 责任链

模式定义

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，允许多个对象按链式顺序处理请求，直到其中一个对象处理为止。该模式将请求的发送者和接收者解耦，使多个对象都有机会处理请求。

---

模式结构

抽象处理者（Handler）

• 定义处理请求的接口（如 handleRequest()）
• 持有下一个处理者的引用（nextHandler）
  具体处理者（ConcreteHandler）
• 实现请求处理逻辑，决定是否处理或传递请求
  客户端（Client）
• 构建处理链并触发请求

---

适用场景

多级处理逻辑：数控系统中需要依次执行安全检查、参数校验、运动控制等步骤
动态调整处理流程：运行时灵活调整处理链顺序（如紧急任务跳过某些校验）
解耦请求与处理者：避免请求发送者依赖具体处理对象

---

C++示例（数控系统场景）

场景说明：
数控系统执行加工任务时需依次通过安全检查、参数校验、运动控制三个环节，任一环节失败则终止流程。

#include 
#include 

// 请求类：加工任务
class MachiningRequest {
public:
    MachiningRequest(int speed, float depth) 
        : speed_(speed), depth_(depth), isSafe_(false), isValid_(false) {}
    
    int speed_;
    float depth_;
    bool isSafe_;
    bool isValid_;
};

// 抽象处理者
class Handler {
protected:
    Handler* nextHandler_;
public:
    Handler() : nextHandler_(nullptr) {}
    virtual ~Handler() = default;
    
    void setNext(Handler* handler) { 
        nextHandler_ = handler; 
    }
    
    virtual void handleRequest(MachiningRequest& request) = 0;
};

// 具体处理者：安全检查
class SafetyCheckHandler : public Handler {
public:
    void handleRequest(MachiningRequest& request) override {
        if (request.speed_ <= 5000 && request.depth_ <= 100.0f) {
            request.isSafe_ = true;
            std::cout << "安全检查通过" << std::endl;
            if (nextHandler_) nextHandler_->handleRequest(request);
        } else {
            std::cout << "安全校验失败：参数超限" << std::endl;
        }
    }
};

// 具体处理者：参数校验
class ParameterValidator : public Handler {
public:
    void handleRequest(MachiningRequest& request) override {
        if (request.speed_ > 0 && request.depth_ > 0) {
            request.isValid_ = true;
            std::cout << "参数校验通过" << std::endl;
            if (nextHandler_) nextHandler_->handleRequest(request);
        } else {
            std::cout << "参数校验失败：非法数值" << std::endl;
        }
    }
};

// 具体处理者：运动控制
class MotionController : public Handler {
public:
    void handleRequest(MachiningRequest& request) override {
        if (request.isSafe_ && request.isValid_) {
            std::cout << "运动控制执行：速度=" << request.speed_ 
                      << "rpm，深度=" << request.depth_ << "mm" << std::endl;
        }
    }
};

int main() {
    // 构建处理链
    Handler* safetyCheck = new SafetyCheckHandler();
    Handler* validator = new ParameterValidator();
    Handler* motionCtrl = new MotionController();
    
    safetyCheck->setNext(validator);
    validator->setNext(motionCtrl);

    // 触发请求
    MachiningRequest task1(2500, 50.0f);
    std::cout << "--- 任务1执行 ---" << std::endl;
    safetyCheck->handleRequest(task1);

    MachiningRequest task2(6000, 150.0f);
    std::cout << "\n--- 任务2执行 ---" << std::endl;
    safetyCheck->handleRequest(task2);

    delete safetyCheck;
    delete validator;
    delete motionCtrl;
    return 0;
}

输出结果

--- 任务1执行 ---
安全检查通过
参数校验通过
运动控制执行：速度=2500rpm，深度=50mm

--- 任务2执行 ---
安全校验失败：参数超限

---

实现要点

链式传递：每个处理者通过 nextHandler_ 传递请求，形成处理链[
动态扩展：新增处理步骤（如日志记录）只需添加新 ConcreteHandler
终止条件：处理者根据业务逻辑决定是否中断链（如安全检查失败）

---

模式变体

纯责任链：请求必须被严格处理或传递（如审批流程）
带中断的链：处理完成后可终止传递（如本示例的安全检查）
优先级链：按优先级动态排序处理者（如紧急任务优先处理）