SpringMVC的拦截器_mvc:exclude-mapping元素的作用-CSDN博客

本文链接：https://blog.csdn.net/weixin_47960075/article/details/122283911

本文详细介绍了SpringMVC中的拦截器机制，包括HandlerInterceptor接口的三个核心方法及其作用，以及拦截器的配置和执行流程。通过实例展示了如何创建和配置拦截器，实现用户登录权限验证。此外，还分析了单个和多个拦截器的执行顺序。

摘要由CSDN通过智能技术生成

一、拦截器简介

1、拦截器定义

SpringMVC中的拦截器（Interceptor）类似于Servlet中的过滤器（Filter），它主要用于拦截用户请求，并作出相应的处理，例如通过拦截器可以进行权限验证、判断用户是否登录等

要使用SpringMVC中的拦截器，就需要对拦截器类进行定义和配置，通常拦截器类可以通过两种方式来定义：

实现HandlerInterceptor接口或者继承HandlerInterceptor接口的实现类如（HandlerInterceptorAdapter）来定义
实现WebRequestInterceptor接口或者继承WebRequestInterceptor接口的实现类来定义

以实现HandlerInterceptor接口为例：

package controller;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
     Object handler) throws Exception {
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, 
    Object handler, ModelAndView modelAndView) throws Exception {
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
     Object handler, Exception ex) throws Exception {
    }
}

从上述代码中可以看出，自定义的拦截器类实现了HandlerInterceptor接口，并实现了接口中的三种方法。

这三个方法的具体描述：

preHandle()：在控制器方法前执行，返回值表示是否中断后续操作。方法类型为布尔型，当其返回值为true时，表示继续向下执行；当其返回false时，会中断后续的所有操作。包括调用下一个拦截器和控制器类中的方法执行等
postHandle()：在控制器方法调用之后，解析视图之前执行。可以通过此方法对请求域中的模型和视图作出进一步的修改
afterCompletion()：在整个请求完成，即视图渲染结束之后执行。可以通过此方法实现一些资源清理、记录日志信息等工作

2、拦截器的配置

自定义的拦截器要生效，必须在springmvc的配置文件中进行配置

<!--配置拦截器-->
    <mvc:interceptors>
        <!--使用bean直接定义在总拦截器下的拦截器，将拦截所有请求-->
        <bean class="interceptor.MyInterceptor"/>
        <!--拦截器1-->
        <mvc:interceptor>
            <!--配置拦截器作用的路径-->
            <mvc:mapping path="/**"/>
            <!--配置不需要拦截器作用的路径-->
            <mvc:exclude-mapping path=""/>
            <!--定义在子拦截器下，表示对匹配路径的请求才进行拦截-->
            <bean class="interceptorr.MyInterceptor1"/>
        </mvc:interceptor>
        <!--拦截器2-->
        <mvc:interceptor>
            <mvc:mapping path="/hello"/>
            <bean class="interceptor.MyInterceptor2"/>
        </mvc:interceptor>
        ......
    </mvc:interceptors>

分析：

在上述代码中， < mvc:interceptors>元素用于配置一组拦截器，其子元素< bean>中定义的是全局拦截器，它会拦截所有的请求。
< mvc:interceptor>元素定义的是指定路径的拦截器，它只会对指定路径下的请求生效。
< mvc:interceptor>元素的子元素< mvc:mapping>用于配置拦截器作用的路径，该路径在其属性path中定义。如上述代码中path的属性值"/**“表示拦截所有路径，”/hello"表示拦截所有以hello结尾的路径。
< mvc:exclude-mapping>元素用于配置拦截器不需要作用的路径。
按指定的配置顺序进行配置，否则会报错！

二、拦截器的执行流程

拦截器的执行是有一定顺序的，该顺序与配置文件中所定义的拦截器的顺序有关

1、单个拦截器的执行流程

在这里插入图片描述

程序会首先执行拦截器类中的preHandle()方法，如果该方法的返回值为true，则程序会继续向下执行处理器中的方法，否则将不在向下执行；
在控制层（controller层）处理完请求后，会执行postHandle()方法，然后通过DispatcherServlet向客户端返回响应；
在DispatcherServlet处理完请求后，才会执行afterCompletion()方法！

简单使用

1、创建控制器

@Controller
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        System.out.println("hello");
        return "success";
    }
}

2、创建拦截器

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
     Object handler) throws Exception {
        System.out.println("preHandle");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, 
    Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
     Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion");
    }
}

3、在springmvc中配置

	<!--<mvc:interceptors>
        <bean class="interceptor.MyInterceptor"/>
    </mvc:interceptors>-->
    <!--两种方式结果一致-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/hello"/>
            <bean class="interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

4、启动Tomcat服务器

在这里插入图片描述

5、分析

结果与刚开始的图片流程一致！
如果出现404，可能是创建项目的时候没有在项目结构中没有创建lib目录，导入jar包！

2、多个拦截器的执行流程

在这里插入图片描述
当有多个拦截器同时工作时，它们的preHandle()方法会按照配置文件中拦截器的配置顺序执行，而它们的postHandle()方法和afterCompletion()方法则会按照配置顺序的反序执行。

简单使用

1、创建拦截器类

public class Interceptor1 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
     Object handler) throws Exception {
        System.out.println("拦截器1中的preHandle方法");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
     Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("拦截器1中的postHandle方法");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
     Object handler, Exception ex) throws Exception {
        System.out.println("拦截器1中的afterCompletion方法");
    }
}

public class Interceptor2 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
     Object handler) throws Exception {
        System.out.println("拦截器2中的preHandle方法");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
     Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("拦截器2中的postHandle方法");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
    Object handler, Exception ex) throws Exception {
        System.out.println("拦截器2中的afterCompletion方法");
    }
}

2、配置springmvc

	<mvc:interceptors>
		<!--会作用于所有路径下的请求-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="interceptor.Interceptor1"/>
        </mvc:interceptor>
        
        <!--会作用于以/hello结尾的请求-->
        <mvc:interceptor>
            <mvc:mapping path="/hello"/>
            <bean class="interceptor.Interceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

3、启动Tomcat服务器

在这里插入图片描述

4、分析

程序先执行了两个拦截器类的preHandle()方法，这两个方法的执行顺序与配置文件中定义的顺序相同；
然后执行了控制器类中hello()方法；
最后执行了两个拦截器类中的postHandle()方法和afterCompletion()方法，且这两个方法的执行顺序与配置文件中的顺序相反！类似if嵌套，先执行内部，后执行外部！

三、案例：用户登录权限验证

在这里插入图片描述
只有登录后的用户才能访问管理主页，如果没有登录而直接反问主页，拦截器就会请求拦截，并转发到登录页面，同时在登录页面中给出提示信息。

如果用户名或密码错误，也会在登录页面给出提示信息。

当已登录的用户在管理主页中单击退出链接时，同样会回到登录页面。

1、创建pojo实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;
    private String username;
    private String password;
}

2、配置web文件

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-config.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3、创建控制器类

package controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import pojo.User;

import javax.servlet.http.HttpSession;

@Controller
public class UserController {

    //向登录页面跳转
    //@GetMapping("/toLogin")
    @RequestMapping(value = "/toLogin",method = RequestMethod.GET)
    public String toLogin() {
        return "login";
    }

    //用户登录
    //@PostMapping("/login")
    @RequestMapping(value = "/login",method = RequestMethod.POST)
    public String login(User user, Model model, HttpSession session) {
        String username = user.getUsername();
        String password = user.getPassword();
        if (username != null && username.equals("admin")) {
            if (password != null && password.equals("123456")) {
                session.setAttribute("info", user);
                return "redirect:main";
            }
        }
        model.addAttribute("msg", "用户名或密码错误，请重新输入");
        return "login";
    }

    //用户不存在，添加错误信息到model，并跳转到登录页面
    @RequestMapping("/main")
    public String toMain() {
        return "main";
    }

    //退出
    @RequestMapping("logout")
    public String logout(HttpSession session){
        session.invalidate();//清除session
        return "redirect:toLogin";
    }
}

4、创建拦截器

package interceptor;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import pojo.User;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
    Object handler) throws Exception {
        //获取请求的url
        String url = request.getRequestURI();
        //判断是否在登陆页面
        if (url.contains("/toLogin")){
            return true;
        }
        if (url.contains("/login")) {
            return true;
        }
        //获取session
        HttpSession session = request.getSession();
        User user = (User) session.getAttribute("info");
        //如果user不为空，表示已登录
        if (user != null) {
            return true;
        }
        //如果user为空，表示未登录，返回登录页面
        request.setAttribute("msg", "请先登录");
        request.getRequestDispatcher("WEB-INF/jsp/login.jsp").forward(request, response);
        return false;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
     Object handler, ModelAndView modelAndView) throws Exception {
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
     Object handler, Exception ex) throws Exception {
    }
}

5、配置springmvc和拦截器

<?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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="controller"/>
    <mvc:default-servlet-handler/>
    <mvc:annotation-driven/>
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="interceptor.LoginInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

6、创建主页和登录页

主页：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>管理页面</title>
</head>
<body>
当前用户信息：
${info.username}
<a href="${pageContext.request.contextPath}/logout">退出</a>
</body>
</html>

登录页：

<html>
<head>
    <title>登录页面</title>
</head>
<body>
<form action="${pageContext.request.contextPath}/login" method="post">
账号: <input type="text"  name="username" id="username" /><br>
密码： <input type="password" name="password" id="password" /><br>
<input type="submit" value="登录">
</form>
</body>
</html>

7、启动Tomcat服务器

在这里插入图片描述
输入admin和123456后

点击退出后，退回到登录页

8、分析

如果出现404，注意在项目结构中WEB-INF下创建lib目录导入jar包！！！
controller类定义了向主页跳转、向登录页面跳转、执行用户登录等操作
在登录的时候，先通过User实体类获取账号和密码，然后判断是否与定义的账号密码一致。如果一致，就将用户信息保存到Session中，并复位到主页，否则跳转到登录页面
Interceptor拦截器类中preHandle()方法中，获取了请求的url，判断了url是否有"/toLogin"和"/login"字符串。如果有，就放行；没有就继续向下执行拦截处理。接着获取了Session中的信息，如果Session中包含用户信息，就表示用户已登录，就直接放行；否则转发到登录页面，不再执行后续操作！