14SpringMVC的拦截器

Posted 2023-03-05

文章目录

• ​​一、拦截器​​

• ​​1.1 拦截器与过滤器​​
• ​​1.2 拦截器的应用​​

• ​​1.2.1 HandlerInterceptor接口​​
• ​​1.2.2 拦截器的拦截规则​​

• ​​1.3 搭建工程测试拦截器​​

• ​​1.3.1 测试SpringMVC拦截器​​
• ​​1.3.2 SprinMVC拦截器注意事项​​

• ​​1.4 HandlerMethod类​​
• ​​1.5 多个拦截器的执行顺序​​

一、拦截器

1.1 拦截器与过滤器

• 过滤器

依赖于servlet容器。在实现上基于函数回调，可以对几乎所有请求进行过滤，使用过滤器的目的是用来做一些过滤操作，获取我们想要获取的数据，比如：在过滤器中修改字符编码；在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等。

• 拦截器：

依赖于web框架。在SpringMVC中就是依赖于SpringMVC框架。在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种运用。由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。

1.2 拦截器的应用

1.2.1 HandlerInterceptor接口

在SpringMVC中，定义一个拦截器需要实现HandlerInterceptor接口；在该接口下有三个功能方法：

public interface HandlerInterceptor 
    
    // 进入handler之前的处理(选择是否将该请求拦截下来),返回true:放行,返回false:拦截
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 
        return true;
    

    // handler方法执行完毕后执行
    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception 
    
    
    // 页面(JSP等)渲染后执行
    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception 
    

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

1.2.2 拦截器的拦截规则

定义好拦截器后，需要设置拦截器的拦截规则（说明资源该拦截，什么资源不拦截）

符号	说明
?	匹配任何一个字符
*	匹配任何长度的字符
**	匹配多级目录的路径

1.3 搭建工程测试拦截器

1.3.1 测试SpringMVC拦截器

• pom.xml：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.dfbz</groupId>
    <artifactId>SpringMVC_01_Interceptor</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.12.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-api</artifactId>
            <version>8.5.71</version>
        </dependency>
    </dependencies>
</project>

• web.xml：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">

    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--配置springmvc配置文件的位置-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

• 编写拦截器：

package com.dfbz.interceptor;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.invoke.MethodHandle;

public class MyInterceptor implements HandlerInterceptor 
    /**
     * 请求执行前执行(handle执行前执行)
     *
     * @param request
     * @param response
     * @param handler: 要执行的handler(目标方法)
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 

        System.out.println("preHandle...");

        return true;
    

    /**
     * handle执行后执行
     *
     * @param request
     * @param response
     * @param handler      :要执行的handler(目标方法)
     * @param modelAndView :handler返回的ModelAndView对象,如果目标方法没有返回ModelAndView则为null
     * @throws Exception
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception 
        System.out.println("postHandle...");
    

    /**
     * 页面渲染后执行
     *
     * @param request
     * @param response
     * @param handler  :要执行的handler(目标方法)
     * @param ex       :解析JSP页面出现异常时的异常对象
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception 
        System.out.println("afterCompletion...");
    

• SpringMVC.xml：

<?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="com.dfbz"/>

    <!--开启注解驱动-->
    <mvc:annotation-driven />
    
    <!--静态资源放行-->
    <mvc:default-servlet-handler/>

    <!--拦截器配置:将我们编写的拦截器加入到SpringMVC管理的拦截器中-->
    <mvc:interceptors>

        <!--配置单个拦截器-->
        <mvc:interceptor>
            <!--
                path:拦截规则
                    ?:匹配单个字符
                    *:代表匹配任意长度的字符(只能匹配单机目录)
                    **:代表匹配任意长度的多级目录
            -->
<!--            <mvc:mapping path="/**"/>-->

            <!--代表拦截/user下的所有请求-->
            <mvc:mapping path="/user/**"/>

            <!--代表放行/user/register请求-->
            <mvc:exclude-mapping path="/user/register"/>

            <!--配置拦截器-->
            <bean class="com.dfbz.interceptor.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

• Controller：

package com.dfbz.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.ModelAndView;

/**
 * @author lscl
 * @version 1.0
 * @intro:
 */
@RequestMapping("/user")
@RestController
public class UserController 

    @GetMapping("/login")
    public String login()               // 进入拦截器
        System.out.println("login");
        return "login";
    

    @GetMapping("/register")
    public String register()            // 不进入拦截器
        System.out.println("register");
        return "register";
    

    @GetMapping("id")                  // 进入拦截器
    public String findById(@PathVariable Integer id) 
        System.out.println("findById");
        return "findById: " + id;
    

    @GetMapping
    public String findAll()            // 进入拦截器
        System.out.println("findAll");
        return "findAll";
    

    @GetMapping("/hello")               // 进入拦截器
    public ModelAndView hello() 
        ModelAndView mv = new ModelAndView();
        System.out.println("handler...");
        mv.setViewName("/hello.jsp");
        return mv;
    

• JSP页面：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>我是JSP页面哦！</h1>
<%
    System.out.println("页面渲染！");
%>
</body>
</html>

启动服务器，访问：

​​http://localhost:8080/user/register（放行）​​

​​http://localhost:8080/user/login（拦截）​​

​​http://localhost:8080/user/hello（拦截）​​

​​http://localhost:8080/user（拦截）​​

Tips：我们说的拦截指的是发送的请求会进入SpringMVC的拦截器，具体是否能访问到目标资源要看拦截器是否放行；

1.3.2 SprinMVC拦截器注意事项

1）即使访问的资源不存在，只要符合SpringMVC的拦截器规则，都会进入SpringMVC

• 如：http://localhost:8080/user/abc 这样的请求也是会经过SpringMVC拦截器的

Tips：由于请求没有找到对应的资源，因此不会经过拦截器的postHandler方法

2）只要是符合SpringMVC的拦截器规则都会进入SpringMVC，静态资源也不例外！

在webapp目录下新建​​/js/test.js​​

在springmvc.xml中添加配置：

<mvc:interceptor>
    <mvc:mapping path="/js/**"/>
</mvc:interceptor>

访问：http://localhost:8080/js/test.js

同理，缺省servlet放行方式，资源连SpringMVC都没有进入，更加不会进入SpringMVC的拦截器了；

缺省servlet依赖：

<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-catalina</artifactId>
    <version>8.5.41</version>
    <scope>provided</scope>
</dependency>

• 相关配置：

<!--代表以js后缀结尾的任何请求进入Tomcat默认的Servlet处理(放行)-->
<servlet>
    <servlet-name>default</servlet-name>
    <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.js</url-pattern>
</servlet-mapping>

再次访问：http://localhost:8080/js/test.js，发现资源能够直接访问，并且没有经过SpringMVC拦截器；

1.4 HandlerMethod类

HandlerMethod类是SpringMVC用于封装目标方法的类，可以通过该类获取目标方法的一系列参数，如目标方法对象、目标方法所在的类、目标方法参数、目标方法返回值等；

package com.dfbz.interceptor;

import org.springframework.core.MethodParameter;
import org.springframework.lang.Nullable;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.invoke.MethodHandle;
import java.lang.reflect.Method;

public class MyInterceptor implements HandlerInterceptor 
    /**
     * 请求执行前执行(handle执行前执行)
     *
     * @param request
     * @param response
     * @param handler: 要执行的handler(目标方法)
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 
        System.out.println("preHandle...");

        // 转换为Handler对象
        HandlerMethod handlerMethod = (HandlerMethod) handler;

        // 获取目标方法
        Method method = handlerMethod.getMethod();

        // 获取Controller
        Object bean = handlerMethod.getBean();

        // 获取目标方法上的形参
        MethodParameter[] methodParameters = handlerMethod.getMethodParameters();

        // 获取目标方法的返回值
        MethodParameter returnType = handlerMethod.getReturnType();

        return true;
    

访问：http://localhost:8080/user/login

1.5 多个拦截器的执行顺序

SpringMVC多个拦截器执行流程如下：

编写另一个拦截器：

package com.dfbz.interceptor;

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

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

public class MyInterceptor2 implements HandlerInterceptor 
    /**
     * 请求执行前执行(handle执行前执行)
     *
     * @param request
     * @param response
     * @param handler: 要执行的handler(目标方法)
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception 

        System.out.println("preHandle2...");
        return true;
    

    /**
     * handle执行后执行
     *
     * @param request
     * @param response
     * @param handler      :要执行的handler(目标方法)
     * @param modelAndView :handler返回的ModelAndView对象,如果目标方法没有返回ModelAndView则为null
     * @throws Exception
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception 
        System.out.println("postHandle2...");
    

    /**
     * 页面渲染后执行
     *
     * @param request
     * @param response
     * @param handler  :要执行的handler(目标方法)
     * @param ex       :解析JSP页面出现异常时的异常对象
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception 
        System.out.println("afterCompletion2...");
    

添加到SpringMVC中：

<mvc:interceptors>
    <mvc:interceptor>
        <mvc:mapping path="/user/**"/>
        <bean class="com.dfbz.interceptor.MyInterceptor"/>
    </mvc:interceptor>
    <mvc:interceptor>
        <mvc:mapping path="/user/**"/>
        <bean class="com.dfbz.interceptor.MyInterceptor2"/>
    </mvc:interceptor>
</mvc:interceptors>

访问：http://localhost:8080/user/login