责任链模式通过解耦请求发送者与处理者，使多个对象有机会处理请求，提升系统灵活性和可扩展性；每个处理者持有后继引用，若无法处理则传递给下一个，直至被处理或到达链尾；其优势在于降低耦合、支持动态调整处理链，但可能因链过长或配置不当影响性能或导致请求未被处理。
C++责任链模式的核心在于将请求的发送者和处理者解耦，允许多个对象有机会处理请求。每个对象（称为处理者）都持有下一个处理者的引用，如果一个处理者不能处理该请求，它会将请求传递给链中的下一个处理者。
解决方案
以下是一个C++责任链模式的简单实现，用于处理不同优先级的请求：
#include <iostream>
#include <string>
class Request {
public:
enum Priority {
LOW,
MEDIUM,
HIGH
};
Request(std::string description, Priority priority) : description_(description), priority_(priority) {}
std::string getDescription() const { return description_; }
Priority getPriority() const { return priority_; }
private:
std::string description_;
Priority priority_;
};
class Handler {
public:
Handler() : nextHandler_(nullptr) {}
virtual ~Handler() {}
void setNext(Handler* next) {
nextHandler_ = next;
}
virtual void handleRequest(Request& request) {
if (nextHandler_) {
nextHandler_->handleRequest(request);
} else {
std::cout << "End of chain reached. Request cannot be handled." << std::endl;
}
}
protected:
Handler* nextHandler_;
};
class LowPriorityHandler : public Handler {
public:
void handleRequest(Request& request) override {
if (request.getPriority() == Request::Priority::LOW) {
std::cout << "LowPriorityHandler handled request: " << request.getDescription() << std::endl;
} else {
std::cout << "LowPriorityHandler cannot handle request, passing to next handler." << std::endl;
Handler::handleRequest(request);
}
}
};
class MediumPriorityHandler : public Handler {
public:
void handleRequest(Request& request) override {
if (request.getPriority() == Request::Priority::MEDIUM) {
std::cout << "MediumPriorityHandler handled request: " << request.getDescription() << std::endl;
} else {
std::cout << "MediumPriorityHandler cannot handle request, passing to next handler." << std::endl;
Handler::handleRequest(request);
}
}
};
class HighPriorityHandler : public Handler {
public:
void handleRequest(Request& request) override {
if (request.getPriority() == Request::Priority::HIGH) {
std::cout << "HighPriorityHandler handled request: " << request.getDescription() << std::endl;
} else {
std::cout << "HighPriorityHandler cannot handle request, passing to next handler." << std::endl;
Handler::handleRequest(request);
}
}
};
int main() {
LowPriorityHandler lowHandler;
MediumPriorityHandler mediumHandler;
HighPriorityHandler highHandler;
lowHandler.setNext(&mediumHandler);
mediumHandler.setNext(&highHandler);
Request lowRequest("Fix a minor typo", Request::Priority::LOW);
Request mediumRequest("Update documentation", Request::Priority::MEDIUM);
Request highRequest("Server is down!", Request::Priority::HIGH);
Request unhandledRequest("Unknown issue", Request::Priority::LOW);
lowHandler.handleRequest(lowRequest);
lowHandler.handleRequest(mediumRequest);
lowHandler.handleRequest(highRequest);
//Demonstrates what happens if no handler can handle a request. We'll change the priority of the unhandledRequest
//and send it down the chain.
//unhandledRequest = Request("Unknown issue", Request::Priority::HIGH); //now a high priority request.
//lowHandler.handleRequest(unhandledRequest);
return 0;
}责任链模式的优势是什么？
立即学习“C++免费学习笔记（深入）”；
责任链模式的主要优势在于降低了对象之间的耦合度。客户端不需要知道哪个对象会处理请求，只需要将请求发送到链的第一个处理者。此外，可以动态地添加或删除处理者，从而灵活地改变处理请求的流程。 这对维护和扩展系统很有帮助。
如何选择合适的处理者顺序？
处理者顺序的选择取决于具体的业务需求。通常，应该将最有可能处理请求的处理者放在链的前面，以提高处理效率。 也可以根据请求的复杂性或优先级来决定处理者顺序。例如，在上述示例中，优先级较低的请求可以先被处理，避免占用高优先级处理者的资源。
责任链模式有哪些潜在的缺点？
责任链模式的一个潜在缺点是，如果链配置不当，可能会导致请求无法被处理。例如，如果所有处理者都无法处理某个类型的请求，该请求将会一直传递到链的末端，最终被丢弃。此外，责任链模式可能会降低系统的性能，因为每个请求都需要遍历整个链。因此，在使用责任链模式时，需要仔细考虑处理者顺序和请求处理逻辑，以避免这些问题。
