上篇博文我在博客中讲到如何使用spring mvc框架来实现文件的上传和下载，今天小钱给大家再来分享和介绍spring mvc框架中相当重要的一块功能——拦截器。
关于拦截器的概念我在这里就不多说了，大家可以上网百度或者看别人写的具体博客，我今天要说的是拦截器在实际开发中它有什么作用，怎样用spring mvc拦截器来实现可拔插方式管理各种功能。interceptor拦截器，它的主要作用就是拦截用户的请求并进行相应的处理。什么意思呢？比如说：通过拦截器来进行用户的权限验证，或者是用来判断用户是否已经登录等。
spring mvc拦截器是可拔插式的设计。如果需要某个拦截器，只需要在配置文件中应用该拦截器即可，如果不需要使用拦截器，只需要在配置文件中取消其应用拦截器。不管是否应用某个拦截器，对spring mvc框架不会有任何的影响。本文将介绍handlerinterceptor接口和演示“spring mvc拦截器实现用户权限验证”项目案例来学习、掌握拦截器。
本项目源码下载：spring mvc拦截器实现用户权限验证
handlerinterceptor接口
spring mvc中的interceptor拦截器拦截的请求是通过实现handlerinterceptor接口来完成的。在spring mvc中定义一个interceptor拦截器非常简单，通过在要定义的interceptor拦截器类中实现spring的handlerinterceptor接口，或是继承抽象类handlerinterceptoradapter。
handlerinterceptor接口定义了三个方法，spring mvc就是通过这三个方法来对用户的请求进行拦截处理的，下面对这三个方法进行具体的详解：
（1）boolean prehandle(httpservletrequest request,httpservletresponse response,object handle)。顾名思义，这个方法将在请求处理之前被调用。spring mvc中的interceptor实行的是链式调用，即在一个应用中或者说在一个请求中可以同时存在多个interceptor。每个interceptor的调用会依据它的声明顺序依次执行，而且最先执行的是interceptor中的prehandle方法，所以可以在这个方法中进行一些前置的初始化操作或者是对当前请求的一个预处理，也可以在这个方法中进行一些判断来决定请求是否要继续进行下去。该方法的返回值是boolean类型的，当返回值为false时，表示请求结束，后续的interceptor和controller都不会再执行；当返回值为true时就会继续调用下一个interceptor的prehandle方法；如果已经是最后一个interceptor，就会调用当前请求的controller方法。
（2）void posthandle(httpservletrequest request,httpservletresponse response,object handler，modelandview mv)。该方法和之后的aftercompletion方法都只能在当前所属的interceptor的prehandle方法的返回值为true时才能被调用。posthandle方法，顾名思义，就是在当前请求被处理之后，也就是controller方法被调用之后执行，但是它会在dispatcherservlet进行视图返回渲染之前被调用，所以我们可以在这个方法中对controller处理之后的modelandview对象进行操作。posthandle方法被调用的方向跟prehandle是相反的，也就是说先声明的interceptor的posthandle方法反而会后执行，这和struts2里面的interceptor的执行过程类似。
（3）void aftercompletion(httpservletrequest request,httpservletresponse response,object handler,exception exception)。 该方法也是在当前所属的interceptor的prehandle方法的返回值为true时才会执行。顾名思义，该方法将在这个请求结束之后，也就是在dispatcherservlet渲染了对应的视图之后执行。这个方法的主要作用就是进行资源整理。
拦截器实现用户权限验证
本文将通过spring mvc拦截器完成一个用户权限验证的功能。即用户必须登录之后才可以访问这个web网站的首页，如果没有登录就直接访问网站首页，则拦截器会拦截请求，并将请求重新转发到登录页面，同时提示用户“需要先登录再访问网站”，由于是演示案例，所以成功登录之后的网站页面我们直接是拼的一个网页显示给用户。本项目作为测试案例，我就不创建maven项目了，直接创建的是一个dynamic web project（动态的web项目），项目名称为：interceptor，本项目采用tomcat 8作为web服务器，我们需要在项目中引入以下jar包，jar包我就截图演示了，附件源码中lib文件夹下会有，这里直接给一个项目的目录结构，如下图：
首先呢，我们要做一个网页，这个网页就是用来提示用户的登录信息，提示输入用户名和密码，在此我们在项目的webcontent/web-inf/content文件夹中创建一个loginform.jsp，这是一个jsp文件，具体代码如下：
|
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
|
<%@ page language="java" contenttype="text/html; charset=utf-8"
pageencoding="utf-8"%>
<!doctype html public "-//w3c//dtd html 4.01 transitional//en" "http://www.w3.org/tr/html4/loose.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<title>登录页面</title>
</head>
<body>
<h2>用于演示拦截器登录页面</h2>
<form action="login" method="post">
<!-- 提示信息 -->
<font color="red">${requestscope.message }</font>
<table>
<tr>
<td><label>登录名: </label></td>
<td><input type="text" id="loginname" name="loginname" ></td>
</tr>
<tr>
<td><label>密码: </label></td>
<td><input type="password" id="password" name="password" ></td>
</tr>
<tr>
<td><input type="submit" value="登录"></td>
</tr>
</table>
</form>
</body>
</html>
|
这时我们需要进行处理/login的请求，我们需要写请求的功能代码，在src目录下创建“cn.edu.jit.controller”包，在创建一个usercontroller类，用来处理用户请求。具体代码如下：
|
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
40
41
42
43
|
package cn.edu.jit.controller;
import javax.servlet.http.httpsession;
import cn.edu.jit.domain.user;
import org.springframework.stereotype.controller;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.servlet.modelandview;
/**
* 处理用户请求控制器
*/
@controller
public class usercontroller {
/**
* 处理/login请求
*/
@requestmapping(value="/login")
public modelandview login(string loginname,string password,modelandview mv,httpsession session) {
//模拟数据库根据登录名和密码查找用户，判断用户登录
if(loginname != null && loginname.equals("钱春华")
&& password
!= null
&& password.equals("123456")) {
//模拟创建用户
user user = new user();
user.setloginname(loginname);
user.setpassword(password);
user.setusername("钱春华");
//登录成功，将user对象设置到httpsession作用范围域
session.setattribute("user", user);
//转发到main请求
mv.setviewname("redirect:main");
} else {
//登录失败，设置失败提示信息，并跳转到登录页面
mv.addobject("message", "登录名或密码错误，请重新输入!");
mv.setviewname("loginform");
}
return mv;
}
}
|
usercontrolle类的login方法用来处理登录的请求，本项目没有使用数据库存储数据，只是简单的模拟了用户的登录，只要用户输入登录名是“钱春华”，密码是“123456”，则验证通过，并创建一个user对象保存到httpsession当中，同时将请求使用客户端跳转到main请求：如果登录失败提示信息到modelandview对象，同时将请求使用客户端跳转到loginfrom请求，即登录页面。
同样地，我们刚刚写了一个用户的登录请求，我们接下来要处理/main请求，用于实现登录之后给用户显示书的详细定价以及出版信息，我们还在“cn.edu.jit.controller”包中创建一个名为bookcontroller类，用于处理图书请求。具体代码如下：
|
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
|
package cn.edu.jit.controller;
import java.util.arraylist;
import java.util.list;
import cn.edu.jit.domain.book;
import org.springframework.stereotype.controller;
import org.springframework.ui.model;
import org.springframework.web.bind.annotation.requestmapping;
/**
* 处理图书请求控制器
* @author 钱春华
*/
@controller
public class bookcontroller {
/**
* 处理/main请求
*/
@requestmapping(value="/main")
public string main(model model) {
//模拟数据库获得所有图书集合
list<book> book_list = new arraylist<book>();
book_list.add(new book("java.jpg","java核心技术1","周立新 编著",90.00));
book_list.add(new book("ee.jpg","android第一行代码","郭霖 编著",72.50));
book_list.add(new book("android.jpg","spring+mybatis企业应用实战","李刚 编著",58.00));
book_list.add(new book("ajax.jpg","springmvc实战","alex bretet 编著",99.00));
//将图书集合添加到model当中
model.addattribute("book_list", book_list);
//跳转到main页面
return "main";
}
}
|
bookcontroller类中的main方法用来处理网站首页的请求，该方法获得所有图书的信息，并将它们设置到model当中，然后传递到main页面。由于本案例没有使用数据库存储数据，只是简单的创建了一个集合模拟从数据库获取图书信息。
下面是登录成功后访问网页的main.jsp代码，该jsp代码位于webcontent/web-inf/content文件夹中。如下具体代码所示：
|
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
|
<%@ page language="java" contenttype="text/html; charset=utf-8"
pageencoding="utf-8"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!doctype html public "-//w3c//dtd html 4.01 transitional//en" "http://www.w3.org/tr/html4/loose.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<title>首页</title>
<style type="text/css">
table{border-collapse:collapse;border-spacing:0;border-left:1px solid #888;border-top:1px solid #888;background:#efefef;}
th,td{border-right:1px solid #888;border-bottom:1px solid #888;padding:5px 15px;}
th{font-weight:bold;background:#ccc;}
</style>
</head>
<body>
<h2 align="center">欢迎[${sessionscope.user.username }]访问</h2>
<br>
<table border="1" align="center">
<tr>
<th>封面</th><th>图书名称</th><th>作者</th><th>出版价格</th>
</tr>
<c:foreach items="${requestscope.book_list }" var="book">
<tr>
<td><img src="images/${book.image }" height="60"></td>
<td>${book.name }</td>
<td>${book.author }</td>
<td>${book.price }</td>
</tr>
</c:foreach>
</table>
</body>
</html>
|
接下来，我将设计拦截器验证用户是否登录，如果用户没有登录，不可以访问除登录页面和登录请求的所有controller。我们在src文件下创建名为“cn.edu.jit.interceptor”这个包，在这个包下创建“authorizationinterceptor”类，用于演示拦截器验证用户是否登录。具体代码如下：
|
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
package cn.edu.jit.interceptor;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import cn.edu.jit.domain.user;
import org.springframework.web.servlet.handlerinterceptor;
import org.springframework.web.servlet.modelandview;
/**
* 拦截器必须实现handlerinterceptor接口
*/
public class authorizationinterceptor implements handlerinterceptor {
//不拦截"/loginform"和"/login"请求
private static final string[] ignore_uri = {"/loginform", "/login"};
/**
* 该方法将在整个请求完成之后执行， 主要作用是用于清理资源的，
* 该方法也只能在当前interceptor的prehandle方法的返回值为true时才会执行。
*/
@override
public void aftercompletion(httpservletrequest request,
httpservletresponse response, object handler, exception exception)
throws exception {
system.out.println("authorizationinterceptor aftercompletion --> ");
}
/**
* 该方法将在controller的方法调用之后执行， 方法中可以对modelandview进行操作 ，
* 该方法也只能在当前interceptor的prehandle方法的返回值为true时才会执行。
*/
@override
public void posthandle(httpservletrequest request, httpservletresponse response,
object handler, modelandview mv) throws exception {
system.out.println("authorizationinterceptor posthandle --> ");
}
/**
* prehandle方法是进行处理器拦截用的，该方法将在controller处理之前进行调用，
* 该方法的返回值为true拦截器才会继续往下执行，该方法的返回值为false的时候整个请求就结束了。
*/
@override
public boolean prehandle(httpservletrequest request, httpservletresponse response,
object handler) throws exception {
system.out.println("authorizationinterceptor prehandle --> ");
//flag变量用于判断用户是否登录，默认为false
boolean flag = false;
//获取请求的路径进行判断
string servletpath = request.getservletpath();
//判断请求是否需要拦截
for (string s : ignore_uri) {
if (servletpath.contains(s)) {
flag = true;
break;
}
}
//拦截请求
if (!flag) {
//1.获取session中的用户
user user = (user) request.getsession().getattribute("user");
//2.判断用户是否已经登录
if(user == null) {
//如果用户没有登录，则设置提示信息，跳转到登录页面
system.out.println("authorizationinterceptor拦截请求：");
request.setattribute("message", "请先登录再访问网站");
request.getrequestdispatcher("loginform").forward(request, response);
} else {
//如果用户已经登录，则验证通过，放行
system.out.println("authorizationinterceptor放行请求：");
flag = true;
}
}
return flag;
}
}
|
我们需要在springmvc-config.xml文件中配置拦截器，配置代码具体如下：
|
1
|
|
2
3
4
5
6
7
|
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/*"/>
<!-- 使用bean定义一个interceptor，直接定义在mvc:interceptors根下面的interceptor将拦截所有的请求 -->
<bean class="cn.edu.jit.interceptor.authorizationinterceptor"/>
</mvc:interceptor>
</mvc:interceptors>
|
我们在web.xml中配置代码如下：
|
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
|
<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemalocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="webapp_id" version="3.1">
<display-name>multipartfiletest</display-name>
<!-- 定义spring mvc的前端控制器 -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>
org.springframework.web.servlet.dispatcherservlet
</servlet-class>
<init-param>
<param-name>contextconfiglocation</param-name>
<param-value>/web-inf/springmvc-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<!-- 让spring mvc的前端控制器拦截所有请求 -->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 编码过滤器 -->
<filter>
<filter-name>characterencodingfilter</filter-name>
<filter-class>org.springframework.web.filter.characterencodingfilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterencodingfilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
|
我们来部署interceptor这个web应用，在浏览器中输入如下url来测试应用：
http://localhost:8088/interceptor
按enter（回车），出现以下页面，如果没有登录，直接访问main请求，拦截器会拦截请求，验证用户是否登录，此时用户若没有登录，则跳转到登录页面。如下图：
此时我若输入用户名：“钱春华”，密码（假设输入错误的密码）为：“123123”，则拦截器会拦截请求，并将请求重新转发到登录页面，同时提示用户“需要先登录再访问网站”。如下图所示：
输入正确的用户名“钱春华”，密码为“123456”后，显示用户登录成功，而后跳转到网页的首页。如下图所示：
本文中的一些功能案例代码和配置文件不是很完整，下面附上完整代码：
formcontroller类完整的代码如下：
|
1
|
|
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package cn.edu.jit.controller;
import org.springframework.stereotype.controller;
import org.springframework.web.bind.annotation.pathvariable;
import org.springframework.web.bind.annotation.requestmapping;
/**
* 动态页面跳转控制器
*/
@controller
public class formcontroller {
@requestmapping(value="/{formname}")
public string loginform(@pathvariable string formname){
//动态跳转页面
return formname;
}
}
|
在src文件下创建“cn.edu.jit.domain”包，用于存放图书和用户的两个实例，具体代码如下：
book类代码：
|
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
package cn.edu.jit.domain;
import java.io.serializable;
/**
*
* @author 钱春华
*
*/
public class book implements serializable{
private integer id;//id
private string name;//书名
private string author;//作者
private double price;//价格
private string image;//封面图片
public book() {
super();
}
public book( string image,string name, string author, double price) {
super();
this.image = image;
this.name = name;
this.author = author;
this.price = price;
}
public integer getid() {
return id;
}
public void setid(integer id) {
this.id = id;
}
public string getname() {
return name;
}
public void setname(string name) {
this.name = name;
}
public string getauthor() {
return author;
}
public void setauthor(string author) {
this.author = author;
}
public double getprice() {
return price;
}
public void setprice(double price) {
this.price = price;
}
public string getimage() {
return image;
}
public void setimage(string image) {
this.image = image;
}
@override
public string tostring() {
return "book [id=" + id + ", name=" + name + ", author=" + author
+ ", price=" + price + ", image=" + image + "]";
}
}
|
user类代码：
|
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
40
41
42
43
44
45
46
47
|
package cn.edu.jit.domain;
import java.io.serializable;
public class user implements serializable {
private integer id;//id
private string loginname;//登录名
private string password;//密码
private string username;//用户名
public user() {
super();
}
public integer getid() {
return id;
}
public void setid(integer id) {
this.id = id;
}
public string getloginname() {
return loginname;
}
public void setloginname(string loginname) {
this.loginname = loginname;
}
public string getpassword() {
return password;
}
public void setpassword(string password) {
this.password = password;
}
public string getusername() {
return username;
}
public void setusername(string username) {
this.username = username;
}
@override
public string tostring() {
return "user [id=" + id + ", loginname=" + loginname + ", password="
+ password + ", username=" + username + "]";
}
}
|
springmvc-config.xml配置文件具体配置信息如下：
|
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
40
41
42
43
|
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemalocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd">
<!-- spring可以自动去扫描base-pack下面的包或者子包下面的java文件，
如果扫描到有spring的相关注解的类，则把这些类注册为spring的bean -->
<context:component-scan base-package="cn.edu.jit.controller"/>
<!-- 设置默认配置方案 -->
<mvc:annotation-driven/>
<!-- 使用默认的servlet来响应静态文件 -->
<mvc:default-servlet-handler/>
<!-- 视图解析器 -->
<bean id="viewresolver"
class="org.springframework.web.servlet.view.internalresourceviewresolver">
<!-- 前缀 -->
<property name="prefix">
<value>/web-inf/content/</value>
</property>
<!-- 后缀 -->
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
<mvc:interceptors>
<mvc:interceptor>
<mvc:mapping path="/*"/>
<!-- 使用bean定义一个interceptor，直接定义在mvc:interceptors根下面的interceptor将拦截所有的请求 -->
<bean class="cn.edu.jit.interceptor.authorizationinterceptor"/>
</mvc:interceptor>
</mvc:interceptors>
</beans>
|
web.xml配置文件具体配置信息如下：
|
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
|
<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemalocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="webapp_id" version="3.1">
<display-name>multipartfiletest</display-name>
<!-- 定义spring mvc的前端控制器 -->
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>
org.springframework.web.servlet.dispatcherservlet
</servlet-class>
<init-param>
<param-name>contextconfiglocation</param-name>
<param-value>/web-inf/springmvc-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<!-- 让spring mvc的前端控制器拦截所有请求 -->
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 编码过滤器 -->
<filter>
<filter-name>characterencodingfilter</filter-name>
<filter-class>org.springframework.web.filter.characterencodingfilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterencodingfilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
|
总结：今天主要就介绍spring mvc拦截器，通过引用拦截器机制，spring mvc框架可以使用可插拔方式管理各种功能。以上就是完整的使用spring mvc拦截器实现了用户的权限验证，本文所有的案例都是本人亲自测试，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：http://blog.****.net/qian_ch/article/details/71697626