2. 程式人生 > 其它 >行為型設計模式：職責鏈模式

行為型設計模式：職責鏈模式

阿新 • • 發佈：2022-05-27

職責鏈模式的原理和實現

將請求的傳送和接收解耦，讓多個接收物件都有機會處理這個請求。將這些接收物件串成一條鏈，並沿著這條鏈傳遞這個請求，直到鏈上的某個接收物件能夠處理它為止。

在職責鏈模式中，多個處理器一次處理同一個請求，形成一個處理鏈條，鏈條上的每個處理器各司其職，所以叫職責鏈模式。

職責鏈模式有多種實現方式，我們講解其中一種：用陣列儲存處理器的方式，

public interface IHandler {
  boolean handle();
}

public class HandlerA implements IHandler {
  @Override
  public boolean
 
 handle() {
　　//這塊定義這個是標記某個處理器處理完了下一個處理器就不用處理的
    boolean handled = false;
    //...
    return handled;
  }
}

public class HandlerB implements IHandler {
  @Override
  public boolean handle() {
    boolean handled = false;
    //...
    return handled;
  }
}

//處理器鏈
public class HandlerChain {
  private List<IHandler> handlers = new
 
 ArrayList<>();
　　
　　//將處理器新增到執行鏈中
  public void addHandler(IHandler handler) {
    this.handlers.add(handler);
  }

  public void handle() {
　　//挨個執行
    for (IHandler handler : handlers) {
      boolean handled = handler.handle();
　　　　//其中有一個處理器處理後則跳出不繼續執行
      if (handled) {
        break;
      }
    }
  }
}


 
// 使用舉例
public class Application {
  public static void main(String[] args) {
    HandlerChain chain = new HandlerChain();
    chain.addHandler(new HandlerA());
    chain.addHandler(new HandlerB());
    chain.handle();
  }
}

上面是挨個執行，某個處理完其他就不處理了，也可以去掉其中的判斷，那就是挨個處理，比如進行過濾這種需求就要挨個執行。

職責鏈模式的應用場景舉例

處理敏感詞這個應用場景中，有兩種處理結果，1是不進行釋出 2是進行***處理。第一種方式適合用某個處理器進行處理後其他處理器不進行處理，第二種方式就是順序執行，所有處理器都執行完畢。

下面實現一個第一種情況,第二種情況把其中判斷去掉，挨個執行就行。

public interface SensitiveWordFilter {
  boolean doFilter(Content content);
}

public class SexyWordFilter implements SensitiveWordFilter {
  @Override
  public boolean doFilter(Content content) {
    boolean legal = true;
    //...
    return legal;
  }
}

// PoliticalWordFilter、AdsWordFilter類程式碼結構與SexyWordFilter類似

public class SensitiveWordFilterChain {
  private List<SensitiveWordFilter> filters = new ArrayList<>();

  public void addFilter(SensitiveWordFilter filter) {
    this.filters.add(filter);
  }

  // return true if content doesn't contain sensitive words.
  public boolean filter(Content content) {
    for (SensitiveWordFilter filter : filters) {
      if (!filter.doFilter(content)) {
        return false;
      }
    }
    return true;
  }
}

public class ApplicationDemo {
  public static void main(String[] args) {
    SensitiveWordFilterChain filterChain = new SensitiveWordFilterChain();
    filterChain.addFilter(new AdsWordFilter());
    filterChain.addFilter(new SexyWordFilter());
    filterChain.addFilter(new PoliticalWordFilter());

    boolean legal = filterChain.filter(new Content());
    if (!legal) {
      // 不發表
    } else {
      // 發表
    }
  }
}

為什麼要用這種複雜的方式實現？

我們把各個敏感詞過濾函式繼續拆分出來，設計成獨立的類，進一步簡化了 SensitiveWordFilter 類，讓 SensitiveWordFilter 類的程式碼不會過多，過複雜。

如果要增加新的過濾器，只需要新新增一個 Filter 類，並且通過 addFilter() 函式將它新增到 FilterChain 中即可，其他程式碼完全不需要修改。

框架中職責鏈的應用

職責鏈模式最常用來開發框架的過濾器和攔截器。今天，我們就通過 Servlet Filter、Spring Interceptor 這兩個 Java 開發中常用的元件，來具體講講它在框架開發中的應用。

Servlet Filter

Servlet Filter 是 Java Servlet 規範中定義的元件，即過濾器，它可以實現對 HTTP 請求的過濾功能，比如鑑權、限流、記錄日誌、驗證引數等等。因為它是 Servlet 規範的一部分，所以，只要是支援 Servlet 的 Web 容器（比如，Tomcat、Jetty 等），都支援過濾器功能。它的工作原理，如下所示。

在實際專案中，我們該如何使用 Servlet Filter 呢？

新增一個過濾器，我們只需要定義一個實現 javax.servlet.Filter 介面的過濾器類，並且將它配置在 web.xml 配置檔案中。

Web 容器啟動的時候，會讀取 web.xml 中的配置，建立過濾器物件。當有請求到來的時候，會先經過過濾器，然後才由 Servlet 來處理。

public class LogFilter implements Filter {
  @Override
  public void init(FilterConfig filterConfig) throws ServletException {
    // 在建立Filter時自動呼叫，
    // 其中filterConfig包含這個Filter的配置引數，比如name之類的（從配置檔案中讀取的）
  }

  @Override
  public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    System.out.println("攔截客戶端傳送來的請求.");
    chain.doFilter(request, response);
    System.out.println("攔截髮送給客戶端的響應.");
  }

  @Override
  public void destroy() {
    // 在銷燬Filter時自動呼叫
  }
}

// 在web.xml配置檔案中如下配置：
<filter>
  <filter-name>logFilter</filter-name>
  <filter-class>com.xzg.cd.LogFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>logFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
從剛剛的示例程式碼中，我們發現，新增過濾器非常方便，不需要修改任何程式碼，定義一個實現 javax.servlet.Filter 的類，再改改配置就搞定了，完全符合開閉原則。那 Servlet Filter 是如何做到如此好的擴充套件性的呢？ 它利用的就是職責鏈模式。現在，我們通過剖析它的原始碼，詳細地看看它底層是如何實現的，以下為簡化後的程式碼。 
public final class ApplicationFilterChain implements FilterChain {
  private int pos = 0; //當前執行到了哪個filter
  private int n; //filter的個數
  private ApplicationFilterConfig[] filters;
  private Servlet servlet;
  
  @Override
  public void doFilter(ServletRequest request, ServletResponse response) {
    if (pos < n) {
      ApplicationFilterConfig filterConfig = filters[pos++];
      Filter filter = filterConfig.getFilter();
      filter.doFilter(request, response, this);
    } else {
      // filter都處理完畢後，執行servlet
      servlet.service(request, response);
    }
  }
  
  public void addFilter(ApplicationFilterConfig filterConfig) {
    for (ApplicationFilterConfig filter:filters)
      if (filter==filterConfig)
         return;

    if (n == filters.length) {//擴容
      ApplicationFilterConfig[] newFilters = new ApplicationFilterConfig[n + INCREMENT];
      System.arraycopy(filters, 0, newFilters, 0, n);
      filters = newFilters;
    }
    filters[n++] = filterConfig;
  }
}

這裡面可以看到一個遞迴：filter.doFilter，這樣設計的目的是，我們可以在過濾器執行的前後增加實現內容，達到雙向攔截，既能攔截客戶端傳送來的請求，也能攔截髮送給客戶端的響應的效果。

Spring Interceptor

攔截器，與Servlet Filter不同之處在於，Servlet Filter 是 Servlet 規範的一部分，實現依賴於 Web 容器。

Spring Interceptor 是 Spring MVC 框架的一部分，由 Spring MVC 框架來提供實現。

客戶端傳送的請求，會先經過 Servlet Filter，然後再經過 Spring Interceptor，最後到達具體的業務程式碼中。具體如下所示。

在專案中，我們該如何使用 Spring Interceptor 呢？。

LogInterceptor 實現的功能跟剛才的 LogFilter 完全相同，只是實現方式上稍有區別。LogFilter 對請求和響應的攔截是在 doFilter() 一個函式中實現的，而 LogInterceptor 對請求的攔截在 preHandle() 中實現，對響應的攔截在 postHandle() 中實現。示例程式碼如下

public class LogInterceptor implements HandlerInterceptor {

  @Override
  public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    System.out.println("攔截客戶端傳送來的請求.");
    return true; // 繼續後續的處理
  }

  @Override
  public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    System.out.println("攔截髮送給客戶端的響應.");
  }

  @Override
  public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    System.out.println("這裡總是被執行.");
  }
}

//在Spring MVC配置檔案中配置interceptors
<mvc:interceptors>
   <mvc:interceptor>
       <mvc:mapping path="/*"/>
       <bean class="com.xzg.cd.LogInterceptor" />
   </mvc:interceptor>
</mvc:interceptors>

同樣，我們還是來剖析一下，Spring Interceptor 底層是如何實現的。

其中，HandlerExecutionChain 類是職責鏈模式中的處理器鏈。它的實現相較於 Tomcat 中的 ApplicationFilterChain 來說，邏輯更加清晰，不需要使用遞迴來實現，主要是因為它將請求和響應的攔截工作，拆分到了兩個函式中實現。HandlerExecutionChain 的原始碼如下所示，同樣，我對程式碼也進行了一些簡化，只保留了關鍵程式碼。

public class HandlerExecutionChain {
 private final Object handler;
 private HandlerInterceptor[] interceptors;
 
 public void addInterceptor(HandlerInterceptor interceptor) {
  initInterceptorList().add(interceptor);
 }

 boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
  HandlerInterceptor[] interceptors = getInterceptors();
  if (!ObjectUtils.isEmpty(interceptors)) {
   for (int i = 0; i < interceptors.length; i++) {
    HandlerInterceptor interceptor = interceptors[i];
    if (!interceptor.preHandle(request, response, this.handler)) {
     triggerAfterCompletion(request, response, null);
     return false;
    }
   }
  }
  return true;
 }

 void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {
  HandlerInterceptor[] interceptors = 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, Exception ex)
   throws Exception {
  HandlerInterceptor[] interceptors = 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 ex2) {
     logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
    }
   }
  }
 }
}

在 Spring 框架中，DispatcherServlet 的 doDispatch() 方法來分發請求，它在真正的業務邏輯執行前後，執行 HandlerExecutionChain 中的 applyPreHandle() 和 applyPostHandle() 函式，用來實現攔截的功能。

相關推薦

行為型設計模式：職責鏈模式

職責鏈模式的原理和實現 將請求的傳送和接收解耦，讓多個接收物件都有機會處理這個請求。將這些接收物件串成一條鏈，並沿著這條鏈傳遞這個請求，直到鏈上的某個接收物件能夠處理它為止。

設計模式--行為型模式--責任鏈模式（職責鏈模式）

在現實生活中，一個事件需要經過多個物件處理是很常見的場景。例如，採購審批流程、請假流程等。公司員工請假，可批假的領導有部門負責人、副總經理、總經理等，但每個領導能批准的天數不同，員工必須根據需要請假的

設計模式學習筆記（十六）：職責鏈模式

1 概述 1.1 引言 很多情況下，一個軟體系統中可以處理某個請求的物件不知一個，比如採購單的審批，主任，副董事長，董事長，董事會都可以處理採購單，他們可以構成一條處理採購單的鏈式結構，採購單沿著這條鏈進行傳

php設計模式之職責鏈模式例項分析【星際爭霸遊戲案例】

本文例項講述了php設計模式之職責鏈模式。分享給大家供大家參考，具體如下：

快速學習C# 設計模式之職責鏈模式

職責鏈模式簡介及UML 職責鏈也叫責任鏈，他是一種行為型模式，它為請求建立了一個接收請求者物件的鏈，並將請求沿著這條鏈傳遞到目標物件去處理。

【設計模式】職責鏈模式

顧名思義，責任鏈模式（Chain of Responsibility Pattern）為請求建立了一個接收者物件的鏈。這種模式給予請求的型別，對請求的傳送者和接收者進行解耦。這種型別的設計模式屬於行為型模式。

Javascript-設計模式_職責鏈模式

定義 職責鏈模式（Chain of responsibility）是使多個物件都有機會處理請求，從而避免請求的傳送者和接受者之間的耦合關係。將這個物件連成一條鏈，並沿著這條鏈傳遞該請求，直到有一個物件處理他為止

C#設計模式之職責鏈模式示例詳解

前言 在軟體開發中，我們通常會遇到一種場景，比如某個請求，會依次經過系統中的很多個模組來處理，如果某個模組處理不了，則將請求傳遞給下一個模組，比如在訂單處理中，首先要經過使用者校驗，商品庫存充足校驗，

JavaScript設計模式之職責鏈模式

概述 職責鏈模式是設計模式中行為型的一種設計模式； 定義：使多個物件都有機會處理請求，從而避免請求的傳送者與接收者之間的耦合關係，將這些處理請求的物件形成一個鏈，並沿著這個鏈傳遞請求，直到有一個物件處理

設計模式之職責鏈模式

定義 使每個物件都有機會處理請求，從而避免請求的傳送者和接收者之間的耦合關係。將這些物件連成一條鏈，並沿著這條鏈傳遞該請求，

設計模式之---職責鏈模式

職責鏈模式（Chain of Responsibility）：使多個物件都有機會處理請求，從而避免請求的傳送者和接收者之間的耦合關係。將這個物件連成一條鏈，並沿著這條鏈傳遞該請求，直到有一個物件處理它為止。

無廢話設計模式（20）行為型模式--職責鏈模式

0-前言 　　職責鏈模式定義： 　　　　使多個物件都有機會處理請求，從而避免請求的傳送者喝接受者之間的耦合關係。

C#設計模式學習筆記：(20)職責鏈模式

技術標籤：C#教程c# 本筆記摘抄自：https://www.cnblogs.com/PatrickLiu/p/8109100.html，記錄一下學習過程以備後續查用。

行為型設計模式：模板模式

模板模式的原理與實現 模板方法模式：在一個方法中定義一個演算法骨架，並將某些步驟推遲到子類中實現。模板方法模式可以讓子類在不改變演算法整體結構的情況下，重新定義演算法中的某些步驟。

行為型設計模式：策略模式

策略模式：定義一族演算法類，將每個演算法封裝起來，讓他們可以相互替換。策略模式可以使演算法的變化獨立於他們的使用者。

javascript設計模式 – 職責鏈模式原理與用法例項分析

本文例項講述了javascript設計模式 – 職責鏈模式原理與用法。分享給大家供大家參考，具體如下：

3、Template Method 模板方法 行為型設計模式

1、了解模板方法 1.1 模式定義 定義一個操作算法中的框架，而將這些步驟延遲加載到子類中。

1、迭代器 Iterator模式 一個一個遍歷 行為型設計模式

1、Iterator模式 迭代器（iterator）有時又稱遊標（cursor）是程序設計的軟件設計模式，可在容器（container，例如鏈表或者陣列）上遍訪的接口，設計人員無需關心容器的內容。

13、Visitor 訪問者模式 訪問資料結構並處理資料 行為型設計模式

1、模式的定義與特點 訪問者（Visitor）模式的定義：將作用於某種數據結構中的各元素的操作分離出來封裝成獨立的類，使其在不改變數據結構的前提下可以添加作用於這些元素的新的操作，為數據結構中的每個元素提供多種

設計模式 | 職責鏈模式（Chain of responsibility）

定義： 使多個物件都有機會處理請求，從而避免請求的傳送者和接受者之間的耦合關係。將這個物件連城一條鏈，並沿著這條鏈傳遞該請求，直到有一個物件處理它為止。