SpringMVC Interceptor 拦截器

HandlerInterceptor 拦截器 

（1）preHandle: 在执行controller处理之前执行，返回值为boolean ,返回值为true时接着执行postHandle和afterCompletion，如果我们返回false则中断执行

（2）postHandle:在执行controller的处理后，在ModelAndView处理前执行

（3）afterCompletion ：在DispatchServlet执行完ModelAndView之后执行

Source Code

public interface HandlerInterceptor {

    /**
     * Intercept the execution of a handler. Called after HandlerMapping determined
     * an appropriate handler object, but before HandlerAdapter invokes the handler.
     * <p>DispatcherServlet processes a handler in an execution chain, consisting
     * of any number of interceptors, with the handler itself at the end.
     * With this method, each interceptor can decide to abort the execution chain,
     * typically sending an HTTP error or writing a custom response.
     * <p><strong>Note:</strong> special considerations apply for asynchronous
     * request processing. For more details see
     * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}.
     * <p>The default implementation returns {@code true}.
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler chosen handler to execute, for type and/or instance evaluation
     * @return {@code true} if the execution chain should proceed with the
     * next interceptor or the handler itself. Else, DispatcherServlet assumes
     * that this interceptor has already dealt with the response itself.
     * @throws Exception in case of errors
     */
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {

        return true;
    }

    /**
     * Intercept the execution of a handler. Called after HandlerAdapter actually
     * invoked the handler, but before the DispatcherServlet renders the view.
     * Can expose additional model objects to the view via the given ModelAndView.
     * <p>DispatcherServlet processes a handler in an execution chain, consisting
     * of any number of interceptors, with the handler itself at the end.
     * With this method, each interceptor can post-process an execution,
     * getting applied in inverse order of the execution chain.
     * <p><strong>Note:</strong> special considerations apply for asynchronous
     * request processing. For more details see
     * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}.
     * <p>The default implementation is empty.
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler handler (or {@link HandlerMethod}) that started asynchronous
     * execution, for type and/or instance examination
     * @param modelAndView the {@code ModelAndView} that the handler returned
     * (can also be {@code null})
     * @throws Exception in case of errors
     */
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            @Nullable ModelAndView modelAndView) throws Exception {
    }

    /**
     * Callback after completion of request processing, that is, after rendering
     * the view. Will be called on any outcome of handler execution, thus allows
     * for proper resource cleanup.
     * <p>Note: Will only be called if this interceptor's {@code preHandle}
     * method has successfully completed and returned {@code true}!
     * <p>As with the {@code postHandle} method, the method will be invoked on each
     * interceptor in the chain in reverse order, so the first interceptor will be
     * the last to be invoked.
     * <p><strong>Note:</strong> special considerations apply for asynchronous
     * request processing. For more details see
     * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}.
     * <p>The default implementation is empty.
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler handler (or {@link HandlerMethod}) that started asynchronous
     * execution, for type and/or instance examination
     * @param ex any exception thrown on handler execution, if any; this does not
     * include exceptions that have been handled through an exception resolver
     * @throws Exception in case of errors
     */
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
            @Nullable Exception ex) throws Exception {
    }

}

拦截器的功能

　　从接口中的3个方法，可以看出，类似于AOP的操作，可以完成在请求到达方法之前，完成方法之后，以及视图解析之前被调用，例如在调用方法前做用户权限的验证，日志的记录等等。HandlerInterceptorAdapter 类实现了HandlerInterceptor接口，自定义的拦截器也可以通过继承该类来实现拦截。

拦截器流程图

　　拦截器的执行过程是有序的，多个interceptor可以在 xml中 进行配置。

<mvc:interceptors>
        <bean class="com.interceptor.TestInterceptor" />
        <bean class="com.interceptor.DataInterceptor" /> 
</mvc:interceptors>

[2020-05-20 11:12:30,645] Artifact springmvcdemo:war exploded: Artifact is deployed successfully
[2020-05-20 11:12:30,645] Artifact springmvcdemo:war exploded: Deploy took 2,023 milliseconds
TestInterceptor preHandle....
DataInterceptor preHandle....
DataInterceptor postHandle....
TestInterceptor postHandle....
DataInterceptor afterCompletion....
TestInterceptor afterCompletion....

Single Interceptor

Multi Interceptor

interceptor1配置在interceptor2 之前

 

Source Code 2

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ……… 
        try {
            ……… 
            try {
                ……… 
　　　　　        mappedHandler = getHandler(processedRequest);

                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // Actually invoke the handler.
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                ……… 
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                ……… 
            }
            catch (Throwable err) {
                ……… 
            }
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) {
            triggerAfterCompletion(processedRequest, response, mappedHandler,
                    new NestedServletException("Handler processing failed", err));
        }
         
    }

篇幅有限以上只是拦截器的基本玩法，细节点并未涉及，有时间再写里面的 HandlerExecutionChain