责任链模式的高级用法

责任链模式是一种行为设计模式，它允许将请求沿一个由多个对象组成的处理链进行传递，直到某个对象能够处理请求为止。在高级用法中，可以使用责任链模式实现动态的链式处理，允许在运行时添加、移除或修改处理链中的处理器。

以下是一个具体的Java案例代码，演示了责任链模式的高级用法：

import java.util.ArrayList;
import java.util.List;

// 定义请求类
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;
    }
}

// 定义处理器接口
interface Handler {
    void setNextHandler(Handler handler);
    void handleRequest(Request request);
}

// 具体处理器实现类
class ConcreteHandler1 implements Handler {
    private Handler nextHandler;

    @Override
    public void setNextHandler(Handler handler) {
        nextHandler = handler;
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("Type1")) {
            System.out.println("ConcreteHandler1处理请求: " + request.getContent());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("无法处理该请求");
        }
    }
}

class ConcreteHandler2 implements Handler {
    private Handler nextHandler;

    @Override
    public void setNextHandler(Handler handler) {
        nextHandler = handler;
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("Type2")) {
            System.out.println("ConcreteHandler2处理请求: " + request.getContent());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("无法处理该请求");
        }
    }
}

class ConcreteHandler3 implements Handler {
    private Handler nextHandler;

    @Override
    public void setNextHandler(Handler handler) {
        nextHandler = handler;
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getType().equals("Type3")) {
            System.out.println("ConcreteHandler3处理请求: " + request.getContent());
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        } else {
            System.out.println("无法处理该请求");
        }
    }
}

public class ChainOfResponsibilityExample {
    public static void main(String[] args) {
        // 创建处理器实例
        Handler handler1 = new ConcreteHandler1();
        Handler handler2 = new ConcreteHandler2();
        Handler handler3 = new ConcreteHandler3();

        // 构建处理链
        handler1.setNextHandler(handler2);
        handler2.setNextHandler(handler3);

        // 创建请求
        Request request1 = new Request("Type1", "请求类型1");
        Request request2 = new Request("Type2", "请求类型2");
        Request request3 = new Request("Type3", "请求类型3");
        Request request4 = new Request("Type4", "请求类型4");

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

**

在上述代码中，我们首先定义了一个Request类表示请求对象。然后，我们定义了一个Handler接口，其中包含了设置下一个处理器和处理请求的方法。接着，我们实现了三个具体的处理器类ConcreteHandler1、ConcreteHandler2和ConcreteHandler3，分别负责处理不同类型的请求。每个处理器类都会检查请求的类型，如果能够处理该类型的请求，则进行处理；否则，将请求传递给下一个处理器。最后，在main方法中，我们创建了处理器实例并构建了处理链，然后创建不同类型的请求并调用处理器进行处理。

运行以上代码将输出如下结果：

ConcreteHandler1处理请求: 请求类型1
ConcreteHandler2处理请求: 请求类型2
ConcreteHandler3处理请求: 请求类型3
无法处理该请求