C++开发之责任链模式
一、责任链模式概述
定义
责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许多个对象都有机会处理请求，从而避免请求发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有对象处理它为止。
核心思想
二、C++中的典型使用场景
场景1：事件处理系统（GUI框架）
同上；
场景2：日志系统（多级别日志）
// 示例：鼠标点击事件传递
class UIComponent {
protected:UIComponent* parent;
public:virtual bool handleClick(int x, int y) {if (parent) return parent->handleClick(x, y);return false;}
};class Button : public UIComponent {bool handleClick(int x, int y) override {if (isInside(x, y)) {onClick();return true; // 处理完成}return UIComponent::handleClick(x, y); // 传递给父组件}
};场景3：异常处理（多层异常捕获）
class Logger {
protected:std::shared_ptr<Logger> next;LogLevel level;public:void setNext(std::shared_ptr<Logger> nextLogger) {next = nextLogger;}void log(LogLevel msgLevel, const std::string& msg) {if (msgLevel >= level) {write(msg);}if (next) {next->log(msgLevel, msg);}}virtual void write(const std::string& msg) = 0;
};class ConsoleLogger : public Logger {void write(const std::string& msg) override {std::cout << "[CONSOLE] " << msg << std::endl;}
};class FileLogger : public Logger {void write(const std::string& msg) override {// 写入文件}
};场景4：权限验证（多级权限检查）
class ExceptionHandler {
protected:std::shared_ptr<ExceptionHandler> next;public:void setNext(std::shared_ptr<ExceptionHandler> handler) {next = handler;}virtual bool handle(const std::exception& e) {if (canHandle(e)) {process(e);return true;}if (next) return next->handle(e);return false;}virtual bool canHandle(const std::exception& e) = 0;virtual void process(const std::exception& e) = 0;
};场景5：请求过滤器（Web中间件）
class AuthHandler {
protected:std::shared_ptr<AuthHandler> next;public:void setNext(std::shared_ptr<AuthHandler> handler) {next = handler;}bool authorize(const User& user, const Resource& resource) {if (check(user, resource)) {return true;}if (next) {return next->authorize(user, resource);}return false;}virtual bool check(const User& user, const Resource& resource) = 0;
};class AdminAuthHandler : public AuthHandler {bool check(const User& user, const Resource& resource) override {return user.role == Role::Admin;}
};class OwnerAuthHandler : public AuthHandler {bool check(const User& user, const Resource& resource) override {return resource.owner_id == user.id;}
};场景6：功率调度系统（现有代码中的实例） ⭐
class RequestFilter {
protected:std::shared_ptr<RequestFilter> next;public:void setNext(std::shared_ptr<RequestFilter> filter) {next = filter;}virtual Response process(const Request& req) {// 前置处理preProcess(req);// 传递给下一个Response resp;if (next) {resp = next->process(req);}// 后置处理postProcess(resp);return resp;}virtual void preProcess(const Request& req) = 0;virtual void postProcess(Response& resp) = 0;
};三、如何使用责任链模式
实现方式1：链式传递（现有代码使用的方式）
// 现有代码中的责任链实现
class Strategy {
protected:std::shared_ptr<Strategy> _next_successor;public:void SetNextSuccessor(const std::shared_ptr<Strategy>& successor) {_next_successor = successor;}virtual void RunStrategy() = 0; // 纯虚函数
};实现方式2：返回值控制（更灵活）
// 基类
class Strategy {
protected:std::shared_ptr<Strategy> _next_successor;public:void SetNextSuccessor(const std::shared_ptr<Strategy>& successor) {_next_successor = successor;}virtual void RunStrategy() = 0;
};// 具体处理器1
class AddPQDischarge : public Strategy {
public:void RunStrategy() override {// 判断是否能处理if (can_handle_by_pq_discharge()) {// 处理逻辑execute_pq_discharge();} else {// 传递给下一个if (_next_successor) {_next_successor->RunStrategy();}}}private:bool can_handle_by_pq_discharge() {return !(*pv_p_up + *charging_ev_p_down + *discharging_ev_p_up + *pq_bat_p_up + *load_p + *vf_bat_p_eco > 0);}void execute_pq_discharge() {*pv_p_set = *pv_p_up;*pq_bat_p_set = calculate_discharge_power();// ... 其他设置}
};// 具体处理器2
class ReduceEvCharge : public Strategy {
public:void RunStrategy() override {// 直接处理，不再传递execute_reduce_ev_charge();}private:void execute_reduce_ev_charge() {*charging_ev_p_set = calculate_reduced_charge();*limit_charging_ev = 1;// ... 其他设置}
};// 使用方式
void setup_chain() {auto handler1 = std::make_shared<AddPQDischarge>();auto handler2 = std::make_shared<ReduceEvCharge>();// 建立链条handler1->SetNextSuccessor(handler2);// 启动处理handler1->RunStrategy();
}实现方式3：中间件模式（双向处理）
class Handler {
protected:std::shared_ptr<Handler> next;public:void setNext(std::shared_ptr<Handler> nextHandler) {next = nextHandler;}// 返回true表示已处理，false表示未处理bool handle(const Request& req) {if (canHandle(req)) {process(req);return true; // 处理成功，停止链}// 传递给下一个if (next) {return next->handle(req);}return false; // 链末端仍未处理}virtual bool canHandle(const Request& req) = 0;virtual void process(const Request& req) = 0;
};四、现有代码中的责任链实例分析
代码结构
构建链条
class Middleware {
protected:std::shared_ptr<Middleware> next;public:void setNext(std::shared_ptr<Middleware> middleware) {next = middleware;}Response execute(const Request& req) {// 前置处理before(req);// 调用下一个Response resp;if (next) {resp = next->execute(req);} else {resp = defaultResponse(req);}// 后置处理after(resp);return resp;}virtual void before(const Request& req) = 0;virtual void after(Response& resp) = 0;virtual Response defaultResponse(const Request& req) = 0;
};使用链条
graph LRsubgraph "功率过剩链"A1[AddPQDischarge] -->|无法处理| A2[ReduceEvCharge]endsubgraph "功率不足链"B1[AddPQCharge] -->|无法处理| B2[ReduceEvDischarge]B2 -->|无法处理| B3[ReducePv]endsubgraph "功率平衡"C1[VFRunEco]endEntry[OffgridSTC] --> Decision{功率判断}Decision -->|过剩| A1Decision -->|平衡| C1Decision -->|不足| B1style A1 fill:#FFE4B5style A2 fill:#FFCCBCstyle B1 fill:#E4F5FFstyle B2 fill:#C8E6FFstyle B3 fill:#B2DFDB链内传递
_addpqdischarge_ptr->SetNextSuccessor(_reduceevcharge_ptr);_addpqcharge_ptr->SetNextSuccessor(_reduceevdischarge_ptr);_reduceevdischarge_ptr->SetNextSuccessor(_reducepv_ptr);五、责任链模式 vs 其他模式
对比表格
| 特性 | 责任链模式 | 策略模式 | 状态模式 | 命令模式 |
|---|---|---|---|---|
| 目的 | 解耦请求发送者和接收者 | 封装算法族 | 封装状态转换 | 封装请求为对象 |
| 结构 | 链式结构 | 平行结构 | 状态图结构 | 命令队列 |
| 选择方式 | 自动传递 | 客户端选择 | 状态驱动 | 调用者执行 |
| 扩展性 | ⭐⭐⭐⭐⭐ 优秀 | ⭐⭐⭐⭐ 良好 | ⭐⭐⭐ 一般 | ⭐⭐⭐⭐ 良好 |
| 复杂度 | ⭐⭐⭐ 中等 | ⭐⭐ 简单 | ⭐⭐⭐⭐ 较复杂 | ⭐⭐⭐ 中等 |
| 运行时修改 | ✅ 可以 | ✅ 可以 | ✅ 可以 | ✅ 可以 |
| 处理顺序 | 固定链式 | 单一选择 | 状态转换 | 队列顺序 |