文章目錄
- 什么是責任鏈模式？
- 詳細示例
- 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);}}}}
}
總結
責任鏈模式是常見的設計模式，各個不同職責的處理器串聯起來，通過一次請求便能夠執行完每個處理器的處理方法。
通過這樣的方式請求的發送者只需發出一次請求同時也不需要知道詳細的鏈路結構；而請求的接送方只關心自己的處理邏輯，自己處理完成之后將請求傳遞給下一個接收者，從而完成自己的任務，這樣便實現了請求發送者和接收者的解耦。
對象)
