责任链


使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。

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

  1. ┌─────────┐
  2. Request
  3. └─────────┘
  4. ┌─────────────┐
  5. ProcessorA
  6. └─────────────┘
  7. ┌─────────────┐
  8. ProcessorB
  9. └─────────────┘
  10. ┌─────────────┐
  11. ProcessorC
  12. └─────────────┘

在实际场景中,财务审批就是一个责任链模式。假设某个员工需要报销一笔费用,审核者可以分为:

  • Manager:只能审核1000元以下的报销;
  • Director:只能审核10000元以下的报销;
  • CEO:可以审核任意额度。

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

我们来看看如何实现责任链模式。

首先,我们要抽象出请求对象,它将在责任链上传递:

  1. public class Request {
  2. private String name;
  3. private BigDecimal amount;
  4. public Request(String name, BigDecimal amount) {
  5. this.name = name;
  6. this.amount = amount;
  7. }
  8. public String getName() {
  9. return name;
  10. }
  11. public BigDecimal getAmount() {
  12. return amount;
  13. }
  14. }

其次,我们要抽象出处理器:

  1. public interface Handler {
  2. // 返回Boolean.TRUE = 成功
  3. // 返回Boolean.FALSE = 拒绝
  4. // 返回null = 交下一个处理
  5. Boolean process(Request request);
  6. }

并且做好约定:如果返回Boolean.TRUE,表示处理成功,如果返回Boolean.FALSE,表示处理失败(请求被拒绝),如果返回null,则交由下一个Handler处理。

然后,依次编写ManagerHandler、DirectorHandler和CEOHandler。以ManagerHandler为例:

  1. public class ManagerHandler implements Handler {
  2. public Boolean process(Request request) {
  3. // 如果超过1000元,处理不了,交下一个处理:
  4. if (request.getAmount().compareTo(BigDecimal.valueOf(1000)) > 0) {
  5. return null;
  6. }
  7. // 对Bob有偏见:
  8. return !request.getName().equalsIgnoreCase("bob");
  9. }
  10. }

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

  1. public class HandlerChain {
  2. // 持有所有Handler:
  3. private List<Handler> handlers = new ArrayList<>();
  4. public void addHandler(Handler handler) {
  5. this.handlers.add(handler);
  6. }
  7. public boolean process(Request request) {
  8. // 依次调用每个Handler:
  9. for (Handler handler : handlers) {
  10. Boolean r = handler.process(request);
  11. if (r != null) {
  12. // 如果返回TRUE或FALSE,处理结束:
  13. System.out.println(request + " " + (r ? "Approved by " : "Denied by ") + handler.getClass().getSimpleName());
  14. return r;
  15. }
  16. }
  17. throw new RuntimeException("Could not handle request: " + request);
  18. }
  19. }

现在,我们就可以在客户端组装出责任链,然后用责任链来处理请求:

  1. // 构造责任链:
  2. HandlerChain chain = new HandlerChain();
  3. chain.addHandler(new ManagerHandler());
  4. chain.addHandler(new DirectorHandler());
  5. chain.addHandler(new CEOHandler());
  6. // 处理请求:
  7. chain.process(new Request("Bob", new BigDecimal("123.45")));
  8. chain.process(new Request("Alice", new BigDecimal("1234.56")));
  9. chain.process(new Request("Bill", new BigDecimal("12345.67")));
  10. chain.process(new Request("John", new BigDecimal("123456.78")));

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

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

  1. public class AHandler implements Handler {
  2. private Handler next;
  3. public void process(Request request) {
  4. if (!canProcess(request)) {
  5. // 手动交给下一个Handler处理:
  6. next.process(request);
  7. } else {
  8. ...
  9. }
  10. }
  11. }

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

  • 记录日志;
  • 检查权限;
  • 准备相关资源;

例如,JavaEE的Servlet规范定义的Filter就是一种责任链模式,它不但允许每个Filter都有机会处理请求,还允许每个Filter决定是否将请求“放行”给下一个Filter

  1. public class AuditFilter implements Filter {
  2. public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
  3. log(req);
  4. if (check(req)) {
  5. // 放行:
  6. chain.doFilter(req, resp);
  7. } else {
  8. // 拒绝:
  9. sendError(resp);
  10. }
  11. }
  12. }

这种模式不但允许一个Filter自行决定处理ServletRequestServletResponse,还可以“伪造”ServletRequestServletResponse以便让下一个Filter处理,能实现非常复杂的功能。

练习

责任链 - 图1下载练习:使用责任链模式实现审批 (推荐使用IDE练习插件快速下载)

小结

责任链模式是一种把多个处理器组合在一起,依次处理请求的模式;

责任链模式的好处是添加新的处理器或者重新排列处理器非常容易;

责任链模式经常用在拦截、预处理请求等。

读后有收获可以支付宝请作者喝咖啡:

责任链 - 图2