行为型模式之责任链模式

责任链模式（Chain of Responsibility Pattern）

定义一个抽象处理者（Handler）类，其中包含一个指向下一个处理者的引用。

每个具体处理者（ConcreteHandler）类继承自抽象处理者类，并实现其处理请求的方法。在处理请求时，

如果能够处理，则直接处理；否则将请求传递给下一个处理者。

请求从第一个具体处理者开始，沿着责任链依次传递，直到有某个处理者能够处理或者到达责任链的末端。
优点：

解耦发送者和接收者：发送者不需要知道具体的接收者，只需要将请求发送给责任链的第一个处理者即可。

灵活性和可扩展性：可以动态地增加、删除或修改处理者，而不影响其他处理者的工作。

可以按需处理请求：每个处理者都有机会处理请求，可以根据业务需求决定是否进行处理。
适用场景：

有多个对象可以处理同一请求，但具体处理者在运行时可确定。

需要动态指定处理请求的对象，或者按顺序依次处理请求。

请求的发送者和接收者应该解耦，避免耦合关系过于复杂。

需要注意的是，责任链模式并不保证请求一定会被处理，可能存在请求无法被处理的情况。

在设计时需要合理地安排责任链的顺序和处理逻辑，以确保能够正确地处理请求。

提供demo版代码更容易理解

java 复制代码

/**
 * @author zhou
 *  具体处理者A
 */
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 0 && request < 10) {
            System.out.println("ConcreteHandlerA 处理请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

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

/**
 * @author zhou
 *  具体处理者C
 */
class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 20 && request < 30) {
            System.out.println("ConcreteHandlerC 处理请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

/**
 * @author zhou
 *  抽象处理者
 */
abstract class Handler {
    protected Handler nextHandler; // 下一个处理者

    public void setNextHandler(Handler handler) {
        this.nextHandler = handler;
    }

    public abstract void handleRequest(int request);
}

/**
 * @author zhou
 *  客户端使用
 */
public class ChainOfResponsibilityPattern {
    public static void main(String[] args) {
        // 创建具体处理者对象
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        // 设置责任链关系
        handlerA.setNextHandler(handlerB);
        handlerB.setNextHandler(handlerC);

        // 发起请求
        int[] requests = {5, 15, 25};
        for (int request : requests) {
            handlerA.handleRequest(request);
        }
    }
}

在这个示例中，我们创建了三个具体处理者（ConcreteHandlerA、ConcreteHandlerB、ConcreteHandlerC），每个处理者都有自己的处理逻辑。

通过设置处理者的nextHandler属性，将它们连接成一个责任链。
当发起请求时，请求会从责任链的第一个处理者（ConcreteHandlerA）开始进行处理。如果当前处理者能够处理该请求，则直接处理；

否则将请求传递给下一个处理者，直到找到能够处理请求的处理者，或者到达责任链的末端。
在上述示例中，请求分别是5、15和25，根据具体处理者的处理范围不同，分别由ConcreteHandlerA、ConcreteHandlerB和ConcreteHandlerC进行处理。

如果请求超过所有处理者的处理范围，将不被任何处理者处理。