【设计模式】【行为型模式】【责任链模式】

系列文章目录

可跳转到下面链接查看下表所有内容https://blog.csdn.net/handsomethefirst/article/details/138226266?spm=1001.2014.3001.5501文章浏览阅读2次。系列文章大全https://blog.csdn.net/handsomethefirst/article/details/138226266?spm=1001.2014.3001.5501

---

目录

系列文章目录

1 简介

1.1 基本概念

1.2 组成结构

1.3 优点和缺点

2.代码案例

2.1 主要步骤

2.2 代码

---

1 简介

1.1 基本概念

责任链模式是一种行为型设计模式，它允许你构建一个对象链，让请求从链的一端进入，然后依次沿着链传递处理，直到链上的某个对象能够处理该请求。职责链上的每一个处理者都是一个对象，其内部会包含mNext指向下一个对象，这个对象可以对请求进行处理也可以将请求发送给下一个对象去处理。

1.2 组成结构

1.客户端类：首先其需要创建并组装处理者对象链，即客户端需要通过SetNextHandler函数，将其mNext指向下一个处理者，然后形成一个链表，当客户端发送请求的时候，只需要调用第一个处理者的处理函数即可。
2.抽象的处理者Handler类：这是一个抽象类，主要提供两个接口，第一一个接口是SetNextHandler函数，用于指向下一个处理者，第二个接口是hanlerRequset函数，用于让子类去重写其实现。
2.具体的处理者，Handler类的子类，需要重写hanlerRequset函数。

1.3 优点和缺点

优点：

1.降低耦合度，将请求的发送者和处理者解耦，每个具体的处理者只处理和自己相关的请求，客户端无需知道谁来处理。

2.可扩展性，新增加处理者，也无须修改原有的代码。只继续放在链表中即可。

3.灵活性，可以动态的改变处理者之间的顺序，新增和删除处理者，很方便。

缺点：

1.当链表上的处理者比较多的时候，请求可能需要遍历所有的处理者，可能会存在性能问题。

2.链表建立不当可能草成循环调用，即进入死循环。

3.不一定被处理，如果中间写错，则很可能请求无法到末端。

2.代码案例

2.1 主要步骤

第一步：构建抽象的处理者类（Handler）

第二步：构建多个具体的处理者类，并重写hanlerRequset函数，处理自己类的需求。

第三步：构建链表。

第四步：调用链表头部的hanlerRequset函数。

第三步：

2.2 代码

class Handler //抽象处理类父类
{
public:
    Handler(std::shared_ptr<Handler> NextHandler)
    {
        setNextHandler(NextHandler);
    }
    void setNextHandler(const std::shared_ptr<Handler> NextHandler)//设置当前处理者的下一个处理者
    {
        mNextHandler = NextHandler;
    }
    virtual int hanlerRequset(int day) = 0; //纯虚函数，子类需要具体的实现

    std::shared_ptr<Handler> mNextHandler = nullptr;//指向下一个处理者类
};
0
class GroupLeaderHandler : public Handler //第一个处理者（组长）
{
public:
    GroupLeaderHandler(std::shared_ptr<Handler> NextHandler) : Handler(NextHandler)
    {
    }
    int hanlerRequset(int day)
    {
        if (day < 0)
        {
            cout << "day is error" << endl;
            return -1;
        }
        else if (day <= 3 && day >= 0)
        {
            cout << "GroupLeaderHandler hanlerRequset success" << endl;
            return 0;
        }
        else
        {
            if (mNextHandler)
            {
                return mNextHandler->hanlerRequset(day);
            }
            else
            {
                return -1;
            }
        }
    }
};

class ManagerHandler : public Handler//第二个处理者（经理）
{
public:
    ManagerHandler(std::shared_ptr<Handler> NextHandler) : Handler(NextHandler)
    {
    }
    int hanlerRequset(int day)
    {
        if (day < 0)
        {
            cout << "day is error" << endl;
            return -1;
        }
        else if (day <= 7 && day >= 4)
        {
            cout << "ManagerHandler hanlerRequset success" << endl;
            return 0;
        }
        else
        {
            if (mNextHandler)
            {
                return mNextHandler->hanlerRequset(day);
            }
            else
            {
                return -1;
            }
        }
    }
};

class DirectorHandler : public Handler
{
public:
    DirectorHandler(std::shared_ptr<Handler> NextHandler) : Handler(NextHandler)//第三个处理者（董事长）
    {
    }
    int hanlerRequset(int day)
    {
        if (day < 0)
        {
            cout << "day is error" << endl;
            return -1;
        }
        else if (day >= 8)
        {
            cout << "DirectorHandler hanlerRequset success" << endl;
            return 0;
        }
        else
        {
            if (mNextHandler)
            {
                return mNextHandler->hanlerRequset(day);
            }
            else
            {
                return -1;
            }
        }
    }
};

int main()
{  	
    auto mspDirectorHandler = make_shared<DirectorHandler>(nullptr);
    auto mspManagerHandler = make_shared<ManagerHandler>(mspDirectorHandler);
    auto mspGroupLeaderHandler = make_shared<GroupLeaderHandler>(mspManagerHandler);//构建链表
    mspGroupLeaderHandler->hanlerRequset(3);//调用统一接口去处理
    mspGroupLeaderHandler->hanlerRequset(5);
    mspGroupLeaderHandler->hanlerRequset(8);
    
    return 0;
}