设计模式之责任链模式

概述

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它允许多个对象在一个链中按照顺序处理请求，直到其中一个对象处理了请求为止。这种模式将请求的发送者和接收者分离开来，使得多个对象都有机会处理请求，从而避免了请求发送者和接收者之间的耦合关系。在责任链模式中，每个处理者都有一个下一个处理者的引用，如果当前处理者无法处理请求，它会将请求传递给下一个处理者，直到请求被处理为止。

在 Java 中，责任链模式通常由一个抽象处理者（Handler）和多个具体处理者（ConcreteHandler）组成。抽象处理者定义了处理请求的接口，具体处理者实现了处理请求的具体逻辑，并且可以选择将请求传递给下一个处理者。在实际使用中，可以通过链式调用的方式来构建责任链，从而实现请求的处理。

示例

下面是一个基于 Java 的责任链模式的示例代码：

// 抽象处理者
public abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(Request request);
}

// 具体处理者A
public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getType() == RequestType.TYPE_A) {
            System.out.println("ConcreteHandlerA handles the request.");
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            }
        }
    }
}

// 具体处���者B
public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getType() == RequestType.TYPE_B) {
            System.out.println("ConcreteHandlerB handles the request.");
        } else {
            if (nextHandler != null) {
                nextHandler.handleRequest(request);
            }
        }
    }
}

// 请求类型
public enum RequestType {
    TYPE_A, TYPE_B
}

// 请求
public class Request {
    private RequestType type;

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

    public RequestType getType() {
        return type;
    }
}

// 测试代码
public class Test {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        handlerA.setNextHandler(handlerB);

        Request request1 = new Request(RequestType.TYPE_A);
        handlerA.handleRequest(request1);

        Request request2 = new Request(RequestType.TYPE_B);
        handlerA.handleRequest(request2);
    }
}

在上面的代码中，抽象处理者（Handler）定义了处理请求的接口，并持有下一个处理者的引用。具体处理者A（ConcreteHandlerA）和具体处理者B（ConcreteHandlerB）分别实现了处理请求的具体逻辑，并根据请求类型来决定是否将请求传递给下一个处理者。请求（Request）定义了请求类型，测试代码中创建了两个请求，并将它们传递给责任链的第一个处理者（handlerA）进行处理。

当运行测试代码时，输出结果为：

ConcreteHandlerA handles the request.
ConcreteHandlerB handles the request.

说明

可以看到，第一个请求的类型为TYPE_A，被具体处理者A处理；第二个请求的类型为TYPE_B，被具体处理者B处理。由于责任链中只有两个处理者，因此第二个请求被处理后就结束了。如果需要添加更多的处理者，只需要创建新的具体处理者并将它们添加到责任链中即可。

总结

责任链模式的优点包括：

1. 可以动态地添加或删除处理者，灵活性高。
2. 可以避免请求发送者和接收者之间的紧耦合关系，降低系统的耦合度。
3. 可以将请求的处理流程拆分成多个独立的处理者，使得系统更加易于扩展和维护。

责任链模式的缺点包括：

1. 请求可能被多个处理者处理，但只有一个处理者会真正处理请求，这可能会导致系统性能下降。
2. 如果责任链过长，可能会影响系统的性能和可维护性。
3. 可能会导致请求被无限循环处理，造成系统崩溃。
4. 在实际应用中，责任链模式常用于处理请求的场景，比如日志记录、权限验证、异常处理等。它可以使得请求的处理者之间解耦，提高系统的可维护性和可扩展性。