设计模式（15）-责任链模式及实现

设计模式（15）-责任链模式及实现

---

基本概念

通过一系列处理对象来处理请求的方法。每个处理对象都包含一个对下一个处理对象的引用，形成一个链式结构。当一个请求到达时，它首先被传递给链中的第一个处理对象，如果该对象不能处理该请求，它会将请求传递给下一个处理对象，依此类推，直到找到能够处理请求的对象为止。
优点：
● 降低耦合度：发送者不需要知道哪个对象会处理请求，只需将请求发送到链的起始点。
● 灵活性：可以根据需要动态地改变处理链中处理者的顺序，以及每个处理者的职责。
● 可扩展性：可以很容易地添加新的处理者，而不会影响现有代码。
● 可维护性：每个处理者关注单一的责任，使得代码更易于理解和维护。
缺点：
责任链模式也有一些潜在的限制，比如可能导致请求无法被处理或者处理链太长而导致性能问题。因此，在使用责任链模式时需要谨慎权衡权衡利弊。

https://gitee.com/want-to-lose-another-30-jin/design-pattern-implementation

设计模式具体实现

---

角色

1、处理者（Handler）：
定义了处理请求的接口，所有具体处理者都实现这个接口。

2、具体处理者（Concrete Handler）：
实现了处理者接口，负责处理它所负责的请求，并且决定是否将请求传递给链中的下一个处理者。

java实现

package shejimoshi.zerenlianmoshi;
//请求
public class Request {
    private String type;

    public Request(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }
}

package shejimoshi.zerenlianmoshi;
// 处理者接口
public interface Handler {
    void setNext(Handler next);
    void handleRequest(Request request);
}

package shejimoshi.zerenlianmoshi;
// 具体处理者
public abstract class AbstractHandler implements Handler {
    protected Handler next;

    @Override
    public void setNext(Handler next) {
        this.next = next;
    }

    public abstract void handleRequest(Request request);
}

package shejimoshi.zerenlianmoshi;
// 具体处理者实现1
public class ConcreteHandler1 extends AbstractHandler {
    @Override
    public void handleRequest(Request request) {
        if (canHandle(request)) {
            System.out.println("ConcreteHandler1 handled the request for type " + request.getType());
        } else if (next != null) {
            next.handleRequest(request);
        } else {
            System.out.println("No handler found for request type " + request.getType());
        }
    }

    private boolean canHandle(Request request) {
        return "A".equals(request.getType());
    }
}

package shejimoshi.zerenlianmoshi;
// 具体处理者实现2
public class ConcreteHandler2 extends AbstractHandler {
    @Override
    public void handleRequest(Request request) {
        if (canHandle(request)) {
            System.out.println("ConcreteHandler2 handled the request for type " + request.getType());
        } else if (next != null) {
            next.handleRequest(request);
        } else {
            System.out.println("No handler found for request type " + request.getType());
        }
    }

    private boolean canHandle(Request request) {
        return "B".equals(request.getType());
    }
}

package shejimoshi.zerenlianmoshi;

public class client {
    public static void main(String[] args) {
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();

        handler1.setNext(handler2); // 创建责任链

        Request request1 = new Request("A");
        handler1.handleRequest(request1); // 由 ConcreteHandler1 处理

        Request request2 = new Request("B");
        handler1.handleRequest(request2); // 由 ConcreteHandler2 处理

        Request request3 = new Request("C");
        handler1.handleRequest(request3); // 没有处理者处理，打印未找到处理者的消息
    }
}

c++实现

#include<iostream>
#include <iostream>
#include <string>

// 请求
class Request {
private:
    std::string type;

public:
    Request(const std::string& type) : type(type) {}

    std::string getType() const {
        return type;
    }
};

// 处理者接口
class Handler {
public:
    virtual ~Handler() {}
    virtual void handleRequest(Request& request) = 0;
    virtual void setNext(Handler* next) = 0;
};

// 具体处理者
class ConcreteHandler1 : public Handler {
private:
    Handler* next;

public:
    ConcreteHandler1() : next(nullptr) {}
    ~ConcreteHandler1() {}

    void handleRequest(Request& request) override {
        if (canHandle(request)) {
            std::cout << "ConcreteHandler1 handled the request." << std::endl;
        }
        else if (next != nullptr) {
            next->handleRequest(request);
        }
    }

    void setNext(Handler* next) override {
        this->next = next;
    }

private:
    bool canHandle(Request& request) const {
        return request.getType() == "A";
    }
};

// 另一个具体处理者
class ConcreteHandler2 : public Handler {
private:
    Handler* next;

public:
    ConcreteHandler2() : next(nullptr) {}
    ~ConcreteHandler2() {}

    void handleRequest(Request& request) override {
        if (canHandle(request)) {
            std::cout << "ConcreteHandler2 handled the request." << std::endl;
        }
        else if (next != nullptr) {
            next->handleRequest(request);
        }
    }

    void setNext(Handler* next) override {
        this->next = next;
    }

private:
    bool canHandle(Request& request) const {
        return request.getType() == "B";
    }
};

// 客户端
int main() {
    Handler* handler1 = new ConcreteHandler1();
    Handler* handler2 = new ConcreteHandler2();

    handler1->setNext(handler2); // 创建责任链

    Request request1("A");
    handler1->handleRequest(request1);

    Request request2("B");
    handler1->handleRequest(request2);

    // 清理分配的内存
    delete handler1;
    delete handler2;

    return 0;
}