设计模式-责任链-笔记

动机(Motivation)

在软件构建过程中,一个请求可能被多个对象处理,但是每个请求在运行时只能有个接受者,如果显示指定,将必不可少地带来请求者与接受者的紧耦合。

如何使请求的发送者不需要指定具体的接受者?让请求的接受者自己在运行是决定来处理请求,从而两者解耦。

模式定义:

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

cpp 复制代码
#include <iostream>
#include <string>

using namespace std;

enum class RequestType {
    REQ_HANDLER1,
    REQ_HANDLER2,
    REQ_HANDLER3,
};

class Request {
    string description;
    RequestType reqType;
public:
    Request(const string& desc, RequestType type) 
        : description(desc), reqType(type) {}
    RequestType getReqType() const { return reqType; }
    const string& getDescription() const { return description; }
};

class ChainHandler {
    ChainHandler* nextChain;
    void sendRequestToNextHandler(const Request& req) {
        if (nullptr != nextChain) {
            nextChain->handle(req);
        }
    }
protected:
    virtual bool canHandleRequest(const Request& req) = 0;
    virtual void processRequest(const Request& req) = 0;
public:
    ChainHandler() { nextChain = nullptr; }
    void setNextChain(ChainHandler* next) { nextChain = next; }

    void handle(const Request& req) {
        if (canHandleRequest(req)) {
            processRequest(req);
        }
        else{
            sendRequestToNextHandler(req);
        }
    }
};

class Handler1 : public ChainHandler {
protected:
    virtual bool canHandleRequest(const Request& req) override {
       return req.getReqType() == RequestType::REQ_HANDLER1;
    }
    virtual void processRequest(const Request& req) override {
        cout << "Handler1 is handle request: " << req.getDescription() << endl;
    }
};

class Handler2 : public ChainHandler {
protected:
    virtual bool canHandleRequest(const Request& req) override {
        return req.getReqType() == RequestType::REQ_HANDLER2;
    }
    virtual void processRequest(const Request& req) override {
        cout << "Handler2 is handle request: " << req.getDescription() << endl;
    }
};

class Handler3 : public ChainHandler {
protected:
    virtual bool canHandleRequest(const Request& req) override {
        return req.getReqType() == RequestType::REQ_HANDLER3;
    }
    virtual void processRequest(const Request& req) override {
        cout << "Handler3 is handle request: " << req.getDescription() << endl;
    }
};

int main() {
    Handler1 h1;
    Handler1 h2;
    Handler1 h3;
    h1.setNextChain(&h2);
    h2.setNextChain(&h3);

    Request req("process task ...", RequestType::REQ_HANDLER3);
    h1.handle(req);
    return 0;
}

要点总结:

Chain of Responsibility模式的应用场合在于"一个请求可能有多个接受者,但是最后真正的接受者只有一个",这时候请求发送者与接受者的耦合有可能出现"变化脆弱"的症状,指责链的目的就是将两者解耦,从而更好地应对变化。

应用了Chain of Responsibility模式后,对象的职责分派将更具灵活性。我们可以在运行时动态增加/修改请求的处理职责。

如果请求传递到职责链的末尾乃得不到处理,应该有一个合理的缺省机制。这也使每一个接受对象的职责,而不是发出请求的对象的职责。

相关推荐
tianchang2 小时前
SSR 深度解析:从原理到实践的完整指南
前端·vue.js·设计模式
饕餮争锋3 小时前
设计模式笔记_创建型_建造者模式
笔记·设计模式·建造者模式
萝卜青今天也要开心3 小时前
2025年上半年软件设计师考后分享
笔记·学习
吃货界的硬件攻城狮4 小时前
【STM32 学习笔记】SPI通信协议
笔记·stm32·学习
蓝染yy4 小时前
Apache
笔记
小小寂寞的城4 小时前
JAVA策略模式demo【设计模式系列】
java·设计模式·策略模式
lxiaoj1115 小时前
Python文件操作笔记
笔记·python
半导体守望者6 小时前
ADVANTEST R4131 SPECTRUM ANALYZER 光谱分析仪
经验分享·笔记·功能测试·自动化·制造
一块plus6 小时前
深度详解 Revive 和 Precompile 技术路径
后端·设计模式·架构
啊我不会诶7 小时前
倍增法和ST算法 个人学习笔记&代码
笔记·学习·算法