责任链模式

责任链模式

责任链模式（Chain of Responsibility）是一种处理请求的模式，它让多个处理器都有机会处理该请求，直到其中某个处理成功为止。责任链模式吧多个处理器串成链，然后请求在链上传递。

假如有以下场景：

公司的费用报销审核制度规定，Manager只能审核1000元以下的报销，Director只能审核10000元以下的报销，CEO可以审核任意额度。

用责任链模式设计此报销流程时，每个审核者只关心自己的责任范围内的请求，并处理它。对于超出自己责任的范围的请求则扔给下一个审核者处理。假设将来在继续添加审核者的时候就不需要改动现有逻辑。

首先抽象出一个请求对象，它将在责任链上传递

/**
 * 抽象一个请求对象，负责在责任链上传递
 */
public class Request {
    private String name;
    private double amount;

    public Request(String name, double amount) {
        this.name = name;
        this.amount = amount;
    }

    public String getName() {
        return name;
    }

    public double getAmount() {
        return amount;
    }
}

接着，抽象出处理器：

/**
 * 抽象处理器
 */
public interface Handler {
    /**
     *
     * @param request
     * @return true 成功，false 拒绝，null 交给下一个处理
     */
    Boolean process(Request request);
}

并且做好约定：如果返回 TRUE，表示处理成功，如果返回FALSE，表示处理失败（请求被拒绝），如果返回null，则交由下一个Handler处理。

然后，依次编写ManagerHandler、DirectorHandler和CEOHandler。以ManagerHandler为例：

public class ManagerHandler implements Handler {
    @Override
    public Boolean process(Request request) {
        if (request.getAmount() >= 1000) {
            // 超过1000元，处理不了，交给上级处理
            return null;
        }
        // 对Bob有偏见，Bob的请求直接拒绝
        return !request.getName().equals("Bob");
    }
}

有了不同的Handler后，我们还要把这些Handler组合起来，变成一个链，并通过统一入口处理：

public class HandlerChain {
    private List<Handler> handlers = new ArrayList<>();

    public void addHandler(Handler handler) {
        this.handlers.add(handler);
    }

    public boolean process(Request request) {
        for (Handler handler :
                handlers) {
            Boolean process = handler.process(request);
            if (process != null) {
                System.out.println(request.getName() + "'s request " + (process ? "Approved by" : "Denied by") + handler.getClass().getSimpleName());
                return process;
            }
        }
        throw new RuntimeException("Count not handle request: " + request);
    }
}

现在可以在客户端组装出责任链，然后通过责任链来处理请求：

public static void main(String[] args) {
    // 构造责任链:
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new ManagerHandler());
    chain.addHandler(new DirectorHandler());
    chain.addHandler(new CEOHandler());

    // 处理请求:
    chain.process(new Request("Bob", 123.45));
    chain.process(new Request("Alice", 1234.56));
    chain.process(new Request("Bill", 12345.67));
    chain.process(new Request("John", 123456.78));

}

责任链模式本身很容易理解，需要注意的是，Handler添加的顺序很重要，如果顺序不对，处理的结果可能就不是符合要求的。

此外，责任链模式有很多变种。有些责任链的实现方式是通过某个Handler手动调用下一个Handler来传递Request，例如：

public class AHandler implements Handler {
    private Handler next;
    public void process(Request request) {
        if (!canProcess(request)) {
            // 手动交给下一个Handler处理:
            next.process(request);
        } else {
            ...
        }
    }
}

还有一些责任链模式，每个Handler都有机会处理Request，通常这种责任链被称为拦截器（Interceptor）或者过滤器（Filter），它的目的不是找到某个Handler处理掉Request，而是每个Handler都做一些工作，比如OkHttp中的拦截器：

• 重定向拦截器负责重试与重定向
• 桥接拦截器是应用程序与服务器的桥梁，请求会经过它来补全请求头
• 缓存拦截器在发出请求前判断是否命中缓存，如果命中则可以不请求，直接使用缓存。
• 连接拦截器打开目标服务器的连接，并执行下一个拦截器
• 请求服务器拦截器利用HttpCodec发出请求并解析生成Reponse

https://www.liaoxuefeng.com/wiki/1252599548343744/1281319474561057