不得不说的行为型模式-责任链模式_责任链模式hasnext最后一个不执行-CSDN博客

本文链接：https://blog.csdn.net/clayhell/article/details/130438889

责任链模式：

责任链模式是一种行为型设计模式，它允许多个对象在一个请求序列中依次处理该请求，直到其中一个对象能够处理它为止。这些对象被组织成一条链，并且每个对象都有一个指向下一个对象的引用。

底层原理：

客户端将请求发送到责任链中的第一个对象。
如果该对象能够处理请求，则处理请求并返回结果。
如果该对象不能处理请求，则将请求传递给下一个对象。
重复此过程，直到找到能够处理请求的对象或责任链末尾。

代码案例：

下面是一个简单的 C++ 代码案例，以说明责任链模式的实现方式。假设我们正在处理一个简单的文本编辑器，需要实现一系列文本处理器来处理不同的文本格式。我们可以使用责任链模式来处理这些请求，以便让每个处理器能够处理它们自己能够处理的请求。

在上面的代码中，我们定义了一个 TextProcessor 接口，其中包含了一个 process 方法，它接受一个字符串作为输入，并将其处理。然后，我们定义了三个具体的文本处理器：PlainTextProcessor，HtmlTextProcessor 和 MarkdownProcessor。这些处理器都实现了 TextProcessor 接口，并且能够处理不同类型的文本格式。

HtmlTextProcessor 和 MarkdownProcessor 都有一个指向下一个处理器的指针，这样它们就可以将请求传递给下一个处理器。在每个处理器的 process 方法中，它会检查输入的文本是否符合该处理器所能处理的格式。如果是，它就处理该文本；否则，它就将该文本传递给下一个处理器，直到找到能够处理该文本的处理器为止。

在 main 函数中，我们定义了一个责任链，将 PlainTextProcessor、HtmlTextProcessor 和 MarkdownProcessor 链接在一起。然后，我们向该链中的第一个处理器发送三个不同的文本请求。第一个请求是普通文本，第二个请求是 HTML 格式的文本，第三个请求是 Markdown 格式的文本。我们可以看到，在每个请求中，只有能够处理该请求的处理器才会处理该请求，而其他处理器则将其传递给下一个处理器。

该代码的输出如下所示：

PlainTextProcessor: This is some plain text.
HtmlTextProcessor: <html><body><h1>This is an HTML document.</h1></body></html>
MarkdownProcessor: This is some **markdown** text.

可以看到，在第一个请求中，只有 PlainTextProcessor 能够处理该请求，因此它处理了该请求。在第二个请求中，只有 HtmlTextProcessor 能够处理该请求，因此它处理了该请求。在第三个请求中，只有 MarkdownProcessor 能够处理该请求，因此它处理了该请求。

这个例子展示了责任链模式的基本实现方式。责任链模式可以帮助我们实现解耦和灵活性，因为它允许我们在运行时动态地组合和分离对象。

下面是面试中可能遇到的问题：

什么是责任链模式？它有什么作用？
在责任链模式中，处理器之间的连接是怎样的？怎样才能保证处理器按照正确的顺序被调用？
责任链模式中的处理器都有哪些角色？它们是如何协同工作的？
责任链模式有哪些优点和缺点？你能够举例说明吗？

可以先自己思考一下，看参考答案是不是和你想的一样哦=v=~

可能的答案如下：

缺点：

责任链模式是一种行为型模式，它允许我们将多个处理器链接在一起，形成一个处理器链。当一个请求从链的一端进入时，处理器链会依次尝试处理该请求，直到找到能够处理该请求的处理器为止。责任链模式的作用是解耦请求发送者和接收者之间的关系，使系统更加灵活。
在责任链模式中，处理器之间的连接是一条链式结构。每个处理器都有一个指向下一个处理器的指针。为了保证处理器按照正确的顺序被调用，需要将处理器按照一定的顺序链接在一起。一般来说，这个顺序应该是从最具体的处理器开始，依次向上层抽象处理器链接。当请求进入责任链时，它会从链的第一个处理器开始，依次向下传递，直到找到能够处理该请求的处理器为止。
在责任链模式中，处理器一般分为两种角色：具体处理器和抽象处理器。具体处理器是责任链中最底层的处理器，它们负责处理请求，并决定是否将请求传递给下一个处理器。抽象处理器是一个接口或抽象类，它定义了处理器的共同接口，并保存了下一个处理器的指针。在链中的任何一个处理器都可以通过它的接口来发送请求，并将请求传递给下一个处理器。

责任链模式的优点包括：可以动态地组合和分离对象；可以使系统更加灵活；可以避免将请求发送者和接收者之间的关系硬编码在一起。其缺点包括：由于每个请求都要在责任链中传递，因此可能会对性能产生一定的影响；在处理器链过长或者没有正确设置链中处理器的顺序时，可能会导致请求不能被正确处理。例如，一个简单的应用场景是文本处理，不同的文本处理器可以根据文本

的类型和需求被组合成一个处理器链，实现文本处理的功能。

一个可能的C++代码案例如下：

#include <iostream>
#include <string>

// 抽象处理器
class Handler {
public:
    Handler(Handler* successor) : successor_(successor) {}
    virtual ~Handler() {}

    // 处理请求的虚函数
    virtual void handleRequest(const std::string& request) {
        if (successor_) {
            successor_->handleRequest(request);
        }
    }

protected:
    Handler* successor_;
};

// 具体处理器 A
class ConcreteHandlerA : public Handler {
public:
    ConcreteHandlerA(Handler* successor) : Handler(successor) {}

    virtual void handleRequest(const std::string& request) override {
        if (request == "A") {
            std::cout << "ConcreteHandlerA handles the request." << std::endl;
        }
        else {
            Handler::handleRequest(request);
        }
    }
};

// 具体处理器 B
class ConcreteHandlerB : public Handler {
public:
    ConcreteHandlerB(Handler* successor) : Handler(successor) {}

    virtual void handleRequest(const std::string& request) override {
        if (request == "B") {
            std::cout << "ConcreteHandlerB handles the request." << std::endl;
        }
        else {
            Handler::handleRequest(request);
        }
    }
};

// 具体处理器 C
class ConcreteHandlerC : public Handler {
public:
    ConcreteHandlerC(Handler* successor) : Handler(successor) {}

    virtual void handleRequest(const std::string& request) override {
        if (request == "C") {
            std::cout << "ConcreteHandlerC handles the request." << std::endl;
        }
        else {
            Handler::handleRequest(request);
        }
    }
};

// 客户端代码
int main() {
    ConcreteHandlerA handlerA(nullptr);
    ConcreteHandlerB handlerB(&handlerA);
    ConcreteHandlerC handlerC(&handlerB);

    // 将请求依次发送给责任链的第一个处理器
    handlerC.handleRequest("A");
    handlerC.handleRequest("B");
    handlerC.handleRequest("C");
    handlerC.handleRequest("D");

    return 0;
}

在这个代码案例中，Handler 是抽象处理器，定义了所有处理器都应该有的接口。具体处理器 ConcreteHandlerA、ConcreteHandlerB 和 ConcreteHandlerC 继承了 Handler 接口，并实现了各自的处理逻辑。

在客户端代码中，首先创建了三个具体处理器，并将它们依次链接在一起，形成一个处理器链。然后将请求依次发送给责任链的第一个处理器，让处理器链依次尝试处理该请求。

当请求为 A 时，ConcreteHandlerA 可以处理该请求，因此它会输出相应的处理信息。当请求为 B 时，ConcreteHandlerB 可以处理该请求，因此它会输出相应的处理信息。当请求为 C 时，ConcreteHandlerC 可以处理该请求，因此它会输出相应的处理信息。当请求为 D 时，处理器链上的任何一个处理器都不能处理该请求，因此它不会输出任何处理信息

5责任链模式的优缺点如下：

优点：

将请求的发送者和接收者解耦。请求发送者无需知道哪个接收者能够处理该请求，接收者也无需知道请求的发送者是谁，以及该请求是从哪个接收者发出的。
可以动态的添加或删除处理器，因此责任链模式具有很好的灵活性和可扩展性。
由于请求可能需要经过多个处理器才能被处理，因此责任链模式的处理过程可能会比较缓慢。
对于长的责任链，请求可能会遍历整个责任链才能被处理，这可能会带来一些性能问题。
对于一些请求，如果没有任何一个处理器能够处理该请求，那么该请求就会被“吞掉”，导致该请求无法得到处理。
- 责任链模式可以使得系统更加符合单一职责原则。每个具体处理器只负责处理与自己相关的请求，从而将复杂的业务逻辑拆分成多个小的处理器，让每个处理器聚焦于自己的领域，更加清晰明了。