SpringWeb 拦截器

前言

spring拦截器能帮我们实现验证是否登陆、验签校验请求是否合法、预先设置数据等功能，那么该如何设置拦截器以及它的原理如何呢，下面将进行简单的介绍
1.设置

HandlerInterceptor接口

1. public interface HandlerInterceptor {
3.         /**
4.          * Intercept the execution of a handler. Called after HandlerMapping determined
5.          * an appropriate handler object, but before HandlerAdapter invokes the handler.
6.          * <p>DispatcherServlet processes a handler in an execution chain, consisting
7.          * of any number of interceptors, with the handler itself at the end.
8.          * With this method, each interceptor can decide to abort the execution chain,
9.          * typically sending a HTTP error or writing a custom response.
10.          * <p><strong>Note:</strong> special considerations apply for asynchronous
11.          * request processing. For more details see
12.          * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}.
13.          * <p>The default implementation returns {@code true}.
14.          * @param request current HTTP request
15.          * @param response current HTTP response
16.          * @param handler chosen handler to execute, for type and/or instance evaluation
17.          * @return {@code true} if the execution chain should proceed with the
18.          * next interceptor or the handler itself. Else, DispatcherServlet assumes
19.          * that this interceptor has already dealt with the response itself.
20.          * @throws Exception in case of errors
21.          */
22.         default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
23.                         throws Exception {
25.                 return true;
26.         }
28.         /**
29.          * Intercept the execution of a handler. Called after HandlerAdapter actually
30.          * invoked the handler, but before the DispatcherServlet renders the view.
31.          * Can expose additional model objects to the view via the given ModelAndView.
32.          * <p>DispatcherServlet processes a handler in an execution chain, consisting
33.          * of any number of interceptors, with the handler itself at the end.
34.          * With this method, each interceptor can post-process an execution,
35.          * getting applied in inverse order of the execution chain.
36.          * <p><strong>Note:</strong> special considerations apply for asynchronous
37.          * request processing. For more details see
38.          * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}.
39.          * <p>The default implementation is empty.
40.          * @param request current HTTP request
41.          * @param response current HTTP response
42.          * @param handler handler (or {@link HandlerMethod}) that started asynchronous
43.          * execution, for type and/or instance examination
44.          * @param modelAndView the {@code ModelAndView} that the handler returned
45.          * (can also be {@code null})
46.          * @throws Exception in case of errors
47.          */
48.         default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
49.                         @Nullable ModelAndView modelAndView) throws Exception {
50.         }
52.         /**
53.          * Callback after completion of request processing, that is, after rendering
54.          * the view. Will be called on any outcome of handler execution, thus allows
55.          * for proper resource cleanup.
56.          * <p>Note: Will only be called if this interceptor's {@code preHandle}
57.          * method has successfully completed and returned {@code true}!
58.          * <p>As with the {@code postHandle} method, the method will be invoked on each
59.          * interceptor in the chain in reverse order, so the first interceptor will be
60.          * the last to be invoked.
61.          * <p><strong>Note:</strong> special considerations apply for asynchronous
62.          * request processing. For more details see
63.          * {@link org.springframework.web.servlet.AsyncHandlerInterceptor}.
64.          * <p>The default implementation is empty.
65.          * @param request current HTTP request
66.          * @param response current HTTP response
67.          * @param handler handler (or {@link HandlerMethod}) that started asynchronous
68.          * execution, for type and/or instance examination
69.          * @param ex exception thrown on handler execution, if any
70.          * @throws Exception in case of errors
71.          */
72.         default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
73.                         @Nullable Exception ex) throws Exception {
74.         }
76. }

复制代码

自定义拦截器需要实现HandlerInteceptor接口，该接口有三个方法：
preHandle：主要在映射适配器执行handler之前调用，若返回为true则继续往下执行handler，若返回为false则直接返回不继续处理请求
postHandle：主要在适配器执行handler之后调用 
afterCompletion：在postHandle后调用可清理一些数据，若preHandle返回false那么会调用完此方法后再返回

1. @Component
2. public class CustomInterceptor implements HandlerInterceptor {
4.   @Override
5.   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
6.       throws Exception {
7.     System.out.println("-------------拦截请求:" + request.getRequestURI() + "-------------");
8.     // 可以根据request设置请求头、或从请求头提取信息等等...
9.     return true;
10.   }
12.   @Override
13.   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
14.       @Nullable ModelAndView modelAndView) throws Exception {
15.     System.out.println("postHandle ....");
16.   }
18.   @Override
19.   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
20.       @Nullable Exception ex) throws Exception {
21.     System.out.println("afterCompletion ....");
22.   }
23. }

复制代码

接着创建配置类，实现WebMvcConfigurer接口，重写addInterceptors方法将自定义拦截器添加，并且加上@EnableWebMvc注解 （springboot项目会自动配置）

1. @Configuration
2. @EnableWebMvc
3. public class MyMvcConfigurer implements WebMvcConfigurer {
5.   @Resource
6.   private CustomInterceptor customInterceptor;
8.   @Override
9.   public void addInterceptors(InterceptorRegistry registry) {
10.     registry.addInterceptor(customInterceptor)
11.         .addPathPatterns("/**");
12.   }
13. }

复制代码

配置完之后启动项目访问某个url路径，从控制台可以看到拦截器确实生效了

 
2.原理

首先是@EnableWebMvc注解，spring会解析并导入DelegatingWebMvcConfiguration这个bean，继承关系如下，主要逻辑都写在父类WebMvcConfigurationSupport中

1. @Retention(RetentionPolicy.RUNTIME)
2. @Target(ElementType.TYPE)
3. @Documented
4. @Import(DelegatingWebMvcConfiguration.class)
5. public @interface EnableWebMvc {
6. }

复制代码

WebMvcConfigurationSupport中会创建一个映射处理器RequestMappingHandlerMapping

1. @Bean
2. public RequestMappingHandlerMapping requestMappingHandlerMapping() {
3.         RequestMappingHandlerMapping mapping = createRequestMappingHandlerMapping();
4.         mapping.setOrder(0);
5.         // 设置拦截器到mapping
6.         mapping.setInterceptors(getInterceptors());
7.         // 设置内容协商管理器
8.         mapping.setContentNegotiationManager(mvcContentNegotiationManager());
9.         // 跨域配置
10.         mapping.setCorsConfigurations(getCorsConfigurations());
12.         // 路径匹配设置
13.         PathMatchConfigurer configurer = getPathMatchConfigurer();
15.         Boolean useSuffixPatternMatch = configurer.isUseSuffixPatternMatch();
16.         if (useSuffixPatternMatch != null) {
17.                 mapping.setUseSuffixPatternMatch(useSuffixPatternMatch);
18.         }
19.         Boolean useRegisteredSuffixPatternMatch = configurer.isUseRegisteredSuffixPatternMatch();
20.         if (useRegisteredSuffixPatternMatch != null) {
21.                 mapping.setUseRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch);
22.         }
23.         Boolean useTrailingSlashMatch = configurer.isUseTrailingSlashMatch();
24.         if (useTrailingSlashMatch != null) {
25.                 mapping.setUseTrailingSlashMatch(useTrailingSlashMatch);
26.         }
28.         UrlPathHelper pathHelper = configurer.getUrlPathHelper();
29.         if (pathHelper != null) {
30.                 mapping.setUrlPathHelper(pathHelper);
31.         }
32.         PathMatcher pathMatcher = configurer.getPathMatcher();
33.         if (pathMatcher != null) {
34.                 mapping.setPathMatcher(pathMatcher);
35.         }
37.         return mapping;
38. }
41. #获取拦截器
42. protected final Object[] getInterceptors() {
43.         if (this.interceptors == null) {
44.                 InterceptorRegistry registry = new InterceptorRegistry();
45.                 // 调用DelegatingWebMvcConfiguration.addInterceptors 添加自定义的拦截器
46.                 addInterceptors(registry);
47.                 registry.addInterceptor(new ConversionServiceExposingInterceptor(mvcConversionService()));
48.                 registry.addInterceptor(new ResourceUrlProviderExposingInterceptor(mvcResourceUrlProvider()));
49.                 // 获取拦截器并根据order排序，若有匹配路径则封装成MappedInterceptor
50.                 this.interceptors = registry.getInterceptors();
51.         }
52.         return this.interceptors.toArray();
53. }

复制代码

注意这一行代码mapping.setInterceptors(getInterceptors());  getInterceptors方法会调用子类DelegatingWebMvcConfiguration的addInterceptors方法，接着会调用委托类即我们自定义配置类MyMvcConfigurer类的addInterceptors方法，将自定义的拦截器添加到拦截器注册类中，而后通过拦截器注册类获取到拦截器列表，最后将拦截器添加到映射处理器handlerMapping中，供后续使用。
最后看下请求处理的DispatcherServlet#doDispatch方法 （为了看的更清楚一点删掉了一些代码）

1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
2.         HttpServletRequest processedRequest = request;
3.         // 处理程序执行链
4.         HandlerExecutionChain mappedHandler = null;
6.         try {
7.                 ModelAndView mv = null;
8.                 Exception dispatchException = null;
10.                 try {
11.                         // Determine handler for the current request.
12.                         // 遍历handlerMapping获取能处理request的处理器，mappedHandler里封装着之前我们定义的拦截器供后续调用
13.                         mappedHandler = getHandler(processedRequest);
14.                         if (mappedHandler == null) {
15.                                 noHandlerFound(processedRequest, response);
16.                                 return;
17.                         }
19.                         // Determine handler adapter for the current request.
20.                         // 确定处理当前请求的处理适配器 RequestMappingHandlerAdapter
21.                         HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
23.                         // 执行handler之前应用拦截器执行拦截器的后置方法 返回为false表示请求不合理直接返回了
24.                         if (!mappedHandler.applyPreHandle(processedRequest, response)) {
25.                                 return;
26.                         }
28.                         // Actually invoke the handler.
29.                         // 真正执行这个HandlerMethod
30.                         mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
31.             
32.                         applyDefaultViewName(processedRequest, mv);
33.                         // 执行拦截器的后置方法
34.                         mappedHandler.applyPostHandle(processedRequest, response, mv);
35.                 }
36.                 catch (Exception ex) {
37.                         dispatchException = ex;
38.                 }
39.                 catch (Throwable err) {
40.                         // As of 4.3, we're processing Errors thrown from handler methods as well,
41.                         // making them available for @ExceptionHandler methods and other scenarios.
42.                         dispatchException = new NestedServletException("Handler dispatch failed", err);
43.                 }
44.                 processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
45.         }
46.         catch (Exception ex) {
47.                 triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
48.         }
49.         catch (Throwable err) {
50.                 triggerAfterCompletion(processedRequest, response, mappedHandler,
51.                                 new NestedServletException("Handler processing failed", err));
52.         }
53.         finally {
55.         }
56. }
59. #mappedHandler.applyPreHandle
60. boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
61.         HandlerInterceptor[] interceptors = getInterceptors();
62.         if (!ObjectUtils.isEmpty(interceptors)) {
63.                 for (int i = 0; i < interceptors.length; i++) {
64.                         HandlerInterceptor interceptor = interceptors[i];
65.                         // 前置处理为false时
66.                         if (!interceptor.preHandle(request, response, this.handler)) {
67.                                 // 触发拦截器的afterCompletion方法
68.                                 triggerAfterCompletion(request, response, null);
69.                                 return false;
70.                         }
71.                         this.interceptorIndex = i;
72.                 }
73.         }
74.         return true;
75. }

复制代码

可以看到再真正执行handler之前会调用mappedHandler.applyPreHandle 方法，遍历拦截器执行preHandle方法，若返回false则根据先前执行过的拦截器顺序倒序执行afterCompletion方法，都通过的话后续执行handler获取请求结果，再接着执行拦截器的postHandle方法最后执行afterCompletion方法。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！