一文带你彻底搞懂什么是责任链模式！！

文章目录

- 什么是责任链模式？
- 详细示例
- SpingMVC 中的责任链模式使用
- 总结

在这里插入图片描述

什么是责任链模式？

在我们日常生活中，经常会出现一种场景：一个请求需要经过多个对象的处理才能得到最终的结果。比如，一个请假申请，需要经过组长、部门经理、总经理等多个级别的审批。这种场景下，使用责任链模式是一种非常优雅的解决方案。

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，它的主要目的是将请求的发送者和接收者解耦，使得多个对象都有机会处理这个请求。这种模式通过将请求沿着处理者链进行传递，直到有一个对象处理它为止。

在这里插入图片描述

在责任链模式中，主要涉及以下三个角色：

抽象处理者（Handler）：处理器抽象接口，定义了处理请求的方法和执行下一步处理的处理器。
具体处理者（ConcreteHandler）：实现抽象处理者接口，具体处理请求的逻辑在这里实现。如果不能处理当前请求，则将请求传递给下一个处理者。
客户端（Client）：负责创建并组装责任链，将请求发送给链中的第一个处理者。

在这里插入图片描述

代码：

// 抽象处理器
public abstract class Handler {private Handler next;public Handler getNext() {return next;}public void setNext(Handler next) {this.next = next;}public abstract void handle(Object request);
}// 具体处理器 1
public class ConcreteHandler1 extends Handler {@Overridepublic void handle(Object request) {System.out.println("concrete handler 1 execute request. request: " + request);if (getNext() != null) {getNext().handle(request);}}
}// 具体处理器 2
public class ConcreteHandler2 extends Handler {@Overridepublic void handle(Object request) {System.out.println("concrete handler 2 execute request. request: " + request);if (getNext() != null){getNext().handle(request);}}
}// 具体处理器 3
public class ConcreteHandler3 extends Handler {@Overridepublic void handle(Object request) {System.out.println("concrete handler 3 execute request. request: " + request);if (getNext() != null) {getNext().handle(request);}}
}public static void main(String[] args) {Handler concreteHandler1 = new ConcreteHandler1();Handler concreteHandler2 = new ConcreteHandler2();Handler concreteHandler3 = new ConcreteHandler3();concreteHandler1.setNext(concreteHandler2);concreteHandler2.setNext(concreteHandler3);concreteHandler1.handle("my request.");
}

从上面的代码我们可以看到其实责任链模式是非常简单的，但是其中有几个点需要注意一下：

首先我们需要对整个责任链进行初始化，即设置每个处理器的 next。
在每个具体处理器处理完之后需要手动调用下一个处理器的 handle 方法来执行下一步处理，这里其实还可以使用模板方法模式进行优化。

控制台输出如下：

concrete handler 1 execute request. request: my request.
concrete handler 2 execute request. request: my request.
concrete handler 3 execute request. request: my request.

详细示例

以日常请假为例。请假申请会先到你的直属 leader 处审批，审批通过后再到部门 leader 处审批，部门 leader 通过后，最后到人事处报备记录请假天数。

如果在传统企业里面，我们需要手写一份请假表，然后跑到直属 leader 办公室，让直属 leader 签字，然后再到部门 leader 办公室签字，最后还要跑到人事处上交请假单，这样相当于发出了三次请求，才能走完整个请假流程。

在这里插入图片描述

但是当我们使用责任链模式后整个请假流程就变的简单了，我们只需要发起一次请假请求，接下来你的请假请求便会自动的在审批人中间进行流转，这个时候我们的责任链模式便派上用场。

在这里插入图片描述

代码如下：

// 请假抽象处理器
public abstract class DayOffHandler {private DayOffHandler next;public DayOffHandler getNext() {return next;}public void setNext(DayOffHandler next) {this.next = next;}public abstract void handle(String request);}
// 直属 leader 处理
public class GroupLeaderHandler extends DayOffHandler {@Overridepublic void handle(String request) {System.out.println("直属 leader 审查: " + request);System.out.println("同意请求");if (getNext() != null) {getNext().handle(request);}}
}
// 部门 leader 处理
public class DepartmentLeaderHandler extends DayOffHandler{@Overridepublic void handle(String request) {System.out.println("部门 leader 审查: " + request);System.out.println("同意请求");if (getNext() != null) {getNext().handle(request);}}
}
// 人事处处理
public class HRHandler extends DayOffHandler {@Overridepublic void handle(String request) {System.out.println("人事处审查: " + request);System.out.println("同意请求，记录请假");if (getNext() != null) {getNext().handle(request);}}
}

客户端：

public static void main(String[] args) {DayOffHandler groupLeaderHandler = new GroupLeaderHandler();DayOffHandler departmentLeaderHandler = new DepartmentLeaderHandler();DayOffHandler hrHandler = new HRHandler();groupLeaderHandler.setNext(departmentLeaderHandler);departmentLeaderHandler.setNext(hrHandler);System.out.println("收到面试通知，需要请假");String request = "家中有事，请假半天，望批准";System.out.println("发起请求：");groupLeaderHandler.handle(request);
}

上面的代码定义了请假抽象处理类和三个具体的处理人，我们需要将这三个处理人的流程初始化串联起来，并且一步步的执行下去

结果：

收到面试通知，需要请假
发起请求：
直属 leader 审查: 家中有事，请假半天，望批准
同意请求
部门 leader 审查: 家中有事，请假半天，望批准
同意请求
人事处审查: 家中有事，请假半天，望批准
同意请求，记录请假

SpingMVC 中的责任链模式使用

在 SpringMVC 中的 Interceptor 用到了责任链模式。首先来看看 Interceptor 的抽象处理类;

public interface HandlerInterceptor {default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {return true;}default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {}default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {}
}

在抽象处理类中，定义了三个方法，分别是处理前置处理器、后置处理器和整个流程完成之后的处理。通过 HandlerExecutionChain 将拦截器串联起来，在 HandlerExecutionChain 中，我们需要关注 applyPreHandle、applyPostHandle 和 triggerAfterCompletion 三个方法，这三个方法分别执行了拦截器中所定义的 preHandle 、postHandle 和 afterCompletion 方法。并且从代码中也能够看处，和前面的过滤器一样，所有的拦截器都存放在 interceptors 数组中，并在三个方法中遍历 interceptors 数组依次执行相应的方法

public class HandlerExecutionChain {@Nullableprivate HandlerInterceptor[] interceptors;boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {HandlerInterceptor[] interceptors = this.getInterceptors();if (!ObjectUtils.isEmpty(interceptors)) {for(int i = 0; i < interceptors.length; this.interceptorIndex = i++) {HandlerInterceptor interceptor = interceptors[i];if (!interceptor.preHandle(request, response, this.handler)) {this.triggerAfterCompletion(request, response, (Exception)null);return false;}}}return true;}void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {HandlerInterceptor[] interceptors = this.getInterceptors();if (!ObjectUtils.isEmpty(interceptors)) {for(int i = interceptors.length - 1; i >= 0; --i) {HandlerInterceptor interceptor = interceptors[i];interceptor.postHandle(request, response, this.handler, mv);}}}void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) throws Exception {HandlerInterceptor[] interceptors = this.getInterceptors();if (!ObjectUtils.isEmpty(interceptors)) {for(int i = this.interceptorIndex; i >= 0; --i) {HandlerInterceptor interceptor = interceptors[i];try {interceptor.afterCompletion(request, response, this.handler, ex);} catch (Throwable var8) {logger.error("HandlerInterceptor.afterCompletion threw exception", var8);}}}}
}