java责任链模式的实现

责任链模式是一种行为设计模式，它允许多个对象按照顺序处理请求，直到其中一个对象能够处理该请求为止。Java中可以通过以下方式实现责任链模式：

1. 定义一个抽象处理器（Handler）类，其中包含一个指向下一个处理器的引用，并定义一个处理请求的方法。
2. 创建具体的处理器类，继承抽象处理器类，并实现处理请求的方法。在方法中判断是否能够处理该请求，如果能够处理则进行处理，否则将请求传递给下一个处理器。
3. 在客户端代码中创建处理器对象，并设置它们的下一个处理器，形成一个处理器链。
4. 将请求发送给第一个处理器，它会根据自身的逻辑判断是否能够处理该请求，如果不能则将请求传递给下一个处理器，直到找到能够处理该请求的处理器为止。

以下是Java责任链模式的实现示例：

// 抽象处理器类
abstract class Handler {
    protected Handler nextHandler;

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

    public abstract void handleRequest(String request);
}

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

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

// 具体处理器类C
class ConcreteHandlerC extends Handler {
    @Override
    public void handleRequest(String request) {
        if (request.equals("C")) {
            System.out.println("ConcreteHandlerC 处理请求：" + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

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

        // 设置处理器链
        handlerA.setNextHandler(handlerB);
        handlerB.setNextHandler(handlerC);

        // 发送请求
        handlerA.handleRequest("B");
    }
}

以上代码中，客户端创建了三个具体的处理器对象，并设置它们的下一个处理器，形成一个处理器链。然后将请求发送给第一个处理器，它会根据自身的逻辑判断是否能够处理该请求，如果不能则将请求传递给下一个处理器，直到找到能够处理该请求的处理器为止。