Java设计模式之职责链模式

职责链模式（Chain of Responsibility Pattern）是一种行为型设计模式，用于将请求的发送者和接收者解耦，并使多个对象都有机会处理这个请求。在职责链模式中，请求沿着一个链传递，直到有一个对象处理它为止。

在职责链模式中，通常有以下几个角色：

1. 抽象处理者（Handler）：定义处理请求的接口，并维护一个指向下一个处理者的引用。通常包含一个处理方法，用于处理请求或将请求传递给下一个处理者。
2. 具体处理者（ConcreteHandler）：实现抽象处理者接口，具体处理请求的逻辑。如果自己无法处理请求，可以将请求传递给下一个处理者。
3. 客户端（Client）：创建职责链，并将请求发送给链中的第一个处理者。

下面是一个简单的示例，说明职责链模式的工作原理：

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

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

    public void handleRequest(Request request) {
        if (canHandle(request)) {
            processRequest(request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            // 没有处理者能够处理该请求
            System.out.println("No handler found for the request.");
        }
    }

    protected abstract boolean canHandle(Request request);

    protected abstract void processRequest(Request request);
}

// 具体处理者A
public class ConcreteHandlerA extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        // 判断是否能够处理该请求
        return request.getType().equals("A");
    }

    @Override
    protected void processRequest(Request request) {
        // 处理请求的逻辑
        System.out.println("ConcreteHandlerA is handling the request.");
    }
}

// 具体处理者B
public class ConcreteHandlerB extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        // 判断是否能够处理该请求
        return request.getType().equals("B");
    }

    @Override
    protected void processRequest(Request request) {
        // 处理请求的逻辑
        System.out.println("ConcreteHandlerB is handling the request.");
    }
}

// 请求类
public class Request {
    private String type;

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

    public String getType() {
        return type;
    }
}

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

        // 设置处理者的下一个处理者
        handlerA.setNextHandler(handlerB);

        // 创建请求
        Request requestA = new Request("A");
        Request requestB = new Request("B");
        Request requestC = new Request("C");

        // 发送请求
        handlerA.handleRequest(requestA); // 输出：ConcreteHandlerA is handling the request.
        handlerA.handleRequest(requestB); // 输出：ConcreteHandlerB is handling the request.
        handlerA.handleRequest(requestC); // 输出：No handler found for the request.
    }
}

在上面的示例中，抽象处理者（Handler）定义了处理请求的接口，并维护了一个指向下一个处理者的引用。具体处理者（ConcreteHandlerA和ConcreteHandlerB）实现了抽象处理者接口，并根据自身的能力判断是否能够处理请求。如果自己无法处理请求，就将请求传递给下一个处理者。客户端（Client）创建职责链，并将请求发送给链中的第一个处理者。

在示例中，请求类型为"A"的请求会被ConcreteHandlerA处理，请求类型为"B"的请求会被ConcreteHandlerB处理，而请求类型为"C"的请求没有任何处理者能够处理，最终输出"No handler found for the request."。

职责链模式的优点是将请求的发送者和接收者解耦，增加了系统的灵活性。同时，职责链模式也有可能导致请求的处理链过长，影响性能，因此在使用时需要注意控制链的长度。