C++责任链模式请求处理

C++责任链模式请求处理

责任链模式将请求沿着处理器链传递，直到某个处理器处理它。这种模式解耦了请求发送者和接收者，适合日志记录、权限验证和事件过滤。

责任链包含处理器接口和具体处理器实现。

#include
#include
#include
#include

class Request {
std::string type_;
std::string content_;
int priority_;
public:
Request(const std::string& type, const std::string& content, int priority = 0)
: type_(type), content_(content), priority_(priority) {}

const std::string& type() const { return type_; }
const std::string& content() const { return content_; }
int priority() const { return priority_; }
};

class Handler {
protected:
std::unique_ptr next_;

public:
virtual ~Handler() = default;

Handler* set_next(std::unique_ptr handler) {
next_ = std::move(handler);
return this;
}

virtual void handle(const Request& request) {
if (next_) {
next_->handle(request);
}
}

virtual bool can_handle(const Request& request) const = 0;
};

class LogHandler : public Handler {
public:
bool can_handle(const Request& request) const override {
return request.type() == "LOG";
}

void handle(const Request& request) override {
if (can_handle(request)) {
std::cout << "[LOG] " << request.content() << "\n";
} else {
Handler::handle(request);
}
}
};

class AuthHandler : public Handler {
public:
bool can_handle(const Request& request) const override {
return request.type() == "AUTH";
}

void handle(const Request& request) override {
if (can_handle(request)) {
std::cout << "[AUTH] Validating: " << request.content() << "\n";
if (request.content().find("token=") != std::string::npos) {
std::cout << "[AUTH] Access granted\n";
} else {
std::cout << "[AUTH] Access denied\n";
}
} else {
Handler::handle(request);
}
}
};

class DataHandler : public Handler {
public:
bool can_handle(const Request& request) const override {
return request.type() == "DATA";
}

void handle(const Request& request) override {
if (can_handle(request)) {
std::cout << "[DATA] Processing: " << request.content() << "\n";
std::cout << "[DATA] Priority: " << request.priority() << "\n";
} else {
Handler::handle(request);
}
}
};

void chain_demo() {
auto chain = std::make_unique();
chain->set_next(std::make_unique())
->set_next(std::make_unique());

Request r1("LOG", "System startup");
Request r2("AUTH", "token=abc123");
Request r3("DATA", "Important payload", 5);
Request r4("UNKNOWN", "Test request");

chain->handle(r1);
chain->handle(r2);
chain->handle(r3);
chain->handle(r4);
}

通用责任链使用std::function。

class Filter {
std::function predicate_;
std::function action_;
std::unique_ptr next_;
public:
Filter(std::function pred,
std::function action)
: predicate_(std::move(pred)), action_(std::move(action)) {}

Filter* set_next(std::unique_ptr next) {
next_ = std::move(next);
return this;
}

void process(const std::string& data) {
if (predicate_(data)) {
action_(data);
} else if (next_) {
next_->process(data);
} else {
std::cout << "No handler for: " << data << "\n";
}
}
};

void functional_chain_demo() {
auto chain = std::make_unique(
[](const std::string& s) { return s.find("ERROR") != std::string::npos; },
[](const std::string& s) { std::cout << "Error handler: " << s << "\n"; }
);

chain->set_next(std::make_unique(
[](const std::string& s) { return s.find("WARN") != std::string::npos; },
[](const std::string& s) { std::cout << "Warning handler: " << s << "\n"; }
))->set_next(std::make_unique(
[](const std::string& s) { return s.find("INFO") != std::string::npos; },
[](const std::string& s) { std::cout << "Info handler: " << s << "\n"; }
));

chain->process("ERROR: Connection failed");
chain->process("WARN: Low memory");
chain->process("INFO: User logged in");
chain->process("DEBUG: Variable value");
}

责任链模式适合处理多层次、可动态配置的请求处理场景。