原文链接:http://jinnianshilongnian.iteye.com/blog/1670856
常见应用场景
1、日志记录:记录请求信息的日志,以便进行信息监控、信息统计、计算PV(Page View)等。
2、权限检查:如登录检测,进入处理器检测检测是否登录,如果没有直接返回到登录页面;
3、性能监控:有时候系统在某段时间莫名其妙的慢,可以通过拦截器在进入处理器之前记录开始时间,在处理完后记录结束时间,从而得到该请求的处理时间(如果有反向代理,如apache可以自动记录);
4、通用行为:读取cookie得到用户信息并将用户对象放入请求,从而方便后续流程使用,还有如提取Locale、Theme信息等,只要是多个处理器都需要的即可使用拦截器实现。
5、OpenSessionInView:如Hibernate,在进入处理器打开Session,在完成后关闭Session。
…………本质也是AOP(面向切面编程),也就是说符合横切关注点的所有功能都可以放入拦截器实现。
拦截器接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package org.springframework.web.servlet;
public interface HandlerInterceptor {
boolean preHandle(
HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception;
void postHandle(
HttpServletRequest request, HttpServletResponse response,
Object handler, ModelAndView modelAndView)
throws Exception;
void afterCompletion(
HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex)
throws Exception;
}
|
preHandle:预处理回调方法,实现处理器的预处理(如登录检查),第三个参数为响应的处理器;
返回值:true表示继续流程(如调用下一个拦截器或处理器);
false表示流程中断(如登录检查失败),不会继续调用其他的拦截器或处理器,此时我们需要通过response来产生响应;
postHandle:后处理回调方法,实现处理器的后处理(但在渲染视图之前),此时我们可以通过modelAndView(模型和视图对象)对模型数据进行处理或对视图进行处理,modelAndView也可能为null。
afterCompletion:整个请求处理完毕回调方法,即在视图渲染完毕时回调,如性能监控中我们可以在此记录结束时间并输出消耗时间,还可以进行一些资源清理,类似于try-catch-finally中的finally,但仅调用处理器执行链中preHandle返回true的拦截器的afterCompletion。
拦截器适配器
有时候我们可能只需要实现三个回调方法中的某一个,如果实现HandlerInterceptor接口的话,三个方法必须实现,不管你需不需要,此时spring提供了一个HandlerInterceptorAdapter适配器(一种适配器设计模式的实现),允许我们只实现需要的回调方法。
1
2
3
|
public abstract class HandlerInterceptorAdapter implements HandlerInterceptor {
//省略代码 此处所以三个回调方法都是空实现,preHandle返回true。
} |
运行流程图
正常流程:
中断流程:
DispatcherServlet内部到底是如何工作的
1
2
3
4
5
6
7
8
9
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
|
public abstract class HandlerInterceptorAdapter implements HandlerInterceptor {
//省略代码 此处所以三个回调方法都是空实现,preHandle返回true。
} //doDispatch方法
//1、处理器拦截器的预处理(正序执行)
HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
if (interceptors != null ) {
for ( int i = 0 ; i < interceptors.length; i++) {
HandlerInterceptor interceptor = interceptors[i];
if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
//1.1、失败时触发afterCompletion的调用
triggerAfterCompletion(mappedHandler, interceptorIndex,
processedRequest, response, null );
return ;
}
interceptorIndex = i; //1.2、记录当前预处理成功的索引
}
}
//2、处理器适配器调用我们的处理器
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
//当我们返回null或没有返回逻辑视图名时的默认视图名翻译
if (mv != null && !mv.hasView()) {
mv.setViewName(getDefaultViewName(request));
}
//3、处理器拦截器的后处理(逆序)
if (interceptors != null ) {
for ( int i = interceptors.length - 1 ; i >= 0 ; i--) {
HandlerInterceptor interceptor = interceptors[i];
interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);
}
}
//4、视图的渲染
if (mv != null && !mv.wasCleared()) {
render(mv, processedRequest, response);
if (errorView) {
WebUtils.clearErrorRequestAttributes(request);
}
//5、触发整个请求处理完毕回调方法afterCompletion
triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null );
|
注:以上是流程的简化代码,中间省略了部分代码,不完整。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
// triggerAfterCompletion方法 private void triggerAfterCompletion(HandlerExecutionChain mappedHandler, int interceptorIndex,
HttpServletRequest request, HttpServletResponse response, Exception ex) throws Exception {
// 5、触发整个请求处理完毕回调方法afterCompletion (逆序从1.2中的预处理成功的索引处的拦截器执行)
if (mappedHandler != null ) {
HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
if (interceptors != null ) {
for ( int i = interceptorIndex; i >= 0 ; i--) {
HandlerInterceptor interceptor = interceptors[i];
try {
interceptor.afterCompletion(request, response, mappedHandler.
getHandler(), ex);
}
catch (Throwable ex2) {
logger.error( "HandlerInterceptor.afterCompletion threw exception" , ex2);
}
}
}
}
} |
正常流程
1、拦截器实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package cn.javass.chapter5.web.interceptor;
//省略import //此处一般继承HandlerInterceptorAdapter适配器即可 public class HandlerInterceptor1 extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
System.out.println( "===========HandlerInterceptor1 preHandle" );
return true ;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response,
Object handler, ModelAndView modelAndView) throws Exception {
System.out.println( "===========HandlerInterceptor1 postHandle" );
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
System.out.println( "===========HandlerInterceptor1 afterCompletion" );
}
} |
2、控制器
1
2
3
4
5
6
7
8
9
10
|
package cn.javass.chapter5.web.controller;
//省略import public class TestController implements Controller {
@Override
public ModelAndView handleRequest(HttpServletRequest req, HttpServletResponse resp)
throws Exception {
System.out.println( "===========TestController" );
return new ModelAndView( "test" );
}
} |
3、Spring配置文件chapter5-servlet.xml
1
2
3
4
5
|
< bean name = "/test" class = "cn.javass.chapter5.web.controller.TestController" />
< bean id = "handlerInterceptor1" class = "cn.javass.chapter5.web.interceptor.HandlerInterceptor1" />
< bean id = "handlerInterceptor2" class = "cn.javass.chapter5.web.interceptor.HandlerInterceptor2" />
|
1
2
3
4
5
6
7
8
|
< bean class = "org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" >
< property name = "interceptors" >
< list >
< ref bean = "handlerInterceptor1" />
< ref bean = "handlerInterceptor2" />
</ list >
</ property >
</ bean >
|
interceptors:指定拦截器链,拦截器的执行顺序就是此处添加拦截器的顺序
4、视图页面WEB-INF/jsp/test.jsp
1
2
3
|
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <%System.out.println("==========test.jsp");%> test page |
在控制台输出 test.jsp
5、启动服务器测试
输入网址:http://localhost:9080/springmvc-chapter5/test
控制台输出:
===========HandlerInterceptor1 preHandle
===========HandlerInterceptor2 preHandle
===========TestController
===========HandlerInterceptor2 postHandle
===========HandlerInterceptor1 postHandle
==========test.jsp
===========HandlerInterceptor2 afterCompletion
===========HandlerInterceptor1 afterCompletion
中断流程
1、拦截器
HandlerInterceptor3和HandlerInterceptor4 与 之前的 HandlerInteceptor1和HandlerInterceptor2一样,只是在HandlerInterceptor4的preHandle方法返回false:
1
2
3
4
5
6
7
|
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
System.out.println( "===========HandlerInterceptor1 preHandle" );
response.getWriter().print( "break" ); //流程中断的话需要我们进行响应的处理
return false ; //返回false表示流程中断
} |
2、控制器
流程中断不会执行到控制器,使用之前的TestController控制器。
3、Spring配置文件chapter5-servlet.xml
1
2
3
4
|
< bean id = "handlerInterceptor3" class = "cn.javass.chapter5.web.interceptor.HandlerInterceptor3" />
< bean id = "handlerInterceptor4" class = "cn.javass.chapter5.web.interceptor.HandlerInterceptor4" />
|
1
2
3
4
5
6
7
8
|
< bean class = "org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" >
< property name = "interceptors" >
< list >
< ref bean = "handlerInterceptor3" />
< ref bean = "handlerInterceptor4" />
</ list >
</ property >
</ bean >
|
interceptors:指定拦截器链,拦截器的执行顺序就是此处添加拦截器的顺序;
4、视图页面
流程中断,不会执行到视图渲染。
5、启动服务器测试
输入网址:http://localhost:9080/springmvc-chapter5/test
控制台输出:
===========HandlerInterceptor3 preHandle
===========HandlerInterceptor4 preHandle
===========HandlerInterceptor3 afterCompletion
应用
性能监控
如记录一下请求的处理时间,得到一些慢请求(如处理时间超过500毫秒),从而进行性能改进,一般的反向代理服务器如apache都具有这个功能,但此处我们演示一下使用拦截器怎么实现。
实现分析:
1、在进入处理器之前记录开始时间,即在拦截器的preHandle记录开始时间;
2、在结束请求处理之后记录结束时间,即在拦截器的afterCompletion记录结束实现,并用结束时间-开始时间得到这次请求的处理时间。
问题:
我们的拦截器是单例,因此不管用户请求多少次都只有一个拦截器实现,即线程不安全,那我们应该怎么记录时间呢?
解决方案是使用ThreadLocal,它是线程绑定的变量,提供线程局部变量(一个线程一个ThreadLocal,A线程的ThreadLocal只能看到A线程的ThreadLocal,不能看到B线程的ThreadLocal)。
代码实现:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
package cn.javass.chapter5.web.interceptor;
public class StopWatchHandlerInterceptor extends HandlerInterceptorAdapter {
private NamedThreadLocal<Long> startTimeThreadLocal =
new NamedThreadLocal<Long>( "StopWatch-StartTime" );
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
long beginTime = System.currentTimeMillis(); //1、开始时间
startTimeThreadLocal.set(beginTime); //线程绑定变量(该数据只有当前请求的线程可见)
return true ; //继续流程
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) throws Exception {
long endTime = System.currentTimeMillis(); //2、结束时间
long beginTime = startTimeThreadLocal.get(); //得到线程绑定的局部变量(开始时间)
long consumeTime = endTime - beginTime; //3、消耗的时间
if (consumeTime > 500 ) { //此处认为处理时间超过500毫秒的请求为慢请求
//TODO 记录到日志文件
System.out.println(
String.format( "%s consume %d millis" , request.getRequestURI(), consumeTime));
}
}
} |
NamedThreadLocal:Spring提供的一个命名的ThreadLocal实现。
在测试时需要把stopWatchHandlerInterceptor放在拦截器链的第一个,这样得到的时间才是比较准确的。
登录检测
在访问某些资源时(如订单页面),需要用户登录后才能查看,因此需要进行登录检测。
流程:
1、访问需要登录的资源时,由拦截器重定向到登录页面;
2、如果访问的是登录页面,拦截器不应该拦截;
3、用户登录成功后,往cookie/session添加登录成功的标识(如用户编号);
4、下次请求时,拦截器通过判断cookie/session中是否有该标识来决定继续流程还是到登录页面;
5、在此拦截器还应该允许游客访问的资源。
拦截器代码如下所示:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
@Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) throws Exception {
//1、请求到登录页面 放行
if (request.getServletPath().startsWith(loginUrl)) {
return true ;
}
//2、TODO 比如退出、首页等页面无需登录,即此处要放行 允许游客的请求
//3、如果用户已经登录 放行
if (request.getSession().getAttribute( "username" ) != null ) {
//更好的实现方式的使用cookie
return true ;
}
//4、非法请求 即这些请求需要登录后才能访问
//重定向到登录页面
response.sendRedirect(request.getContextPath() + loginUrl);
return false ;
} |
提示:推荐能使用servlet规范中的过滤器Filter实现的功能就用Filter实现,因为HandlerInteceptor只有在Spring Web MVC环境下才能使用,因此Filter是最通用的、最先应该使用的。如登录这种拦截器最好使用Filter来实现。
相关推荐
在本文中,我们讨论了三种解决SpringMVC拦截器拦截静态资源文件的方法,并对这些方法的优劣进行了分析。 方案一是在拦截器中排除静态资源路径。在SpringMVC的配置文件中(通常是spring-mvc.xml),可以通过配置元素...
SpringMVC 拦截器项目是一个典型的 Web 应用开发示例,它利用 SpringMVC 框架中的拦截器(Interceptor)机制来实现特定的功能,如权限控制、日志记录、性能统计等。SpringMVC 是 Spring 框架的一部分,专为构建基于 ...
这个名为“SpringMVC拦截器源代码.zip”的压缩包可能包含了Spring MVC拦截器的实现源码,这对于理解和学习如何自定义拦截器以增强应用功能非常有帮助。 1. **拦截器的基本概念** - 拦截器是AOP(面向切面编程)的...
### SpringMVC拦截器 #### 一、拦截器概述 拦截器(Interceptor)是一种轻量级、低侵入式的AOP实现方式,在SpringMVC框架中有着广泛的应用。它主要用于处理那些与业务逻辑无关但又频繁出现的功能需求,如日志记录...
如果一个请求被拦截器链中的某个拦截器阻止,后面的拦截器都不会被执行。 8. **应用场景** - 权限验证:在请求到达Controller之前检查用户是否有权限访问。 - 日志记录:记录用户的请求信息,便于跟踪和调试。 -...
在Spring MVC框架中,拦截器(Interceptor)是一个强大的工具,用于在请求被控制器处理之前或之后执行特定的逻辑。它们可以用来实现通用的功能,如权限验证、日志记录、性能统计等,避免在每个控制器方法中重复编写...
本实验报告将探讨如何利用 SpringMVC 的拦截器(Interceptor)来实现用户登录权限验证,确保只有已登录的用户才能访问特定的受保护资源。 首先,我们来看一下实验的基本步骤: 1. 创建 `User` 类:这是表示用户...
综上所述,本项目是一个适合初学者了解和实践SpringMVC拦截器功能的小程序。通过学习和实践,你可以掌握如何使用拦截器实现登录验证和安全退出,同时加深对Intelli IDEA的使用理解。在实际应用中,拦截器常用于权限...
SpringMVC拦截器是基于AOP(面向切面编程)的概念实现的,它们遵循HandlerInterceptor接口。这个接口定义了三个方法: 1. `preHandle`: 在请求被处理器处理之前调用,返回`true`表示继续执行处理器,`false`则中断...
SpringMVC拦截器是实现登录认证的一种常见方法,它允许开发者在请求被实际处理之前或之后执行特定的逻辑。本文将深入探讨如何利用SpringMVC拦截器来实现这一功能。 首先,了解SpringMVC的核心组件是必要的。...
在Spring MVC框架中,拦截器(Interceptor)是一个强大的工具,用于在请求被控制器处理之前或之后执行特定的逻辑。它们可以用来实现通用的功能,如权限验证、日志记录、性能统计等,避免在每个控制器方法中重复代码...
在这个过程中,`SessionListener`、持久化`Session`和`Springmvc拦截器`是关键组件,让我们逐一深入探讨。 ### SessionListener `SessionListener`是Java Servlet API中的一个接口,用于监听`HttpSession`事件。...
SpringMVC 拦截器实现单点登录是一种常见的安全控制机制,主要用于确保在同一时间只有一个用户能够使用同一账号进行操作。这种功能在多用户、多设备登录的环境中尤为重要,可以防止用户账号被盗用或者误操作。 单点...
SpringMVC 拦截器是 Spring MVC 框架中的一个重要组成部分,它允许开发者在控制器处理请求之前或之后执行自定义逻辑。拦截器可以用于实现登录检查、权限验证、日志记录、性能监控等多种功能。本文将详细介绍 ...
11SpringMVC拦截器.md
SpringMVC 拦截器(HandlerInterceptor)是 SpringMVC 框架中的一个重要组成部分,它在请求处理之前、之后以及视图渲染之前执行,提供了预处理和后处理的功能。这个入门实例是为了帮助开发者理解如何在实际项目中...
SpringMVC拦截器配置及运行流程解析 SpringMVC拦截器是指在SpringMVC框架中,用于拦截和处理请求的组件。拦截器可以在请求处理之前、之后或抛出异常时执行某些操作,例如身份验证、日志记录、异常处理等。SpringMVC...
"springMVC拦截器HandlerInterceptor用法代码示例" springMVC拦截器HandlerInterceptor是一种非常重要的技术,它可以帮助我们拦截用户的请求,从而知道页面请求的是哪个class的哪个方法。本文将详细介绍springMVC...