16.Spring MVC拦截器案例：用户登录权限验证

本节，我们将通过 Spring MVC 拦截器（Interceptor）来实现一个用户登录权限验证的案例。

在本案例中，只有登录后的用户才能访问系统主页，若没有登录就直接访问主页，则拦截器会将请求拦截并跳转到登录页面，同时在登录页面中给出提示信息。若用户登陆时，用户名或密码错误，则登录页也会显示相应的提示信息。已登录的用户在系统主页点击“退出登录”时，跳转会登录页面，流程图如下。

图1：用户登录流程

在了解了案例的整个执行流程后，接下来我们就具体实现实例来实现用户登录权限验证，具体步骤如下。

1. 新建一个名为“springmvc-login-interceptor-demo”的 Web 工程，并将与 Spring MVC 相关的依赖包引入到工程中。

2. 在 web.xml 中配置 Spring MVC 的 DispatcherServlet、请求和响应编码过滤器等信息，配置内容如下。

1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
5. version="4.0">
6.  
7. <!--请求和响应的字符串过滤器-->
8. <filter>
9. <filter-name>CharacterEncodingFilter</filter-name>
10. <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
11. <init-param>
12. <param-name>encoding</param-name>
13. <param-value>UTF-8</param-value>
14. </init-param>
15. <init-param>
16. <param-name>forceResponseEncoding</param-name>
17. <param-value>true</param-value>
18. </init-param>
19. </filter>
20. <filter-mapping>
21. <filter-name>CharacterEncodingFilter</filter-name>
22. <url-pattern>/*</url-pattern>
23. </filter-mapping>
24.  
25. <!--来处理 PUT 和 DELETE 请求的过滤器-->
26. <filter>
27. <filter-name>HiddenHttpMethodFilter</filter-name>
28. <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
29. </filter>
30. <filter-mapping>
31. <filter-name>HiddenHttpMethodFilter</filter-name>
32. <url-pattern>/*</url-pattern>
33. </filter-mapping>
34.  
35. <!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->
36. <servlet>
37. <servlet-name>dispatcherServlet</servlet-name>
38. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
39. <!--配置 DispatcherServlet 的一个初始化参数：spring mvc 配置文件按的位置和名称-->
40. <init-param>
41. <param-name>contextConfigLocation</param-name>
42. <param-value>classpath:springMVC.xml</param-value>
43. </init-param>
44.  
45. <!--作为框架的核心组件，在启动过程中有大量的初始化操作要做
46. 而这些操作放在第一次请求时才执行会严重影响访问速度
47. 因此需要通过此标签将启动控制DispatcherServlet的初始化时间提前到服务器启动时-->
48. <load-on-startup>1</load-on-startup>
49. </servlet>
50.  
51. <servlet-mapping>
52. <servlet-name>dispatcherServlet</servlet-name>
53. <!--设置springMVC的核心控制器所能处理的请求的请求路径
54. /所匹配的请求可以是/login或.html或.js或.css方式的请求路径
55. 但是/不能匹配.jsp请求路径的请求-->
56. <url-pattern>/</url-pattern>
57. </servlet-mapping>
58. </web-app>

3. 在 src 目录下创建一个名为 springMVC.xml 的 Spring MVC 配置文件，配置内容如下。

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:context="http://www.springframework.org/schema/context"
5. xmlns:mvc="http://www.springframework.org/schema/mvc"
6. xsi:schemaLocation="http://www.springframework.org/schema/beans
7. http://www.springframework.org/schema/beans/spring-beans.xsd
8. http://www.springframework.org/schema/context
9. https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
10.  
11. <!--开启组件扫描-->
12. <context:component-scan base-package="net.biancheng.c"></context:component-scan>
13.  
14. <!-- 配置 Thymeleaf 视图解析器 -->
15. <bean id="viewResolver"
16. class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
17. <property name="order" value="1"/>
18. <property name="characterEncoding" value="UTF-8"/>
19. <property name="templateEngine">
20. <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
21. <property name="templateResolver">
22. <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
23. <!-- 视图前缀 -->
24. <property name="prefix" value="/WEB-INF/templates/"/>
25. <!-- 视图后缀 -->
26. <property name="suffix" value=".html"/>
27. <property name="templateMode" value="HTML5"/>
28. <property name="characterEncoding" value="UTF-8"/>
29. </bean>
30. </property>
31. </bean>
32. </property>
33. </bean>
34. <!-- view-name：设置请求地址所对应的视图名称-->
35. <mvc:view-controller path="/" view-name="login"></mvc:view-controller>
36.  
37. <!-- view-name：设置请求地址所对应的视图名称-->
38. <mvc:view-controller path="/index.html" view-name="login"></mvc:view-controller>
39. <!-- view-name：设置请求地址所对应的视图名称-->
40. <mvc:view-controller path="/main" view-name="main"></mvc:view-controller>
41.  
42. <!-- 当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签-->
43. <mvc:annotation-driven></mvc:annotation-driven>
44. <!--将静态资源交给Tomcat 默认的 Servlet 处理-->
45. <mvc:default-servlet-handler/>
46.  
47. <!--配置拦截器-->
48. <mvc:interceptors>
49. <!--拦截器 1-->
50. <mvc:interceptor>
51. <!--配置拦截器拦截的请求路径-->
52. <mvc:mapping path="/**"/>
53. <!--配置拦截器不需要拦截的请求路径-->
54. <mvc:exclude-mapping path="/login"/>
55. <mvc:exclude-mapping path="/"/>
56. <!--定义在 <mvc:interceptors> 下，表示拦截器只对指定路径的请求进行拦截-->
57. <bean id="interceptor" class="net.biancheng.c.interceptor.LoginInterceptor"></bean>
58. </mvc:interceptor>
59. </mvc:interceptors>
60. </beans>

4. 在 net.biancheng.c.entity 包下创建一个 User 类，代码如下。

1. package net.biancheng.c.entity;
2.  
3. public class User {
4. private String userId;
5. private String userName;
6. private String password;
7.  
8. public String getUserId() {
9. return userId;
10. }
11.  
12. public void setUserId(String userId) {
13. this.userId = userId;
14. }
15.  
16. public String getUserName() {
17. return userName;
18. }
19.  
20. public void setUserName(String userName) {
21. this.userName = userName;
22. }
23.  
24. public String getPassword() {
25. return password;
26. }
27.  
28. public void setPassword(String password) {
29. this.password = password;
30. }
31.  
32. @Override
33. public String toString() {
34. return "User{" +
35. "userId='" + userId + '\'' +
36. ", userName='" + userName + '\'' +
37. ", password='" + password + '\'' +
38. '}';
39. }
40. }

4. 在 net.biancheng.c.controller 包下，创建一个名为 LoginController 的 Controller 类，代码如下。

1. package net.biancheng.c.controller;
2.  
3. import net.biancheng.c.entity.User;
4. import org.springframework.stereotype.Controller;
5. import org.springframework.web.bind.annotation.RequestMapping;
6.  
7. import javax.servlet.http.HttpServletRequest;
8. import javax.servlet.http.HttpSession;
9.  
10. @Controller
11. public class LoginController {
12.  
13. /**
14. * 登录
15. *
16. * @param user
17. * @param request
18. * @return
19. */
20. @RequestMapping("/login")
21. public String login(User user, HttpServletRequest request) {
22. //验证用户名和密码
23. if (user != null && "admin".equals(user.getPassword()) && "admin".equals(user.getUserName())) {
24. HttpSession session = request.getSession();
25. //将用户信息放到 session 域中
26. session.setAttribute("loginUser", user);
27. //重定向到商品列表
28. return "redirect:/main";
29. }
30. //提示用户名或密码错误
31. request.setAttribute("msg", "用户名或密码错误");
32. return "login";
33. }
34.  
35. /**
36. * 登出
37. *
38. * @param user
39. * @param request
40. * @return
41. */
42. @RequestMapping("/logout")
43. public String Logout(User user, HttpServletRequest request) {
44. //session 失效
45. request.getSession().invalidate();
46. return "redirect:/";
47. }
48. }

5. 在 net.biancheng.c.interceptor 包下，创建一个名为 LoginInterceptor 的自定义登陆拦截器类，代码如下。

1. package net.biancheng.c.interceptor;
2.  
3. import org.springframework.web.servlet.HandlerInterceptor;
4.  
5. import javax.servlet.http.HttpServletRequest;
6. import javax.servlet.http.HttpServletResponse;
7.  
8. public class LoginInterceptor implements HandlerInterceptor {
9. /**
10. * 目标方法执行前
11. *
12. * @param request
13. * @param response
14. * @param handler
15. * @return
16. * @throws Exception
17. */
18. @Override
19. public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
20. Object loginUser = request.getSession().getAttribute("loginUser");
21. if (loginUser == null) {
22. //未登录，返回登陆页
23. request.setAttribute("msg", "您没有权限进行此操作，请先登录！");
24. request.getRequestDispatcher("/").forward(request, response);
25. return false;
26. } else {
27. //放行
28. return true;
29. }
30. }
31. }

6. 在 webapp/WEB-INF 下新建一个 templates 目录，并在该目录下创建一个 login.html，代码如下。

1. <!DOCTYPE html>
2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
3. <head>
4. <meta charset="UTF-8">
5. <title>C语言中文网</title>
6. </head>
7. <body>
8. <form th:action="@{/login}" method="post">
9.  
10. <table style="margin: auto">
11. <tr>
12. <td th:if="${not #strings.isEmpty(msg)}" colspan="2" align="center">
13. <p style="color: red;margin: auto" th:text="${msg}"></p>
14. </td>
15. </tr>
16. <tr>
17. <td>用户名：</td>
18. <td><input type="text" name="userName" required><br></td>
19. </tr>
20. <tr>
21. <td>密码：</td>
22. <td><input type="password" name="password" required><br></td>
23. </tr>
24. <tr>
25. <td colspan="2" align="center">
26. <input type="submit" value="登陆">
27. <input type="reset" value="重置">
28. </td>
29. </tr>
30. </table>
31.  
32. </form>
33. </body>
34. </html>

7. 在 webapp/WEB-INF 下的 tempaltes 目录中，创建一个 main.html，代码如下。

1. <!DOCTYPE html>
2. <html lang="en" xmlns:th="http://www.thymeleaf.org">
3. <head>
4. <meta charset="UTF-8">
5. <title>系统主页</title>
6. </head>
7. <body>
8. <h1 th:text="'欢迎您：'+${session.loginUser.getUserName()}" th:if="${not #strings.isEmpty(session.loginUser)}"></h1>
9. <a th:href="@{/logout}">退出登录</a>
10. </body>
11. </html>

8. 将 springmvc-login-interceptor-demo 部署到 Tomcat 服务器中，启动 Tomcat。

9. 使用浏览器访问“http://localhost:8080/springmvc-login-interceptor-demo/main”，结果如下图。

图2：登录拦截

10. 在登录页，输入用户名（admin）和密码（123456），结果如下图。

图3：用户名或密码错误

11. 在登录页输入用户名（admin）和密码（admin），跳转到系统主页，如下图。

图4：系统主页

12. 点击下方的“退出登录”链接，返回登录页，结果如下图。

图5：返回登录页