职责链模式

介绍

避免将请求发送者和接收者耦合在一起，让多个对象都有机会接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。

处理请求的对象组成一条链（职责链），职责链可以是直线、环、树形结构。请求按职责链传递，链上的处理者对请求进行相应处理。

客户端无需关心请求的处理细节及请求的传递，只需要将请求发送到链上。

现实例子

斗地主，纸牌是请求，玩家是接收者。要的起就打，要不起就下家。

采购单分级审批。

类图

核心在于引入抽象处理者。

两个角色

Handler（抽象处理者）

提供抽象处理请求接口。每个处理者的下家还是处理者，在抽象处理者中定义了抽象处理者类型的对象，作为其下家引用。通过该引用，处理者可连成一条链。

ConcreteHandler（具体处理者）

抽象处理者的子类，实现了父类定义的抽象处理请求方法。在处理请求之前先判断是否有相应处理权限，有就处理，没有就转发给后继。

优点

发送请求的客户端不需要知道职责链上的哪个对象处理的请求，可以在不影响客户端的情况下重写组织链和分配责任。

职责链模式并不创建职责链。职责链的创建工作必须由系统的其他部分完成。一般是使用职责链的客户端创建职责链。

职责链模式降低了请求的发送端和接收端之间的耦合，使得多个对象都有机会处理请求。

举个例子（购买审批）

deepseek优化前

#include <string>
#include <iostream>
class PurchaseRequest
{
private:
    double _amount;
    int _number;
    std::string _purpose;
public:
    PurchaseRequest(double amount,int number,std::string purpose):_amount(amount),_number(number),_purpose(purpose){}
    void setAmount(double amount){
        _amount=amount;
    }
    double getAmount(){
        return _amount;
    }
    void setNumber(int number){
        _number=number;
    }
    int getNumber(){
        return _number;
    }
    void setPurpose(std::string purpose){
        _purpose=purpose;
    }
    std::string getPurpose(){
        return _purpose;
    }
};

class Approver{
public:
    Approver* _successor;
    std::string _name;
public:
    Approver(std::string name){
        _name=name;
    }
    void setSuccessor(Approver* successor){
        _successor=successor;
    }
    virtual void processRequest(PurchaseRequest request)=0;
};

class Director : public Approver
{
public:
    Director(std::string name):Approver(name){}
    void processRequest(PurchaseRequest request) override{
        if(request.getAmount()<100)
            std::cout<<"Director Process Request\n";
        else
            _successor->processRequest(request);
    }
};

class VicePresident : public Approver
{
public:
    VicePresident(std::string name):Approver(name){}
    void processRequest(PurchaseRequest request) override{
        if(request.getAmount()<200)
            std::cout<<"VicePresident Process Request\n";
        else
            _successor->processRequest(request);
    }
};

class President : public Approver
{
public:
    President(std::string name):Approver(name){}
    void processRequest(PurchaseRequest request) override{
        if(request.getAmount()<300)
            std::cout<<"President Process Request\n";
        else
            _successor->processRequest(request);
    }
};

class Congress : public Approver
{
public:
    Congress(std::string name):Approver(name){}
    void processRequest(PurchaseRequest request) override{
        std::cout<<"Congress Process Request\n";
    }
};

int main(){
    Approver *director,*vicePresident,*president,*congress;
    director=new Director("Dir a");
    vicePresident=new VicePresident("VP b");
    president=new President("P c");
    congress=new Congress("Con d");

    PurchaseRequest *pr=new PurchaseRequest(250,1,"buy");
    director->setSuccessor(vicePresident);
    vicePresident->setSuccessor(president);
    president->setSuccessor(congress);

    director->processRequest(*pr);
}

deepseek优化后

#include <string>
#include <iostream>
#include <memory> // 引入智能指针

// PurchaseRequest 改为不可变对象，移除setter
class PurchaseRequest {
private:
    const double m_amount;
    const int m_number;
    const std::string m_purpose;
public:
    PurchaseRequest(double amount, int number, std::string purpose)
        : m_amount(amount), m_number(number), m_purpose(std::move(purpose)) {}
    
    // 只保留getter，移除setter
    double getAmount() const { return m_amount; }
    int getNumber() const { return m_number; }
    std::string getPurpose() const { return m_purpose; }
};

class Approver {
protected:
    std::unique_ptr<Approver> m_successor; // 使用智能指针管理后继者
    std::string m_name;
public:
    explicit Approver(std::string name) : m_name(std::move(name)) {}
    virtual ~Approver() = default; // 添加虚析构函数
    
    // 修改setSuccessor返回后继者的指针，支持链式调用
    Approver* setSuccessor(std::unique_ptr<Approver> successor) {
        m_successor = std::move(successor);
        return m_successor.get(); // 返回后继者的裸指针
    }
    virtual void processRequest(const PurchaseRequest& request) = 0; // 使用const引用避免拷贝
    
protected:
    // 公共逻辑：若无法处理则传递请求
    void forwardRequest(const PurchaseRequest& request) {
        if (m_successor) {
            m_successor->processRequest(request);
        } else {
            std::cerr << "Request cannot be handled. No successor available.\n";
        }
    }
};

// 具体处理者类通过继承实现
class Director : public Approver {
public:
    using Approver::Approver; // 继承构造函数
    
    void processRequest(const PurchaseRequest& request) override {
        if (request.getAmount() < 100) {
            std::cout << m_name << " (Director) processed request\n";
        } else {
            std::cout << m_name << " (Director) forwarded request\n";
            forwardRequest(request);
        }
    }
};

class VicePresident : public Approver {
public:
    using Approver::Approver;
    
    void processRequest(const PurchaseRequest& request) override {
        if (request.getAmount() < 200) {
            std::cout << m_name << " (VicePresident) processed request\n";
        } else {
            std::cout << m_name << " (VicePresident) forwarded request\n";
            forwardRequest(request);
        }
    }
};

class President : public Approver {
public:
    using Approver::Approver;
    
    void processRequest(const PurchaseRequest& request) override {
        if (request.getAmount() < 300) {
            std::cout << m_name << " (President) processed request\n";
        } else {
            std::cout << m_name << " (President) forwarded request\n";
            forwardRequest(request);
        }
    }
};

class Congress : public Approver {
public:
    using Approver::Approver;
    
    void processRequest(const PurchaseRequest& request) override {
        std::cout << m_name << " (Congress) finally processed request\n";
    }
};

int main() {
    auto director = std::make_unique<Director>("Dir A");
    
    // 链式构建责任链
    director->setSuccessor(std::make_unique<VicePresident>("VP B"))
            ->setSuccessor(std::make_unique<President>("P C"))
            ->setSuccessor(std::make_unique<Congress>("Con D"));

    PurchaseRequest pr(250, 1, "buy");
    director->processRequest(pr); 
    
    return 0;
}

推荐一下

https://github.com/0voice