设计模式 – 责任链模式（Chain of Responsibility Pattern）

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它为请求创建了一个接收者对象的链。这个链上的每个接收者都包含对其他接收者的引用。当请求沿着链传递时，每个接收者要么处理请求，要么将其传递给链上的下一个接收者。这有助于将发送请求的对象与处理请求的对象解耦。

Java 示例代码：

首先，我们创建一个抽象处理者类，包含对下一个处理者的引用：

public abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(String request);
}

接下来，我们创建具体的处理者类：

public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("A".equals(request)) {
            System.out.println("ConcreteHandlerA handled the request.");
        } else {
            System.out.println("ConcreteHandlerA cannot handle the request, passing to the next handler.");
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            }
        }
    }
}

public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("B".equals(request)) {
            System.out.println("ConcreteHandlerB handled the request.");
        } else {
            System.out.println("ConcreteHandlerB cannot handle the request, passing to the next handler.");
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            }
        }
    }
}

public class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(String request) {
        if ("C".equals(request)) {
            System.out.println("ConcreteHandlerC handled the request.");
        } else {
            System.out.println("ConcreteHandlerC cannot handle the request, passing to the next handler.");
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            }
        }
    }
}

现在，我们可以在客户端代码中使用这些类：

public class Client {
    public static void main(String[] args) {
        // 创建处理者并设置责任链
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        handlerA.setNextHandler(handlerB);
        handlerB.setNextHandler(handlerC);

        // 发送请求
        String request = "B";
        handlerA.handleRequest(request);
    }
}

输出：

ConcreteHandlerA cannot handle the request, passing to the next handler.
ConcreteHandlerB handled the request.

通过这个示例，你可以看到责任链模式如何实现请求在一系列处理者之间传递，每个处理者要么处理请求，要么将其传递给链上的下一个处理者。这有助于将发送请求的对象与处理请求的对象解耦，从而提高代码的可扩展性和可维护性。

你可以看到责任链模式如何实现请求在一系列处理者之间传递，每个处理者要么处理请求，要么将其传递给链上的下一个处理者。这有助于将发送请求的对象与处理请求的对象解耦，从而提高代码的可扩展性和可维护性。

责任链模式的一个典型应用场景是处理程序的错误或异常。例如，你可以为程序的不同层次或模块创建不同的错误处理器，这些处理器按照处理能力和优先级组成一个责任链。当程序出现错误时，沿着责任链寻找可以处理该错误的处理器。

总结一下，责任链模式有以下优点：

1. 将请求的发送者与处理者解耦，降低了请求发送者对处理者的依赖。
2. 可以根据需要动态地添加或删除处理者，提高了程序的灵活性。
3. 当请求不能被任何处理者处理时，可以定义一个默认处理者来处理这种情况。

然而，责任链模式也有一些缺点：

1. 当责任链过长时，可能会导致性能下降。
2. 如果责任链的配置不当，可能导致某些请求得不到处理。