Java责任链模式

责任链模式是一种行为型设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。在责任链模式中，请求沿着一个链传递，直到有一个对象处理它为止。

 

下面是一个简单的Java责任链模式的示例，假设有三个处理器，分别是A、B、C，它们按照顺序组成一个责任链，当有请求到来时，责任链会依次将请求传递给每个处理器，直到有一个处理器能够处理该请求为止。

 

```java

// 定义一个处理器接口

public interface Handler {

    void handleRequest(Request request);

}

 

// 具体的处理器A

public class HandlerA implements Handler {

    private Handler nextHandler;

 

    public void setNextHandler(Handler nextHandler) {

        this.nextHandler = nextHandler;

    }

 

    public void handleRequest(Request request) {

        if (request.getType() == RequestType.TYPE_A) {

            System.out.println("HandlerA处理了该请求");

        } else {

            if (nextHandler != null) {

                nextHandler.handleRequest(request);

            }

        }

    }

}

 

// 具体的处理器B

public class HandlerB implements Handler {

    private Handler nextHandler;

 

    public void setNextHandler(Handler nextHandler) {

        this.nextHandler = nextHandler;

    }

 

    public void handleRequest(Request request) {

        if (request.getType() == RequestType.TYPE_B) {

            System.out.println("HandlerB处理了该请求");

        } else {

            if (nextHandler != null) {

                nextHandler.handleRequest(request);

            }

        }

    }

}

 

// 具体的处理器C

public class HandlerC implements Handler {

    private Handler nextHandler;

 

    public void setNextHandler(Handler nextHandler) {

        this.nextHandler = nextHandler;

    }

 

    public void handleRequest(Request request) {

        if (request.getType() == RequestType.TYPE_C) {

            System.out.println("HandlerC处理了该请求");

        } else {

            if (nextHandler != null) {

                nextHandler.handleRequest(request);

            }

        }

    }

}

 

// 定义请求类

public class Request {

    private RequestType type;

 

    public Request(RequestType type) {

        this.type = type;

    }

 

    public RequestType getType() {

        return type;

    }

}

 

// 定义请求类型枚举

public enum RequestType {

    TYPE_A, TYPE_B, TYPE_C

}

 

// 客户端代码

public class Client {

    public static void main(String[] args) {

        HandlerA handlerA = new HandlerA();

        HandlerB handlerB = new HandlerB();

        HandlerC handlerC = new HandlerC();

 

        // 组成责任链

        handlerA.setNextHandler(handlerB);

        handlerB.setNextHandler(handlerC);

 

        // 发送请求

        Request request1 = new Request(RequestType.TYPE_A);

        handlerA.handleRequest(request1);

 

        Request request2 = new Request(RequestType.TYPE_B);

        handlerA.handleRequest(request2);

 

        Request request3 = new Request(RequestType.TYPE_C);

        handlerA.handleRequest(request3);

    }

}

```

 

在上面的示例中，我们定义了三个具体的处理器A、B、C，它们都实现了Handler接口，并且都有一个指向下一个处理器的引用。在客户端代码中，我们将它们按照顺序组成了一个责任链，并且发送了三个不同类型的请求。当请求到来时，责任链会依次将请求传递给每个处理器，直到有一个处理器能够处理该请求为止。