C++责任链模式实现多级请求处理

责任链模式通过解耦请求发送者与处理者，使多个对象有机会处理请求，提升系统灵活性和可扩展性；每个处理者持有后继引用，若无法处理则传递给下一个，直至被处理或到达链尾；其优势在于降低耦合、支持动态调整处理链，但可能因链过长或配置不当影响性能或导致请求未被处理。

C++责任链模式的核心在于将请求的发送者和处理者解耦，允许多个对象有机会处理请求。每个对象（称为处理者）都持有下一个处理者的引用，如果一个处理者不能处理该请求，它会将请求传递给链中的下一个处理者。

解决方案

以下是一个C++责任链模式的简单实现，用于处理不同优先级的请求：

#include 
#include 

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++免费学习笔记（深入）”；

责任链模式的主要优势在于降低了对象之间的耦合度。客户端不需要知道哪个对象会处理请求，只需要将请求发送到链的第一个处理者。此外，可以动态地添加或删除处理者，从而灵活地改变处理请求的流程。 这对维护和扩展系统很有帮助。

磁力开创

快手推出的一站式AI视频生产平台

下载

如何选择合适的处理者顺序？

处理者顺序的选择取决于具体的业务需求。通常，应该将最有可能处理请求的处理者放在链的前面，以提高处理效率。 也可以根据请求的复杂性或优先级来决定处理者顺序。例如，在上述示例中，优先级较低的请求可以先被处理，避免占用高优先级处理者的资源。

责任链模式有哪些潜在的缺点？

责任链模式的一个潜在缺点是，如果链配置不当，可能会导致请求无法被处理。例如，如果所有处理者都无法处理某个类型的请求，该请求将会一直传递到链的末端，最终被丢弃。此外，责任链模式可能会降低系统的性能，因为每个请求都需要遍历整个链。因此，在使用责任链模式时，需要仔细考虑处理者顺序和请求处理逻辑，以避免这些问题。