设计模式简述（十）责任链模式

描述

如果一个请求要经过多个类似或相关处理器的处理。
可以考虑将这些处理器添加到一个链上，让请求逐个经过这些处理器进行处理。

通常，在一个业务场景下会对整个责任链进行初始化，确定这个链上有哪些Handler

关于一个handler处理请求后，请求如何流转通常有几种处理方式：

• handler有匹配条件
  • 一旦匹配一个handler完成处理后直接返回 后续handler 不会处理i请求
  • 无论是否匹配都执行完整个责任链
• handler没有匹配条件
  • 这种没有匹配条件的链通常是执行整个责任链

基本使用

这里以有条件匹配，只执行一个handler后就返回的方式举例
匹配的条件通常包含在请求参数中，用于与每个Handler内条件匹配

这里参数就简单定义一个类，不提抽象层了

• 请求参数

public class HandleRequest {
    private String type;
    private Object data;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "HandleRequest{" +
                "type='" + type + '\'' +
                ", data=" + data +
                '}';
    }
}

• 抽象Handler

public abstract class AbstractHandler {
    private AbstractHandler nextHandler;

    public final void handleRequest(HandleRequest request) {
        if (Objects.equals(handleType(), request.getType())) {
            this.handle(request);
        } else {
            if (this.nextHandler != null) {
                this.nextHandler.handleRequest(request);
            } else {
                System.out.println("请求未匹配到Handler...");
            }
        }
    }

    public void setNext(AbstractHandler handler) {
        this.nextHandler = handler;
    }

    protected abstract String handleType();

    protected abstract void handle(HandleRequest request);
}

• 具体Handler

public class HandlerA extends AbstractHandler {
    @Override
    protected String handleType() {
        return "typeA";
    }

    @Override
    protected void handle(HandleRequest request) {
        System.out.println("HandlerA 处理请求: " + request);
    }
}

public class HandlerB extends AbstractHandler {
    @Override
    protected String handleType() {
        return "typeB";
    }

    @Override
    protected void handle(HandleRequest request) {
        System.out.println("HandlerB 处理请求: " + request);
    }
}

使用

在实际使用中，可以将责任链的初始化动作放到具体业务类中，返回第一个Handler给调用者即可
然后将请求委托给责任链。

这里就直接在调用方 进行初始化

public class Sample {
    public static void main(String[] args) {
        AbstractHandler handlerA = new HandlerA();
        AbstractHandler handlerB = new HandlerB();
        handlerA.setNext(handlerB);
        HandleRequest request = new HandleRequest();
        request.setType("typeB");
        request.setData("data.....");
        handlerA.handleRequest(request);
    }
}