行为型模式-责任链模式

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者与接收者之间的耦合。将这些对象连成一条链，并沿着这条链传递请求，直到某个对象处理它为止。

核心思想

请求的发送者不需要指定具体的接收者。

请求沿着链条传递，每个处理者根据自身的逻辑决定是否处理请求。

如果某个处理者无法处理，则传递给下一个处理者。

结构

责任链模式通常包含以下角色：

Handler（处理者接口/抽象类）：
定义处理请求的方法 handleRequest。

持有对下一个处理者的引用。
ConcreteHandler（具体处理者）：

实现具体的请求处理逻辑。

判断是否处理请求，如果不处理则将请求传递给下一个处理者。
Client（客户端）：

创建链条，并发送请求。

优缺点

优点
降低耦合度：请求的发送者和处理者解耦。
灵活性：可以通过调整链条顺序、动态添加/移除处理者来改变责任的分配。
扩展性好：增加新的处理者不会影响现有代码。
缺点
链条过长：如果链条过长，处理可能会影响性能。
调试困难：链条中的问题可能难以排查。

实现示例

java 复制代码

// 抽象处理者
abstract class Handler {
    protected Handler next; // 下一个处理者

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

    // 处理请求的方法
    public abstract void handleRequest(int request);
}

// 具体处理者A
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("HandlerA 处理请求：" + request);
        } else if (next != null) {
            next.handleRequest(request); // 转发请求
        }
    }
}

// 具体处理者B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("HandlerB 处理请求：" + request);
        } else if (next != null) {
            next.handleRequest(request); // 转发请求
        }
    }
}

// 具体处理者C
class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 20) {
            System.out.println("HandlerC 处理请求：" + request);
        } else if (next != null) {
            next.handleRequest(request); // 转发请求
        }
    }
}

// 客户端
public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        // 创建处理者
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        // 构建链条 A -> B -> C
        handlerA.setNext(handlerB);
        handlerB.setNext(handlerC);

        // 测试请求
        int[] requests = {5, 14, 22, 8};
        for (int request : requests) {
            handlerA.handleRequest(request);
        }
    }
}

适用场景

多个对象可以处理同一请求：请求的处理者动态决定。
需要动态指定处理顺序：处理者之间可以灵活地增删改。
避免强耦合：客户端和具体处理者解耦。

这种模式非常适合用于审批流程、日志处理、职责划分等场景。