springmvc拦截器入门及其执行顺序源码分析

其他 2020-02-10 10:17:25 阅读次数: 0

springmvc拦截器是偶尔会用到的一个功能，本案例来演示一个较简单的springmvc拦截器的使用，并通过源码来分析拦截器的执行顺序的控制。
具体操作步骤为：
1、maven项目引入spring依赖
2、配置web.xml中的DispatcherServlet
3、准备两个拦截器，并在springmvc配置文件中进行配置管理
4、准备业务类，该类转发到一个JSP页面，并在页面做后台打印
5、测试发送请求到业务类，查看执行顺序
6、源码分析
7、总结以及代码附件
————————————————————————————————————————————————————————————
下面开始开发！
1、maven项目引入spring依赖

[XML]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
< dependencies >
         < dependency >
             < groupId >org.springframework</ groupId >
             < artifactId >spring-context</ artifactId >
             < version >5.0.2.RELEASE</ version >
         </ dependency >
 
         < dependency >
             < groupId >org.springframework</ groupId >
             < artifactId >spring-web</ artifactId >
             < version >5.0.2.RELEASE</ version >
         </ dependency >
 
         < dependency >
             < groupId >org.springframework</ groupId >
             < artifactId >spring-webmvc</ artifactId >
             < version >5.0.2.RELEASE</ version >
         </ dependency >
 
         < dependency >
             < groupId >javax.servlet</ groupId >
             < artifactId >servlet-api</ artifactId >
             < version >2.5</ version >
             < scope >provided</ scope >
         </ dependency >
 
         < dependency >
             < groupId >javax.servlet.jsp</ groupId >
             < artifactId >jsp-api</ artifactId >
             < version >2.0</ version >
             < scope >provided</ scope >
         </ dependency >
     </ dependencies >


2、配置web.xml中的DispatcherServlet

[XML]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
<!-- 前端控制器（加载classpath:springmvc.xml 服务器启动创建servlet） -->
     < servlet >
         < servlet-name >dispatcherServlet</ servlet-name >
         < servlet-class >org.springframework.web.servlet.DispatcherServlet</ servlet-class >
         <!-- 配置初始化参数，创建完DispatcherServlet对象，加载springmvc.xml配置文件 -->
         < init-param >
             < param-name >contextConfigLocation</ param-name >
             < param-value >classpath:springmvc.xml</ param-value >
         </ init-param >
         < load-on-startup >1</ load-on-startup >
     </ servlet >
     < servlet-mapping >
         < servlet-name >dispatcherServlet</ servlet-name >
         < url-pattern >/</ url-pattern >
     </ servlet-mapping >

3、准备两个拦截器，并在springmvc配置文件中进行配置管理
两个拦截器代码如下：
[Java]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
public class MyInterceptor1 implements HandlerInterceptor {
     
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
         System.out.println( "==1-1====前置拦截器1 执行======" );
         return true ; //ture表示放行
     }
 
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
         System.out.println( "==1-2=====后置拦截器1 执行======" );
     }
 
     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
         System.out.println( "==1-3======最终拦截器1 执行======" );
     }
}

[Java]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
public class MyInterceptor2 implements HandlerInterceptor {
 
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
         System.out.println( "==2-1====前置拦截器2 执行======" );
         return true ; //ture表示放行
     }
 
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
         System.out.println( "==2-2=====后置拦截器2 执行======" );
     }
 
     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
         System.out.println( "==2-3======最终拦截器2 执行======" );
     }
}

springmvc配置如下(此处只挑选拦截器配置，具体代码参见附件)：
[XML]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
<!--配置拦截器-->
     < mvc:interceptors >
         <!--配置拦截器-->
         < mvc:interceptor >
             < mvc:mapping path = "/**" />
             < bean class = "com.itheima.interceptor.MyInterceptor1" />
         </ mvc:interceptor >
 
         < mvc:interceptor >
             < mvc:mapping path = "/**" />
             < bean class = "com.itheima.interceptor.MyInterceptor2" />
         </ mvc:interceptor >
 
     </ mvc:interceptors >

注意配置顺序拦截器1先于拦截器2，并且都拦截所有的方法
4、准备业务类，该类转发到一个JSP页面，并在页面做后台打印
[Java]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
@Controller
public class BizController {
     @RequestMapping ( "testBiz" )
     public String showUserInfo(Integer userId, Model model){
         System.out.println( ">>>>>业务代码执行-查询用户ID为:" + userId);
         User user = new User(userId);
         user.setName( "宙斯" );
         model.addAttribute( "userInfo" ,user);
         return "user_detail" ;
     }
}

响应的页面如下：
[HTML]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
< html >
< head >
     < title >detail</ title >
</ head >
< body >
     用户详情：
     ${userInfo.id}:${userInfo.name}
 
     <%System.out.print(">>>>>jsp页面的输出为：");%>
     <%System.out.println(((User)request.getAttribute("userInfo")).getName());%>
</ body >
</ html >

5、测试发送请求到业务类，查看执行顺序
启动项目后，在浏览器中访问/testBiz?userId=1，会在后台打印如下内容：
[Java]  纯文本查看 复制代码
?
1
2
3
4
5
6
7
8
== 1 - 1 ====前置拦截器 1 执行======
== 2 - 1 ====前置拦截器 2 执行======
>>>>>业务代码执行-查询用户ID为: 1
== 2 - 2 =====后置拦截器 2 执行======
== 1 - 2 =====后置拦截器 1 执行======
>>>>>jsp页面的输出为：宙斯
== 2 - 3 ======最终拦截器 2 执行======
== 1 - 3 ======最终拦截器 1 执行======

6、源码分析
通过打印结果会发现，执行顺序为：拦截器1的前置>拦截器2的前置>业务代码>拦截器2后置>拦截器1后置>拦截器2最终>拦截器1最终
我们可以通过源码来分析一下为何是该打印顺序。
最关键的为DispatcherServlet的核心方法——doDispatch。
当浏览器发送/testBiz?userId=1的请求时，会经过DispatcherServlet的doDispatch方法，省略掉部分代码，贴出如下（注释有说明）：
[Java]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
         //...
         try {
             try {
                 ModelAndView mv = null ;
                 Object dispatchException = null ;
 
                 try {
                     processedRequest = this .checkMultipart(request);
                     multipartRequestParsed = processedRequest != request;
                     //1.获取执行链
                     mappedHandler = this .getHandler(processedRequest);
                     if (mappedHandler == null ) {
                         this .noHandlerFound(processedRequest, response);
                         return ;
                     }
                     //2.获取处理器适配器
                     HandlerAdapter ha = this .getHandlerAdapter(mappedHandler.getHandler());
 
                     //...
                     //3.执行前置拦截器
                     if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                         return ;
                     }
                     //4.执行业务handler
                     mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                     if (asyncManager.isConcurrentHandlingStarted()) {
                         return ;
                     }
                     this .applyDefaultViewName(processedRequest, mv);
                     //5.执行后置拦截器
                     mappedHandler.applyPostHandle(processedRequest, response, mv);
                 } catch (Exception var20) {
                     dispatchException = var20;
                 } catch (Throwable var21) {
                     dispatchException = new NestedServletException( "Handler dispatch failed" , var21);
                 }
                 //6.处理页面响应，并执行最终拦截器
                 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 {
             //...
         }
     }

        其中，第一步中"获取执行链"，执行链内容可以截图查看：
<ignore_js_op>
可以看到我们自定义的两个拦截器按顺序保存。
        在doDispatch方法中，我们注释的第3、5、6步骤是对拦截器的执行处理，现在分别来查看第3、5、6步骤的源码。
第三步骤源码如下：
[Java]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
//3.执行前置拦截器中的详细代码
     boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
         //获得本次请求对应的所有拦截器
         HandlerInterceptor[] interceptors = this .getInterceptors();
         if (!ObjectUtils.isEmpty(interceptors)) {
             //按照拦截器顺序依次执行每个拦截器的preHandle方法.
             //并且，interceptorIndex值会一次 + 1 (该值是给后面的最终拦截器使用的)
             for ( int i = 0 ; i < interceptors.length; this .interceptorIndex = i++) {
                 HandlerInterceptor interceptor = interceptors[/color][i][color=black];
                 //只要每个拦截器不返回false,则继续执行，否则执行最终拦截器
                 if (!interceptor.preHandle(request, response, this .handler)) {
                     this .triggerAfterCompletion(request, response, (Exception) null );
                     return false ;
                 }
             }
         }
         //最终返回true
         return true ;
     }

        我们可以看到拦截器的preHandler方法是按拦截器顺序执行的。紧接着贴出第5步的后置拦截器源码：
[Java]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
//5.执行后置拦截器
     void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv) throws Exception {
         //获得本次请求对应的所有拦截器
         HandlerInterceptor[] interceptors = this .getInterceptors();
         if (!ObjectUtils.isEmpty(interceptors)) {
             //按倒叙执行每个拦截器的postHandle方法——所以我们看到先执行的拦截器2的postHandle，再执行拦截器1的postHandle
             for ( int i = interceptors.length - 1 ; i >= 0 ; --i) {
                 HandlerInterceptor interceptor = interceptors[/color][color=black];
                 interceptor.postHandle(request, response, this .handler, mv);
             }
         }
     }

        会发现，后置处理是按照拦截器顺序倒叙处理的。最后，我们贴出执行最终拦截器方法的代码：
[Java]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv, @Nullable Exception exception) throws Exception {
     //...
 
     if (mv != null && !mv.wasCleared()) {
         //处理响应
         this .render(mv, request, response);
         if (errorView) {
             WebUtils.clearErrorRequestAttributes(request);
         }
     } else if ( this .logger.isDebugEnabled()) {
         this .logger.debug( "Null ModelAndView returned to DispatcherServlet with name '" + this .getServletName() + "': assuming HandlerAdapter completed request handling" );
     }
 
     if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
         if (mappedHandler != null ) {
             //6、执行拦截器的最终方法们
             mappedHandler.triggerAfterCompletion(request, response, (Exception) null );
         }
 
     }
}

        其中，有一个render()方法，该方法会直接处理完response。再后则是触发triggerAfterCompletion方法：
[Java]  纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
//6、执行拦截器的[align=left][color=#b00000]最终[/color][/align]方法
     void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) throws Exception {
         HandlerInterceptor[] interceptors = this .getInterceptors();
         if (!ObjectUtils.isEmpty(interceptors)) {
             //倒叙执行每个拦截器(interceptorIndex为前置拦截器动态计算)的afterCompletion方法
             for ( int i = this .interceptorIndex; i >= 0 ; --i) {
                 HandlerInterceptor interceptor = interceptors[/color][/i][color=black][i];
 
                 try {
                     interceptor.afterCompletion(request, response, this .handler, ex);
                 } catch (Throwable var8) {
                     logger.error( "HandlerInterceptor.afterCompletion threw exception" , var8);
                 }
             }
         }
     }

        由此可以看到，拦截器的最终方法的执行也是按照倒叙来执行的，而且是在响应之后。
7、总结
        我们可以从源码中看到，拦截器类似于对我们业务方法的环绕通知效果，并且是通过循环集合来控制每个拦截器方法的执行顺序。
源码如下： <ignore_js_op> mvc_interceptor.zip (13.49 KB, 下载次数: 106) 
更多免费学习资料可关注:itheimaGZ获取

猜你喜欢

转载自www.cnblogs.com/zhuxiaopijingjing/p/12289885.html
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022