设计模式之责任链模式

// 定义请求类
class Request {
    private String content;

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

    public String getContent() {
        return content;
    }
}

// 抽象处理器
abstract class Handler {
    protected Handler successor; // 后继处理器

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(Request request);
}

// 具体处理器A
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getContent().contains("A")) {
            System.out.println("ConcreteHandlerA 处理了请求：" + request.getContent());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理器B
class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getContent().contains("B")) {
            System.out.println("ConcreteHandlerB 处理了请求：" + request.getContent());
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理器C
class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(Request request) {
        if (request.getContent().contains("C")) {
            System.out.println("ConcreteHandlerC 处理了请求：" + request.getContent());
        } else {
            System.out.println("没有处理器可以处理该请求：" + request.getContent());
        }
    }
}

public class ChainOfResponsibilityPatternDemo {
    public static void main(String[] args) {
        // 创建处理器对象
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();

        // 设置处理器的后继关系
        handlerA.setSuccessor(handlerB);
        handlerB.setSuccessor(handlerC);

        // 创建请求对象
        Request request1 = new Request("信息包含A");
        Request request2 = new Request("信息包含C");
        Request request3 = new Request("信息不包含关键字");

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

在这个示例中，首先定义了一个请求类 Request，包含一个内容字段。然后，定义了一个抽象处理器类 Handler，其中包含一个后继处理器的引用 successor 和一个抽象方法 handleRequest(Request request)。

接着，分别实现了三个具体处理器类 ConcreteHandlerA、ConcreteHandlerB 和 ConcreteHandlerC，它们都继承自抽象处理器类 Handler。每个具体处理器类负责判断是否能够处理请求，如果可以处理则进行处理，否则将请求传递给后继处理器。

在主函数中，我们创建了三个具体处理器对象 handlerA、handlerB 和 handlerC，并设置它们的后继关系。然后，根据不同的请求内容，调用 handlerA 的 handleRequest() 方法进行处理。

运行上述示例代码，输出结果为：

ConcreteHandlerA 处理了请求：信息包含A
ConcreteHandlerC 处理了请求：信息包含C
没有处理器可以处理该请求：信息不包含关键字

通过使用责任链模式，每个具体处理器类只需要关注自己能够处理的请求，以及是否将请求传递给后继处理器。这样可以实现请求的自动转发和处理，在不同的情况下选择合适的处理器进行处理。希望这个示例能够帮助你理解责任链模式的使用。