過濾器 (Filter) 和攔截器 (Interceptor)-有解無憂

1.過濾器 (Filter)

過濾器的配置比較簡單，直接實作Filter 介面即可，也可以通過@WebFilter注解實作對特定URL攔截，看到Filter 介面中定義了三個方法，

init() ：該方法在容器啟動初始化過濾器時被呼叫，它在 Filter 的整個生命周期只會被呼叫一次，注意：這個方法必須執行成功，否則過濾器會不起作用，
doFilter() ：容器中的每一次請求都會呼叫該方法， FilterChain 用來呼叫下一個過濾器 Filter，
destroy()：當容器銷毀過濾器實體時呼叫該方法，一般在方法中銷毀或關閉資源，在過濾器 Filter 的整個生命周期也只會被呼叫一次

@Component
public class MyFilter implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

        System.out.println("Filter 前置");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        System.out.println("Filter 處理中");
        filterChain.doFilter(servletRequest, servletResponse);
    }

    @Override
    public void destroy() {

        System.out.println("Filter 后置");
    }
}

2.攔截器 (Interceptor)

攔截器它是鏈式呼叫，一個應用中可以同時存在多個攔截器Interceptor，一個請求也可以觸發多個攔截器，而每個攔截器的呼叫會依據它的宣告順序依次執行，首先撰寫一個簡單的攔截器處理類，請求的攔截是通過HandlerInterceptor 來實作，看到HandlerInterceptor 介面中也定義了三個方法，

preHandle() ：這個方法將在請求處理之前進行呼叫，注意：如果該方法的回傳值為false ,將視為當前請求結束，不僅自身的攔截器會失效，還會導致其他的攔截器也不再執行，
postHandle()：只有在 preHandle() 方法回傳值為true 時才會執行，會在Controller 中的方法呼叫之后，DispatcherServlet 回傳渲染視圖之前被呼叫，有意思的是：postHandle() 方法被呼叫的順序跟 preHandle() 是相反的，先宣告的攔截器 preHandle() 方法先執行，而postHandle()方法反而會后執行，
afterCompletion()：只有在 preHandle() 方法回傳值為true 時才會執行，在整個請求結束之后， DispatcherServlet 渲染了對應的視圖之后執行，

@Component
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        System.out.println("Interceptor 前置");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

        System.out.println("Interceptor 處理中");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

        System.out.println("Interceptor 后置");
    }
}

將自定義好的攔截器處理類進行注冊，并通過addPathPatterns、excludePathPatterns等屬性設定需要攔截或需要排除的 URL，

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
        registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**");
    }
}

3.區別

過濾器和攔截器均體現了AOP的編程思想，都可以實作諸如日志記錄、登錄鑒權等功能，但二者的不同點也是比較多的，接下來一一說明，

3.11、實作原理不同

過濾器和攔截器底層實作方式大不相同，過濾器是基于函式回呼的，攔截器則是基于Java的反射機制（動態代理）實作的，這里重點說下過濾器！在我們自定義的過濾器中都會實作一個 doFilter()方法，這個方法有一個FilterChain 引數，而實際上它是一個回呼介面，ApplicationFilterChain是它的實作類，這個實作類內部也有一個 doFilter() 方法就是回呼方法，

public interface FilterChain {
    void doFilter(ServletRequest var1, ServletResponse var2) throws IOException, ServletException;
}

在這里插入圖片描述
ApplicationFilterChain里面能拿到我們自定義的xxxFilter類，在其內部回呼方法doFilter()里呼叫各個自定義xxxFilter過濾器，并執行 doFilter() 方法，

public final class ApplicationFilterChain implements FilterChain {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response) {
            ...//省略
            internalDoFilter(request,response);
    }
 
    private void internalDoFilter(ServletRequest request, ServletResponse response){
    if (pos < n) {
            //獲取第pos個filter    
            ApplicationFilterConfig filterConfig = filters[pos++];        
            Filter filter = filterConfig.getFilter();
            ...
            filter.doFilter(request, response, this);
        }
    }
 
}

而每個xxxFilter 會先執行自身的 doFilter() 過濾邏輯，最后在執行結束前會執行filterChain.doFilter(servletRequest, servletResponse)，也就是回呼ApplicationFilterChain的doFilter() 方法，以此回圈執行實作函式回呼，

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        filterChain.doFilter(servletRequest, servletResponse);
    }

3.2 使用范圍不同

我們看到過濾器實作的是 javax.servlet.Filter 介面，而這個介面是在Servlet規范中定義的，也就是說過濾器Filter 的使用要依賴于Tomcat等容器，導致它只能在web程式中使用，
在這里插入圖片描述
而攔截器(Interceptor) 它是一個Spring組件，并由Spring容器管理，并不依賴Tomcat等容器，是可以單獨使用的，不僅能應用在web程式中，也可以用于Application、Swing等程式中，

3.3 觸發時機不同

在這里插入圖片描述
過濾器Filter是在請求進入容器后，但在進入servlet之前進行預處理，請求結束是在servlet處理完以后，攔截器 Interceptor 是在請求進入servlet后，在進入Controller之前進行預處理的，Controller 中渲染了對應的視圖之后請求結束，

3.4 攔截的請求范圍不同

在上邊我們已經同時配置了過濾器和攔截器，再建一個Controller接收請求測驗一下，

@Controller
@RequestMapping()
public class Test {

    @RequestMapping("/test1")
    @ResponseBody
    public String test1(String a) {
        System.out.println("我是controller");
        return null;
    }
}

專案啟動程序中發現，過濾器的init()方法，隨著容器的啟動進行了初始化，
此時瀏覽器發送請求，F12 看到居然有兩個請求，一個是我們自定義的 Controller 請求，另一個是訪問靜態圖示資源的請求，
在這里插入圖片描述
看到控制臺的列印日志如下：

執行順序：Filter 處理中 -> Interceptor 前置 -> 我是controller -> Interceptor 處理中 -> Interceptor 處理后

Filter 處理中
Interceptor 前置
Interceptor 處理中
Interceptor 后置
Filter 處理中

3.5 注入Bean情況不同

在實際的業務場景中，應用到過濾器或攔截器，為處理業務邏輯難免會引入一些service服務，
下邊我們分別在過濾器和攔截器中都注入service，看看有什么不同？

@Component
public class TestServiceImpl implements TestService {

    @Override
    public void a() {
        System.out.println("我是方法A");
    }
}

過濾器中注入service，發起請求測驗一下，日志正常列印出“我是方法A”，

@Autowired
    private TestService testService;

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        System.out.println("Filter 處理中");
        testService.a();
        filterChain.doFilter(servletRequest, servletResponse);
    }

Filter 處理中
我是方法A
Interceptor 前置
我是controller
Interceptor 處理中
Interceptor 后置

在攔截器中注入service，發起請求測驗一下，竟然報錯了，debug跟一下發現注入的service怎么是Null啊？
在這里插入圖片描述
這是因為加載順序導致的問題，攔截器加載的時間點在springcontext之前，而Bean又是由spring進行管理，

攔截器：老子今天要進洞房；
Spring：兄弟別鬧，你媳婦我還沒生出來呢！

解決方案也很簡單，我們在注冊攔截器之前，先將Interceptor 手動進行注入，注意：在registry.addInterceptor()注冊的是getMyInterceptor() 實體，

@Configuration
public class MyMvcConfig implements WebMvcConfigurer {

    @Bean
    public MyInterceptor getMyInterceptor(){
        System.out.println("注入了MyInterceptor");
        return new MyInterceptor();
    }
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(getMyInterceptor()).addPathPatterns("/**");
    }
}

3.6 控制執行順序不同

實際開發程序中，會出現多個過濾器或攔截器同時存在的情況，不過，有時我們希望某個過濾器或攔截器能優先執行，就涉及到它們的執行順序，

過濾器用@Order注解控制執行順序，通過@Order控制過濾器的級別，值越小級別越高越先執行，

@Order(Ordered.HIGHEST_PRECEDENCE)
@Component
public class MyFilter2 implements Filter {}

攔截器默認的執行順序，就是它的注冊順序，也可以通過Order手動設定控制，值越小越先執行，

 @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor2()).addPathPatterns("/**").order(2);
        registry.addInterceptor(new MyInterceptor1()).addPathPatterns("/**").order(1);
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**").order(3);
    }

看到輸出結果發現，先宣告的攔截器 preHandle() 方法先執行，而postHandle()方法反而會后執行，

postHandle() 方法被呼叫的順序跟 preHandle() 居然是相反的！如果實際開發中嚴格要求執行順序，那就需要特別注意這一點，

Interceptor1 前置
Interceptor2 前置
Interceptor 前置
我是controller
Interceptor 處理中
Interceptor2 處理中
Interceptor1 處理中
Interceptor 后置
Interceptor2 處理后
Interceptor1 處理后

那為什么會這樣呢？得到答案就只能看原始碼了，我們要知道controller 中所有的請求都要經過核心組件DispatcherServlet路由，都會執行它的 doDispatch() 方法，而攔截器postHandle()、preHandle()方法便是在其中呼叫的，

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
 
        try {
         ...........
            try {
 
                // 獲取可以執行當前Handler的配接器
                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                // Process last-modified header, if supported by the handler.
                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (logger.isDebugEnabled()) {
                        logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                    }
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }
                // 注意： 執行Interceptor中PreHandle()方法
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // 注意：執行Handle【包括我們的業務邏輯，當拋出例外時會被Try、catch到】
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }
                applyDefaultViewName(processedRequest, mv);

                // 注意：執行Interceptor中PostHandle 方法【拋出例外時無法執行】
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
        }
        ...........
    }

看看兩個方法applyPreHandle(）、applyPostHandle(）具體是如何被呼叫的，就明白為什么postHandle()、preHandle() 執行順序是相反的了，

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);
            }
        }
    }

發現兩個方法中在呼叫攔截器陣列 HandlerInterceptor[] 時，回圈的順序竟然是相反的，，，，導致postHandle()、preHandle() 方法執行的順序相反，

在這里插入圖片描述

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/281767.html

標籤：java

上一篇：學Java怎么看API（詳細圖解）+查看Java原始碼（IDEA）

下一篇：java學生宿舍管理系統，來了就點個贊再走唄，即將畢業的兄弟有福了！

過濾器 (Filter) 和 攔截器 (Interceptor)