在 Spring Boot 中，攔截器和動態代理都是用來實現功能增強的，所以在很多時候，有人會認為攔截器的底層是通過動態代理實現的，所以本文就來盤點一下他們兩的區別，以及攔截器的底層實現。
1、攔截器
攔截器（Interceptor）準確來說在 Spring MVC 中的一個很重要的組件，用于攔截 Controller 的請求。它的主要作用有以下幾個：
- 權限驗證：驗證用戶是否登錄、是否有權限訪問某個接口。
- 日志記錄：記錄請求信息的日志，如請求參數，響應信息等。
- 性能監控：監控系統的運行性能，如慢查詢接口等。
- 通用行為：插入一些通用的行為，比如開發環境忽略某些請求。
典型的使用場景是身份認證、授權檢查、請求日志記錄等。
（1）攔截器實現
在 Spring Boot 中攔截器的實現分為兩步：
- 創建一個普通的攔截器，實現 HandlerInterceptor 接口，并重寫接口中的相關方法。
- 將上一步創建的攔截器加入到 Spring Boot 的配置文件中，并配置攔截規則。
具體實現如下。
實現自定義攔截器
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import JAVAx.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Component
public class TestInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("攔截器：執行 preHandle 方法。");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
System.out.println("攔截器：執行 postHandle 方法。");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
System.out.println("攔截器：執行 afterCompletion 方法。");
}
}
其中：
- boolean preHandle(HttpServletRequest request， HttpServletResponse response， Object handle)：在請求方法執行前被調用，也就是調用目標方法之前被調用。比如我們在操作數據之前先要驗證用戶的登錄信息，就可以在此方法中實現，如果驗證成功則返回 true，繼續執行數據操作業務；否則就返回 false，后續操作數據的業務就不會被執行了。
- void postHandle(HttpServletRequest request， HttpServletResponse response， Object handle，ModelAndView modelAndView)：調用請求方法之后執行，但它會在 DispatcherServlet 進行渲染視圖之前被執行。
- void afterCompletion(HttpServletRequest request， HttpServletResponse response， Object handle， Exception ex)：會在整個請求結束之后再執行，也就是在 DispatcherServlet 渲染了對應的視圖之后再執行。
配置攔截規則
然后，我們再將上面的攔截器注入到項目配置文件中，并設置相應攔截規則，具體實現代碼如下：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class AppConfig implements WebMvcConfigurer {
// 注入攔截器
@Autowired
private TestInterceptor testInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(testInterceptor) // 添加攔截器
.addPathPatterns("/**"); // 攔截所有地址
.excludePathPatterns("/login"); // 放行接口
}
}
這樣我們的攔截器就實現完了。
（2）攔截器實現原理
Spring Boot 攔截器是基于 Java 的 Servlet 規范實現的，通過實現 HandlerInterceptor 接口來實現攔截器功能。
在 Spring Boot 框架的執行流程中，攔截器被注冊在 DispatcherServlet 的 doDispatch() 方法中，該方法是 Spring Boot 框架的核心方法，用于處理請求和響應。
程序每次執行時都會調用 doDispatch() 方法時，并驗證攔截器（鏈），之后再根據攔截器返回的結果，進行下一步的處理。如果返回的是 true，那么繼續調用目標方法，反之則會直接返回驗證失敗給前端。
doDispatch 源碼實現如下：
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChAIn mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
try {
ModelAndView mv = null;
Object dispatchException = null;
try {
processedRequest = this.checkMultipart(request);
multipartRequestParsed = processedRequest != request;
mappedHandler = this.getHandler(processedRequest);
if (mappedHandler == null) {
this.noHandlerFound(processedRequest, response);
return;
}
HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());
String method = request.getMethod();
boolean isGet = HttpMethod.GET.matches(method);
if (isGet || HttpMethod.HEAD.matches(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if ((new ServletWebRequest(request, response)).checkNotModified(lastModified) && isGet) {
return;
}
}
// 調用預處理【重點】
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// 執行 Controller 中的業務
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
this.applyDefaultViewName(processedRequest, mv);
mappedHandler.applyPostHandle(processedRequest, response, mv);
} catch (Exception var20) {
dispatchException = var20;
} catch (Throwable var21) {
dispatchException = new NestedServletException("Handler dispatch failed", var21);
}
this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
} catch (Exception var22) {
this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
} catch (Throwable var23) {
this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
}
} finally {
if (asyncManager.isConcurrentHandlingStarted()) {
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
} else if (multipartRequestParsed) {
this.cleanupMultipart(processedRequest);
}
}
}
從上述源碼可以看出在開始執行 Controller 之前，會先調用 預處理方法 applyPreHandle，而 applyPreHandle 方法的實現源碼如下：
boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex = i++) {
// 獲取項目中使用的攔截器 HandlerInterceptor
HandlerInterceptor interceptor = (HandlerInterceptor)this.interceptorList.get(i);
if (!interceptor.preHandle(request, response, this.handler)) {
this.triggerAfterCompletion(request, response, (Exception)null);
return false;
}
}
return true;
}
從上述源碼可以看出，在 applyPreHandle 中會獲取所有的攔截器 HandlerInterceptor 并執行攔截器中的 preHandle 方法，這樣就會咱們前面定義的攔截器對應上了，如下圖所示：
此時用戶登錄權限的驗證方法就會執行，這就是攔截器的執行過程。因此，可以得出結論，攔截器的實現主要是依賴 Servlet 或 Spring 執行流程來進行攔截和功能增強的。
2、動態代理
動態代理是一種設計模式，它是指在運行時提供代理對象，來擴展目標對象的功能。在 Spring 中的，動態代理的實現手段有以下兩種:
- JDK 動態代理：通過反射機制生成代理對象，目標對象必須實現接口。
- CGLIB 動態代理：通過生成目標類的子類來實現代理，不要求目標對象實現接口。
動態代理的主要作用包括：
- 擴展目標對象的功能：如添加日志、驗證參數等。
- 控制目標對象的訪問：如進行權限控制。
- 延遲加載目標對象：在需要時才實例化目標對象。
- 遠程代理：將請求轉發到遠程的目標對象上。
“
JDK 動態代理和 CGLIB 的區別詳見：www.javacn.site/interview/spring/jdk_cglib.html
”
3、攔截器 VS 動態代理
因此，我們可以得出結論，攔截器和動態代理雖然都是用來實現功能增強的，但二者完全不同，他們的主要區別體現在以下幾點：
- 使用范圍不同：攔截器通常用于 Spring MVC 中，主要用于攔截 Controller 請求。動態代理可以使用在 Bean 中，主要用于提供 bean 的代理對象，實現對 bean 方法的攔截。
- 實現原理不同：攔截器是通過 HandlerInterceptor 接口來實現的，主要是通過 afterCompletion、postHandle、preHandle 這三個方法在請求前后進行攔截處理。動態代理主要有 JDK 動態代理和 CGLIB 動態代理，JDK 通過反射生成代理類；CGLIB 通過生成被代理類的子類來實現代理。
- 加入時機不同：攔截器是在運行階段動態加入的；動態代理是在編譯期或運行期生成的代理類。
- 使用難易程度不同：攔截器相對簡單，通過實現接口即可使用。動態代理稍微復雜，需要了解動態代理的實現原理，然后通過相應的 api 實現。
小結
在 Spring Boot 中，攔截器和動態代理都是用來實現功能增強的，但二者沒有任何關聯關系，它的區別主要體現在使用范圍、實現原理、加入時機和使用的難易程度都是不同的。
