责任链模式

责任链模式（Chain of Responsibility Pattern）是一种行为设计模式，它允许将请求沿着一条包含多个处理器的链进行传递。每个处理器都可以选择处理请求或将其传递给下一个处理器。这种模式使得多个对象都有机会处理请求，而无需显式地指定处理请求的对象，从而实现了请求发送者和接收者之间的解耦。

关键点

• 请求的传递：请求从链中的一个处理器传递到下一个处理器，直到被处理或到达链的末端。
• 处理者的抽象：处理者通常是一个抽象类或接口，每个具体的处理者实现这个抽象类或接口并定义如何处理请求。
• 灵活的链条：处理者可以动态地添加到链条中，链条的顺序可以在运行时调整。

适用场景

• 请求的处理者不明确：在设计初期无法预料请求会被哪个处理器处理。
• 动态指定处理者：处理者可以在运行时动态添加或修改。
• 减少耦合：请求的发送者和接收者解耦，以避免硬编码的处理逻辑。

代码示例

假设我们有一个客户支持系统，用户的请求可以是简单的询问、中等复杂度的问题或复杂的问题。我们将这些请求交给不同的处理者。

处理者接口

abstract class SupportHandler {
    protected SupportHandler nextHandler;

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

    public void handleRequest(String request) {
        if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

具体处理者

class BasicSupportHandler extends SupportHandler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("basic")) {
            System.out.println("BasicSupportHandler handling request: " + request);
        } else {
            super.handleRequest(request);
        }
    }
}

class IntermediateSupportHandler extends SupportHandler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("intermediate")) {
            System.out.println("IntermediateSupportHandler handling request: " + request);
        } else {
            super.handleRequest(request);
        }
    }
}

class AdvancedSupportHandler extends SupportHandler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("advanced")) {
            System.out.println("AdvancedSupportHandler handling request: " + request);
        } else {
            super.handleRequest(request);
        }
    }
}

使用责任链

public class Main {
    public static void main(String[] args) {
        // 创建具体处理者
        SupportHandler basicHandler = new BasicSupportHandler();
        SupportHandler intermediateHandler = new IntermediateSupportHandler();
        SupportHandler advancedHandler = new AdvancedSupportHandler();

        // 设置责任链
        basicHandler.setNextHandler(intermediateHandler);
        intermediateHandler.setNextHandler(advancedHandler);

        // 处理请求
        basicHandler.handleRequest("basic");        // 输出: BasicSupportHandler handling request: basic
        basicHandler.handleRequest("intermediate"); // 输出: IntermediateSupportHandler handling request: intermediate
        basicHandler.handleRequest("advanced");     // 输出: AdvancedSupportHandler handling request: advanced
        basicHandler.handleRequest("unknown");      // 无输出, 请求到达链的末端, 未被处理
    }
}

优点

1. 降低耦合度：请求发送者和处理者之间的耦合度降低。
2. 灵活性高：可以灵活地添加或修改处理者，改变处理顺序。
3. 责任分担：多个处理者共同分担处理请求的责任。

缺点

1. 调试困难：由于请求的传递是动态的，调试时可能较为复杂。
2. 可能没有处理者：如果没有处理者能处理请求，可能会造成请求未被处理的情况。

总结

责任链模式通过创建一系列处理者对象，使得多个处理者有机会处理请求，从而实现了请求发送者和接收者的解耦。它特别适用于处理链条中处理者不明确或需要动态指定的场景，但需要注意链条的调试和维护问题。