C++ 设计模式-责任链模式

模拟网络请求处理管道，包含动态处理器注册、请求修改和条件传递等特性：

cpp 复制代码

#include <iostream>
#include <memory>
#include <vector>
#include <string>

// 请求上下文，包含可修改的状态
struct RequestContext {
    std::string headers;
    std::string body;
    bool processed = false;
    int statusCode = 0;
};

// 抽象处理器接口
class RequestHandler {
public:
    virtual ~RequestHandler() = default;
    virtual void handle(RequestContext& context) = 0;
    virtual bool canHandle(const RequestContext& context) const = 0;
};

// 处理器链管理器
class ProcessingPipeline {
    std::vector<std::unique_ptr<RequestHandler>> handlers_;
    std::unique_ptr<RequestHandler> fallback_;

public:
    void addHandler(std::unique_ptr<RequestHandler> handler) {
        handlers_.emplace_back(std::move(handler));
    }

    void setFallbackHandler(std::unique_ptr<RequestHandler> handler) {
        fallback_ = std::move(handler);
    }

    void execute(RequestContext& context) {
        for (auto& handler : handlers_) {
            if (handler->canHandle(context)) {
                handler->handle(context);
                if (context.processed) return;
            }
        }

        if (fallback_) {
            fallback_->handle(context);
        } else {
            std::cerr << "No handler available for request\n";
            context.statusCode = 500;
        }
    }
};

// 具体处理器：认证验证
class AuthenticationHandler : public RequestHandler {
    bool canHandle(const RequestContext& context) const override {
        return context.headers.find("Authorization") != std::string::npos;
    }

    void handle(RequestContext& context) override {
        std::cout << "Validating authentication token...\n";
        // 模拟验证逻辑
        if (context.headers.find("Bearer valid") != std::string::npos) {
            std::cout << "Authentication successful\n";
        } else {
            context.statusCode = 401;
            context.processed = true;
        }
    }
};

// 具体处理器：负载解析
class PayloadParserHandler : public RequestHandler {
    bool canHandle(const RequestContext& context) const override {
        return !context.body.empty() && context.statusCode == 0;
    }

    void handle(RequestContext& context) override {
        std::cout << "Parsing request payload...\n";
        // 解析逻辑...
        context.headers += "\nContent-Type: application/json";
    }
};

// 具体处理器：响应生成
class ResponseGeneratorHandler : public RequestHandler {
    bool canHandle(const RequestContext& context) const override {
        return context.statusCode == 0 && !context.body.empty();
    }

    void handle(RequestContext& context) override {
        std::cout << "Generating response...\n";
        context.statusCode = 200;
        context.processed = true;
    }
};

// 回退处理器
class FallbackHandler : public RequestHandler {
    bool canHandle(const RequestContext&) const override { return true; }
    
    void handle(RequestContext& context) override {
        context.statusCode = 404;
        context.processed = true;
        std::cout << "No suitable handler found\n";
    }
};

int main() {
    ProcessingPipeline pipeline;
    
    pipeline.addHandler(std::make_unique<AuthenticationHandler>());
    pipeline.addHandler(std::make_unique<PayloadParserHandler>());
    pipeline.addHandler(std::make_unique<ResponseGeneratorHandler>());
    pipeline.setFallbackHandler(std::make_unique<FallbackHandler>());

    // 测试用例1：有效请求
    {
        RequestContext validRequest;
        validRequest.headers = "Authorization: Bearer valid";
        validRequest.body = R"({"data":"example"})";
        
        pipeline.execute(validRequest);
        std::cout << "Test1 Status: " << validRequest.statusCode << "\n\n";
    }

    // 测试用例2：无效认证
    {
        RequestContext invalidAuth;
        invalidAuth.headers = "Authorization: Bearer invalid";
        
        pipeline.execute(invalidAuth);
        std::cout << "Test2 Status: " << invalidAuth.statusCode << "\n\n";
    }

    // 测试用例3：未知请求类型
    {
        RequestContext unknownRequest;
        unknownRequest.body = "unstructured data";
        
        pipeline.execute(unknownRequest);
        std::cout << "Test3 Status: " << unknownRequest.statusCode << "\n";
    }

    return 0;
}

该实现包含以下高级特性：

智能处理器选择：

每个处理器通过canHandle方法声明处理能力
处理器链自动选择符合条件的处理器执行
支持提前终止处理流程（通过context.processed标志）

动态管道管理：

使用ProcessingPipeline类管理处理器生命周期
支持运行时动态添加处理器
提供回退处理器处理未匹配情况

上下文状态管理：

RequestContext携带处理状态并在处理器间传递
处理器可以修改上下文内容（如添加headers）
状态码和processed标志控制流程走向

多重处理策略：

认证处理器执行验证并可能终止流程
负载处理器执行数据转换
响应生成器处理成功案例
回退处理器处理边缘情况

扩展性设计：

符合开闭原则（新增处理器无需修改现有代码）
处理器之间完全解耦
支持多种组合方式和执行策略

示例输出：

复制代码

Validating authentication token...
Authentication successful
Parsing request payload...
Generating response...
Test1 Status: 200

Validating authentication token...
Test2 Status: 401

Parsing request payload...
Generating response...
Test3 Status: 200

该实现展示了责任链模式在以下场景的适用性：

需要动态处理顺序的请求管道
复杂的分支处理逻辑
需要灵活组合处理组件的系统
需要渐进式请求处理的Web中间件
业务规则复杂的审批系统

通过这种设计，可以轻松实现以下扩展：

添加新的处理器类型（如日志记录、缓存处理）
实现处理器优先级系统
添加异步处理支持
实现处理器性能监控
支持条件分支管道