C++实现设计模式---职责链模式 (Chain of Responsibility)

职责链模式 (Chain of Responsibility)

职责链模式 是一种行为型设计模式,它允许多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合。这些对象通过形成一条链,沿着这条链传递请求,直到有对象处理它为止。


意图

  • 通过将请求的发送者与接收者解耦,动态地决定由哪个对象来处理请求。
  • 使多个对象有机会处理请求,而不是由固定的对象处理。

使用场景

  1. 请求的处理者不确定
    • 在运行时,可能需要多个对象来处理请求,但具体的处理者在编译时无法确定。
  2. 需要动态组合请求处理的责任链
    • 希望将多个处理者按顺序动态排列。
  3. 减少耦合
    • 将请求的发送者和处理者解耦。

参与者角色

  1. 处理者接口 (Handler)
    • 定义处理请求的方法,并保存对下一个处理者的引用。
  2. 具体处理者 (ConcreteHandler)
    • 实现处理者接口,处理请求或将请求传递给下一个处理者。
  3. 客户端 (Client)
    • 创建责任链,并向责任链中的第一个处理者发送请求。

示例代码

以下代码展示了职责链模式的实现,用于模拟用户请求的权限校验。系统中有三种责任:身份验证、权限验证和业务处理。

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

// 处理者接口
class Handler {
protected:
    std::shared_ptr<Handler> nextHandler; // 下一个处理者

public:
    virtual ~Handler() = default;

    // 设置下一个处理者
    void setNext(std::shared_ptr<Handler> next) {
        nextHandler = std::move(next);
    }

    // 处理请求的接口
    virtual void handleRequest(const std::string& request) {
        if (nextHandler) {
            nextHandler->handleRequest(request); // 将请求传递给下一个处理者
        }
    }
};

// 具体处理者:身份验证
class AuthHandler : public Handler {
public:
    void handleRequest(const std::string& request) override {
        if (request == "auth") {
            std::cout << "身份验证通过。
";
            if (nextHandler) {
                nextHandler->handleRequest(request); // 传递给下一个处理者
            }
        } else {
            std::cout << "身份验证失败。
";
        }
    }
};

// 具体处理者:权限验证
class PermissionHandler : public Handler {
public:
    void handleRequest(const std::string& request) override {
        if (request == "auth") {
            std::cout << "权限验证通过。
";
            if (nextHandler) {
                nextHandler->handleRequest(request); // 传递给下一个处理者
            }
        } else {
            std::cout << "权限验证失败。
";
        }
    }
};

// 具体处理者:业务处理
class BusinessHandler : public Handler {
public:
    void handleRequest(const std::string& request) override {
        if (request == "auth") {
            std::cout << "业务处理完成。
";
        } else {
            std::cout << "无法进行业务处理。
";
        }
    }
};

// 客户端代码
int main() {
    // 创建处理者
    auto authHandler = std::make_shared<AuthHandler>();
    auto permissionHandler = std::make_shared<PermissionHandler>();
    auto businessHandler = std::make_shared<BusinessHandler>();

    // 构建责任链
    authHandler->setNext(permissionHandler);
    permissionHandler->setNext(businessHandler);

    // 发送请求
    std::cout << "发送请求:auth
";
    authHandler->handleRequest("auth");

    std::cout << "
发送请求:invalid
";
    authHandler->handleRequest("invalid");

    return 0;
}

代码解析

1. 处理者接口 (Handler)
  • 定义了处理请求的接口 handleRequest,并包含对下一个处理者的引用。
  • 通过 setNext 方法设置链中的下一个处理者。
cpp 复制代码
class Handler {
protected:
    std::shared_ptr<Handler> nextHandler; // 下一个处理者
public:
    virtual ~Handler() = default;
    void setNext(std::shared_ptr<Handler> next) {
        nextHandler = std::move(next);
    }
    virtual void handleRequest(const std::string& request) {
        if (nextHandler) {
            nextHandler->handleRequest(request); // 将请求传递给下一个处理者
        }
    }
};
2. 具体处理者 (AuthHandler, PermissionHandler, BusinessHandler)
  • AuthHandler
    • 验证请求是否通过身份认证。
  • PermissionHandler
    • 验证请求是否有权限。
  • BusinessHandler
    • 完成实际的业务逻辑处理。
cpp 复制代码
class AuthHandler : public Handler {
public:
    void handleRequest(const std::string& request) override {
        if (request == "auth") {
            std::cout << "身份验证通过。
";
            if (nextHandler) {
                nextHandler->handleRequest(request);
            }
        } else {
            std::cout << "身份验证失败。
";
        }
    }
};
3. 客户端代码
  • 客户端创建责任链的各个处理者,并将它们按顺序连接。
  • 最后,将请求发送到链中的第一个处理者。
cpp 复制代码
int main() {
    auto authHandler = std::make_shared<AuthHandler>();
    auto permissionHandler = std::make_shared<PermissionHandler>();
    auto businessHandler = std::make_shared<BusinessHandler>();

    authHandler->setNext(permissionHandler);
    permissionHandler->setNext(businessHandler);

    authHandler->handleRequest("auth");
}

优缺点

优点
  1. 请求处理灵活
    • 可以根据需要动态地改变责任链的结构。
  2. 解耦请求发送者与处理者
    • 请求发送者不需要知道具体的处理者。
  3. 职责分离
    • 每个处理者只关注自己的职责。
缺点
  1. 请求可能未被处理
    • 如果责任链中没有处理者能处理请求,请求可能会被丢弃。
  2. 调试难度增加
    • 链的结构动态变化,可能导致调试困难。

适用场景

  1. 多个对象可以处理同一个请求
    • 如任务的审批流程。
  2. 需要动态组合请求处理逻辑
    • 可以灵活调整处理者的顺序。
  3. 解耦请求的发送者与接收者
    • 请求发送者不需要直接调用处理者。

总结

职责链模式通过将请求沿着处理者链传递,实现了请求的动态处理。它特别适用于需要动态组合请求处理逻辑,或者需要解耦请求发送者和接收者的场景。

相关推荐
蜉蝣之翼❉1 小时前
CRT 不同会导致 fopen 地址不同
c++·mfc
aramae1 小时前
C++ -- STL -- vector
开发语言·c++·笔记·后端·visual studio
lixzest1 小时前
C++ Lambda 表达式详解
服务器·开发语言·c++·算法
ffcf2 小时前
设计模式—专栏简介
设计模式
_Chipen2 小时前
C++基础问题
开发语言·c++
灿烂阳光g2 小时前
OpenGL 2. 着色器
c++·opengl
AA陈超4 小时前
虚幻引擎UE5专用服务器游戏开发-20 添加基础能力类与连招能力
c++·游戏·ue5·游戏引擎·虚幻
mit6.8244 小时前
[Meetily后端框架] AI摘要结构化 | `SummaryResponse`模型 | Pydantic库 | vs marshmallow库
c++·人工智能·后端
R-G-B4 小时前
【02】MFC入门到精通——MFC 手动添加创建新的对话框模板
c++·mfc·mfc 手动添加创建新的对话框
tianchang4 小时前
SSR 深度解析:从原理到实践的完整指南
前端·vue.js·设计模式