当前位置: 首页 > news >正文

C++软件设计模式之责任链模式

责任链模式的动机与意图

动机:
在软件开发中,经常会遇到需要处理一系列请求或事件的情况。这些请求可能需要经过多个处理对象,每个对象根据其职责决定是否处理请求或将其传递给下一个对象。责任链模式(Chain of Responsibility Pattern)提供了一种将请求的发送者和接收者解耦的方式,允许多个对象都有机会处理请求,从而避免了请求发送者与接收者之间的紧密耦合。

意图:
责任链模式的意图是使多个对象都有机会处理请求,从而避免请求的发送者与接收者之间的耦合。将这些对象连成一条链,并沿着这条链传递请求,直到有对象处理它为止。

适用场合

  1. 多个对象可以处理同一请求,但具体由哪个对象处理在运行时确定。
  2. 需要在不明确指定接收者的情况下,向多个对象中的一个提交请求。
  3. 需要动态指定一组对象处理请求,例如在运行时动态调整处理链。

责任链模式的变体

  1. 纯责任链模式:

    • 每个处理者要么处理请求,要么将请求传递给下一个处理者,但不能同时进行。
    • 这种模式通常用于严格的链式处理,例如审批流程。
  2. 不纯责任链模式:

    • 处理者可以部分处理请求,然后将请求传递给下一个处理者。
    • 这种模式允许处理者在处理请求的同时,继续传递请求,适用于需要多个处理者共同完成任务的场景。
  3. 带中断的责任链模式:

    • 处理者可以在处理请求后决定是否中断链的传递。
    • 这种模式适用于某些情况下,一旦请求被处理,就不需要继续传递的场景。
  4. 带优先级的责任链模式:

    • 处理者根据优先级决定是否处理请求,优先级高的处理者先处理请求。
    • 这种模式适用于需要根据优先级决定处理顺序的场景。

以下是基于责任链模式的不同变体的 C++ 代码示例。每个示例都展示了如何在 C++ 中实现责任链模式的不同形式。


1. 纯责任链模式

在纯责任链模式中,每个处理者要么处理请求,要么将请求传递给下一个处理者。处理者不会同时处理请求并传递请求。

#include <iostream>
#include <memory>class Handler {
public:virtual ~Handler() = default;virtual void setNext(std::shared_ptr<Handler>) = 0;virtual void handle(const std::string& request) = 0;
};class BaseHandler : public Handler {
protected:std::shared_ptr<Handler> nextHandler;public:void setNext(std::shared_ptr<Handler> handler) override {nextHandler = handler;}void handle(const std::string& request) override {if (nextHandler) {nextHandler->handle(request);}}
};class ConcreteHandlerA : public BaseHandler {
public:void handle(const std::string& request) override {if (request == "A") {std::cout << "ConcreteHandlerA handles request: " << request << std::endl;} else {BaseHandler::handle(request);}}
};class ConcreteHandlerB : public BaseHandler {
public:void handle(const std::string& request) override {if (request == "B") {std::cout << "ConcreteHandlerB handles request: " << request << std::endl;} else {BaseHandler::handle(request);}}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>();auto handlerB = std::make_shared<ConcreteHandlerB>();handlerA->setNext(handlerB);handlerA->handle("B");  // ConcreteHandlerB handles request: BhandlerA->handle("A");  // ConcreteHandlerA handles request: AhandlerA->handle("C");  // No handler can process Creturn 0;
}


2. 不纯责任链模式

在不纯责任链模式中,处理者可以部分处理请求,然后将请求传递给下一个处理者。

#include <iostream>
#include <memory>class Handler {
public:virtual ~Handler() = default;virtual void setNext(std::shared_ptr<Handler>) = 0;virtual void handle(const std::string& request) = 0;
};class BaseHandler : public Handler {
protected:std::shared_ptr<Handler> nextHandler;public:void setNext(std::shared_ptr<Handler> handler) override {nextHandler = handler;}void handle(const std::string& request) override {if (nextHandler) {nextHandler->handle(request);}}
};class ConcreteHandlerA : public BaseHandler {
public:void handle(const std::string& request) override {if (request == "A") {std::cout << "ConcreteHandlerA handles request: " << request << std::endl;} else {std::cout << "ConcreteHandlerA partially processes request: " << request << std::endl;BaseHandler::handle(request);}}
};class ConcreteHandlerB : public BaseHandler {
public:void handle(const std::string& request) override {if (request == "B") {std::cout << "ConcreteHandlerB handles request: " << request << std::endl;} else {std::cout << "ConcreteHandlerB partially processes request: " << request << std::endl;BaseHandler::handle(request);}}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>();auto handlerB = std::make_shared<ConcreteHandlerB>();handlerA->setNext(handlerB);handlerA->handle("B");  // ConcreteHandlerB handles request: BhandlerA->handle("A");  // ConcreteHandlerA handles request: AhandlerA->handle("C");  // ConcreteHandlerA partially processes request: C// ConcreteHandlerB partially processes request: Creturn 0;
}


3. 带中断的责任链模式

在带中断的责任链模式中,处理者可以在处理请求后决定是否中断链的传递。

#include <iostream>
#include <memory>class Handler {
public:virtual ~Handler() = default;virtual void setNext(std::shared_ptr<Handler>) = 0;virtual bool handle(const std::string& request) = 0;
};class BaseHandler : public Handler {
protected:std::shared_ptr<Handler> nextHandler;public:void setNext(std::shared_ptr<Handler> handler) override {nextHandler = handler;}bool handle(const std::string& request) override {if (nextHandler) {return nextHandler->handle(request);}return false;}
};class ConcreteHandlerA : public BaseHandler {
public:bool handle(const std::string& request) override {if (request == "A") {std::cout << "ConcreteHandlerA handles request: " << request << std::endl;return true;  // 中断链式传递}return BaseHandler::handle(request);}
};class ConcreteHandlerB : public BaseHandler {
public:bool handle(const std::string& request) override {if (request == "B") {std::cout << "ConcreteHandlerB handles request: " << request << std::endl;return true;  // 中断链式传递}return BaseHandler::handle(request);}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>();auto handlerB = std::make_shared<ConcreteHandlerB>();handlerA->setNext(handlerB);handlerA->handle("B");  // ConcreteHandlerB handles request: BhandlerA->handle("A");  // ConcreteHandlerA handles request: AhandlerA->handle("C");  // No handler can process Creturn 0;
}


4. 带优先级的责任链模式

在带优先级的责任链模式中,处理者根据优先级决定是否处理请求,优先级高的处理者先处理请求。

#include <iostream>
#include <memory>
#include <vector>
#include <algorithm>class Handler {
public:virtual ~Handler() = default;virtual int getPriority() const = 0;virtual void handle(const std::string& request) = 0;
};class BaseHandler : public Handler {
protected:int priority;public:BaseHandler(int p) : priority(p) {}int getPriority() const override {return priority;}void handle(const std::string& request) override {// 默认不处理}
};class ConcreteHandlerA : public BaseHandler {
public:ConcreteHandlerA(int p) : BaseHandler(p) {}void handle(const std::string& request) override {if (request == "A") {std::cout << "ConcreteHandlerA handles request: " << request << std::endl;}}
};class ConcreteHandlerB : public BaseHandler {
public:ConcreteHandlerB(int p) : BaseHandler(p) {}void handle(const std::string& request) override {if (request == "B") {std::cout << "ConcreteHandlerB handles request: " << request << std::endl;}}
};int main() {auto handlerA = std::make_shared<ConcreteHandlerA>(2);auto handlerB = std::make_shared<ConcreteHandlerB>(1);std::vector<std::shared_ptr<Handler>> handlers = {handlerA, handlerB};// 根据优先级排序std::sort(handlers.begin(), handlers.end(), [](const auto& h1, const auto& h2) {return h1->getPriority() > h2->getPriority();});for (const auto& handler : handlers) {handler->handle("B");  // ConcreteHandlerB handles request: Bhandler->handle("A");  // ConcreteHandlerA handles request: A}return 0;
}


总结

以上代码示例展示了责任链模式的四种不同变体:

  1. 纯责任链模式:处理者要么处理请求,要么传递请求。
  2. 不纯责任链模式:处理者可以部分处理请求并传递请求。
  3. 带中断的责任链模式:处理者可以中断链的传递。
  4. 带优先级的责任链模式:处理者根据优先级决定处理顺序。

这些变体可以根据具体需求灵活选择和实现,以满足不同场景下的功能需求。

基于责任链模式特点的软件架构模式

  1. 中间件架构:

    • 在Web开发中,中间件架构通常使用责任链模式来处理HTTP请求。每个中间件都可以对请求进行处理,然后决定是否将请求传递给下一个中间件。
    • 例如,Express.js中的中间件机制就是基于责任链模式实现的。
  2. 事件处理系统:

    • 在GUI编程中,事件处理系统通常使用责任链模式来处理用户事件。每个事件处理器可以处理事件,或者将事件传递给下一个处理器。
    • 例如,Java AWT/Swing中的事件处理机制就是基于责任链模式实现的。
  3. 工作流引擎:

    • 在工作流引擎中,责任链模式可以用于处理工作流中的各个步骤。每个步骤可以处理任务,或者将任务传递给下一个步骤。
    • 例如,Activiti等工作流引擎中的任务处理机制就是基于责任链模式实现的。
  4. 过滤器链:

    • 在Web应用中,过滤器链通常使用责任链模式来处理请求和响应。每个过滤器可以对请求或响应进行处理,然后将其传递给下一个过滤器。
    • 例如,Java Servlet中的过滤器机制就是基于责任链模式实现的。

总结

责任链模式通过将请求的发送者和接收者解耦,提供了一种灵活的方式来处理请求。它适用于多个对象可以处理同一请求的场景,并且可以通过不同的变体来满足不同的需求。基于责任链模式的特点,许多软件架构模式(如中间件架构、事件处理系统、工作流引擎和过滤器链)都采用了这种模式来实现灵活的处理机制。

http://www.lryc.cn/news/514579.html

相关文章:

  • 021-spring-springmvc-组件
  • 基于SpringBoot和OAuth2,实现通过Github授权登录应用
  • macos 支持外接高分辩率显示器开源控制软件
  • C++26 新特性预览(Preview)
  • MySQL5.7.26-Linux-安装(2024.12)
  • 2025-1-2-sklearn学习(30)模型选择与评估-验证曲线: 绘制分数以评估模型 真珠帘卷玉楼空,天淡银河垂地。
  • 【优选算法】查找总价格为目标值的两个商品
  • 利用 NineData 实现 PostgreSQL 到 Kafka 的高效数据同步
  • future和CompletableFuture
  • 如何通过深度学习提升大分辨率图像预测准确率?
  • 【机器学习】机器学习的基本分类-半监督学习-Ladder Networks
  • [react]小技巧, ts如何声明点击事件的类型
  • 智能工厂的设计软件 应用场景的一个例子:为AI聊天工具添加一个知识系统 之9 重新开始 之2
  • 【从零开始】11. LLaMA-Factory 微调 Qwen 模型(番外篇)
  • WPF使用ContentControl控件实现区域导航,并使用Prism依赖注入优化
  • JavaWeb——MySQL-DML(1/3)-添加数据insert(DML 操作概述、INSERT 语句插入数据、语句演示、总结)
  • 经验证:将数据从索尼传输到Android的 4 种方法
  • 嵌入式应用实例→电子产品量产工具→UI界面的绘制和测试
  • 如何删除 Docker 中的悬虚镜像?
  • el-table树形懒加载展开改为点击行展开
  • 【Ubuntu】Ubuntu server 18.04 搭建Slurm并行计算环境(包含NFS)
  • 高并发场景下的秒杀系统架构设计与实现
  • 搭建开源版Ceph分布式存储
  • QT----------多媒体
  • 选择器(结构伪类选择器,伪元素选择器),PxCook软件,盒子模型
  • Vue2/Vue3 响应式原理对比指南
  • FastExcel:超越EasyExcel的新一代Excel处理工具
  • 大模型系列17-RAGFlow搭建本地知识库
  • 常用的mac软件下载地址
  • 基于51单片机和16X16LED点阵屏(74HC138和74HC595驱动)的小游戏《贪吃蛇》