Java设计模式（十四）责任链模式

一、概述

责任链模式是一种行为型设计模式，它通过一系列处理器对象形成一个链，每个处理器对象都有机会处理请求，直到其中一个处理器对象能够处理该请求为止。责任链模式将请求发送者和接收者解耦，使得多个对象都有机会处理请求，增加了系统的灵活性和可扩展性。

二、代码

以下是一个示例代码，说明责任链模式的使用：

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

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

    public String getType() {
        return type;
    }

    public String getContent() {
        return content;
    }
}
//2.抽象处理器类
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("没有可用的处理程序来处理请求.");
        }
    }

    protected abstract boolean canHandle(Request request);

    protected abstract void processRequest(Request request);
}
//3.具体处理器类A
public class ConcreteHandlerA extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        // 根据具体条件判断是否能够处理请求
        return request.getType().equals("TypeA");
    }

    @Override
    protected void processRequest(Request request) {
        // 处理请求的具体逻辑
        System.out.println("ConcreteHandlerA处理请求: " + request.getContent());
    }
}
//4.具体处理器类B
public class ConcreteHandlerB extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        // 根据具体条件判断是否能够处理请求
        return request.getType().equals("TypeB");
    }

    @Override
    protected void processRequest(Request request) {
        System.out.println("ConcreteHandlerB处理请求: " + request.getContent());
    }
}
//5.测试类
public class Test {
    public static void main(String[] args) {
        // 创建处理器对象
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();

        // 设置处理器之间的链式关系
        handlerA.setNextHandler(handlerB);

        // 创建请求
        Request request1 = new Request("TypeA", "请求A");
        Request request2 = new Request("TypeB", "请求B");
        Request request3 = new Request("TypeC", "请求C");

        // 处理请求
        handlerA.handleRequest(request1);
        handlerA.handleRequest(request2);
        handlerA.handleRequest(request3);
    }
}

在上述代码中，我们有一个抽象处理器类 Handler，它定义了处理请求的方法 handleRequest() 和设置下一个处理器的方法 setNextHandler()。具体的处理器类 ConcreteHandlerA 和 ConcreteHandlerB 继承自抽象处理器类，并实现了具体的处理逻辑。

在测试代码中，我们创建了具体的处理器对象 handlerA 和 handlerB，并设置它们之间的链式关系，即通过 handlerA.setNextHandler(handlerB) 将 handlerB 设置为 handlerA 的下一个处理器。

然后，我们创建了不同类型的请求对象 request1、request2 和 request3，并调用 handlerA.handleRequest() 方法来处理这些请求。

在处理请求时，handlerA 首先检查自身是否能够处理请求，如果可以处理，则执行相应的处理逻辑；否则，将请求传递给下一个处理器 handlerB。如果下一个处理器存在，则重复这个过程，直到找到能够处理请求的处理器，或者所有处理器都无法处理请求。

通过这种方式，责任链模式实现了请求的逐级传递和处理，每个处理器根据自身的责任判断是否处理请求，从而实现了请求的动态处理和解耦。

总结而言，责任链模式通过一系列处理器对象的链式结构，实现了请求的逐级处理和解耦。它在需要动态处理请求且不确定处理请求的对象时非常有用，能够提高系统的灵活性和可扩展性。