责任链模式（Chain of Responsibility）

原创于 2024-04-21 13:42:21 发布 · 819 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#责任链模式 #c++ #开发语言

C/C++学习专栏收录该内容

30 篇文章

订阅专栏

本文介绍了责任链模式在处理请求流程中的应用，通过示例展示了如何使用抽象基类和具体处理者实现请求的逐级处理。同时，讨论了多线程异步环境下的应用以及与命令模式、中介者模式和观察者模式的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

简介
示意图
代码实现
- 多线程异步实现
优缺点

简介

对于责任链模式，其作为一种行为设计模式，允许你将请求沿着处理者链进行发送。收到请求后，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者。这种处理方法类似包与包之间的调用的思路，只是其可以不在主程序中累赘的去申明一堆if else变量使得程序更加臃肿。
相比于创建设计模式的对整体架构进行的设计，和结构设计模式对对象的化繁为简的操作，作为行为设计模式，其需要我们对数据流能够充分的把握，来避免检查代码的混乱不堪。而每次新增功能都会使其更加臃肿。修改某个检查步骤有时会影响其他的检查步骤。最糟糕的是，当你希望复用这些检查步骤来保护其他系统组件时，你只能复制部分代码，因为这些组件只需部分而非全部的检查步骤。

示意图

BaseHandler：抽象基类，用于作为处理请求的接口。如果特定等级的请求该类无法处理，则传递给下一个handler，一般这类情况class内部都是纯虚函数。
ConcreteHandler（TechnicalSupportHandler, BillingSupportHandler, and GeneralSupportHandler）：处理请求，或将请求传递给handler链中的下一个，这样可以通过设计整个逻辑链避免混乱
Client（RequestorClient）：发起请求，一般是放在主程序中传入

代码实现

在所有的行为模式中，都设计的准则为：使用对象的组合而不是对象的继承。责任链模式所描述的是：与其从已有的类中继承新的类，不如让你的类指向一个你要使用的已经存在的类。责任链模式通过对Handler Object的封装能够有效地管理整条数据流（行为）的走向。从而避免过多的继承嵌套，与数据流的混乱。

#include <iostream>
using namespace std;

//抽象处理者
class Handler
{
public:
    Handler() { m_pNextHandler = NULL; }
    virtual ~Handler() {}

    //设置下一个处理者
    void SetNextHandler(Handler *successor) { m_pNextHandler = successor; }

    //处理请求
    virtual void HandleRequest(int days) = 0;
protected:
    Handler *m_pNextHandler;  // 后继者
};


//具体处理者、主管
class Director :public Handler
{
public:
    //处理请求
    virtual void HandleRequest(int days)
    {
        if (days <= 1)
        {
            cout << "我是主管，有权批准一天假，同意了！" << endl; 
        }
        else
        {
            m_pNextHandler->HandleRequest(days);
        }
    }
};

//具体处理者、经理
class Manager :public Handler
{
public:
    //处理请求
    virtual void HandleRequest(int days)
    {
        if (days <= 3)
        {
            cout << "我是经理，有权批准三以下的假，同意了！" << endl;
        }
        else
        {
            m_pNextHandler->HandleRequest(days);
        }
    }
};

//具体处理者、老板
class Boss :public Handler
{
public:
    //处理请求
    virtual void HandleRequest(int days)
    {
        if (days <= 7)
        {
            cout << "我是老板，最多让你请7天假，同意了！" << endl;
        }
        else
        {
            cout << "你请的假事假太长了，不同意！" << endl;
        }
    }
};



//场景
int main()
{
    Handler *director = new Director;
    Handler *manager = new Manager;
    Handler *boss = new Boss;

    //设置责任链
    director->SetNextHandler(manager);
    manager->SetNextHandler(boss);


    director->HandleRequest(1);
    director->HandleRequest(2);
    director->HandleRequest(5);
    director->HandleRequest(8);
    return 0;
}
/*结果：
我是主管，有权批准一天假，同意了！
我是经理，有权批准三以下的假，同意了
我是老板，最多让你请7天假，同意了！
你请的假事假太长了，不同意！
请按任意键继续. . .*/

多线程异步实现

我们可以明白，作为行为设计模式，其可以使用多线程并行的方式来实现程序运行时间的节约，而责任链模式其具有清晰地逻辑步骤，这就非常适合线程池线性的数据传输。

// mutex1.cpp         通过互斥体lock与unlock保护共享全局变量

#include <chrono>
#include <mutex>
#include <thread>
#include <iostream> 

std::chrono::milliseconds interval(100);

std::mutex mutex;
int job_shared = 0; //两个线程都能修改'job_shared',mutex将保护此变量
int job_exclusive = 0; //只有一个线程能修改'job_exclusive',不需要保护

//此线程只能修改 'job_shared'
void job_1()
{
    mutex.lock();
    std::this_thread::sleep_for(5 * interval);  //令‘job_1’持锁等待
    ++job_shared;
    std::cout << "job_1 shared (" << job_shared << ")\n";
    mutex.unlock();
}

// 此线程能修改'job_shared'和'job_exclusive'
void job_2()
{
    while (true) {    //无限循环，直到获得锁并修改'job_shared'
        if (mutex.try_lock()) {     //尝试获得锁成功则修改'job_shared'
            ++job_shared;
            std::cout << "job_2 shared (" << job_shared << ")\n";
            mutex.unlock();
            return;
        } else {      //尝试获得锁失败,接着修改'job_exclusive'
            ++job_exclusive;
            std::cout << "job_2 exclusive (" << job_exclusive << ")\n";
            std::this_thread::sleep_for(interval);
        }
    }
}

int main() 
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);

    thread_1.join();
    thread_2.join();

    getchar();
    return 0;
}