玩转SpringMVC之拦截器过滤器区分以及单个多个拦截器执行顺序

最新推荐文章于 2024-05-05 00:05:37 发布

calmtho

最新推荐文章于 2024-05-05 00:05:37 发布

阅读量1k

点赞数

分类专栏： # springmvc 文章标签： spring web.xml java web 过滤器

本文链接：https://blog.csdn.net/xtho62/article/details/109163956

版权

springmvc 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

文章目录

- SpringMVC框架中的拦截器简介

SpringMVC框架中的拦截器简介

拦截器的概述：

1.SpringMVC框架中的拦截器用于处理器进行预处理和后处理的技术。
2.可以定义拦截器链，拦截器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链中的拦截器会按着定义的顺序执行。
3.拦截器和过滤器的功能比较类似，但是有区别！！
区别在于：
- 过滤器是Servlet规范的一部分，任何宽假都可以使用过滤器技术。
- 拦截器是SpringMVC框架独有的。
- 过滤器配置了/*，可以拦截任何资源，如jsp,css,html,img,js等等等等也不例外。
- 拦截器只会对控制器中的方法进行拦截
4.拦截器也是AOP思想的一种是实现方式
5.想要自定义拦截器，需要实现HandlerInterceptor接口（即处理拦截接口）

接下来就是编写案例啦体会一下啦

搭建案件所需环境

还是在此前的项目结构中，构建一个模块：springmvc_day02_04_interceptor
在这里插入图片描述
补充结构以及相关配置文件
导入模块依赖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">
    <parent>
        <artifactId>springmvcdemo</artifactId>
        <groupId>com.tho</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springmvc_day02_04_interceptor</artifactId>
    <packaging>war</packaging>

    <name>springmvc_day02_04_interceptor Maven Webapp</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.0.2.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>

在这里插入图片描述
UserController:

package com.tho.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/testInterceptor")
    public String testException(){
        System.out.println("testInterceptor执行了...");
        return "success";
    }
}

web.xml:

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <display-name>Archetype Created Web Application</display-name>

  <!--springmvc核心配置器，前端控制器-->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!--配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器-->
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>

    <!-- 配置servlet启动时加载对象 -->
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcherServlet</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>

  <!--使用Rest风格的URI,将页面普通的post请求转为delete或者put请求-->
  <filter>
    <filter-name>hiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>hiddenHttpMethodFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
</web-app>

springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 配置spring创建容器时要扫描的包 -->

    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.tho"/>
    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--配置spring开启注解mvc的支持,开启转换器组件支持-->
    <mvc:annotation-driven/>
</beans>

index.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>拦截器</h3>

    <a href="user/testInterceptor">拦截器</a>
</body>
</html>

success.jsp:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>执行成功</h3>
</body>
</html>

测试环境是否能跑通：
在这里插入图片描述

ok环境构完成。

拦截器执行流程

在这里插入图片描述
上面有拦截器的执行流程，我们可参考流程来编写我们的案例测试。

单个拦截器的执行顺序

接下来就开始测试按照上图的写法配置拦截器是否可用

preHandle返回true测试执行顺序

1.com.tho下创建interceptor用于存放拦截器，并且创建MyInterceptor1实现 HandlerInterceptor接口。

package com.tho.interceptor;

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

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

//实现接口没提示重写方法的原因是因为JDK8的新特性，接口可有直接实现方法
public class MyInterceptor1 implements HandlerInterceptor {
    //预处理，如果返回值是true，放行，执行下一个拦截器，如果没有，执行Controller里面的方法
    //false  不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor执行了..");
        return true;
    }
    
}

2.配置springmvc.xml的拦截器相关配置：

 <mvc:interceptors>
        <mvc:interceptor>
            <!--拦截路径-->
            <mvc:mapping path="/user/*"/>
            <bean class="com.tho.interceptor.MyInterceptor1"/>
            <!--
            //放行路径
            <mvc:exclude-mapping path=""/>
            -->
        </mvc:interceptor>
    </mvc:interceptors>

修改index.jsp让结果更清晰：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h3>拦截器</h3>

    <a href="user/testInterceptor">拦截器</a>
</body>
</html>

运行测试：
在这里插入图片描述
点击链接：

证明整合成功，使用了preHandle拦截器拦截了在Controller前做了预处理然后放行了。

preHandle返回false进行拦截

当然也可以不放行，把方法里的返回值改为false即可，后续操作即被拦截，无法执行。
在这里插入图片描述

被拦截了，只有preHandle预处理执行了。

我们可以在被拦截的时候，可以转发一个错误的页面，提示用户无法使用这个功能。
在这里插入图片描述

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h3>此功能被拦截，您无法使用</h3>
</body>
</html>

在这里插入图片描述

整合postHandle测试顺序

可以在自定义拦截器类中使用Ctrl+O重写postHandle后处理方法：

package com.tho.interceptor;

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

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

//实现接口没提示重写方法的原因是因为JDK8的新特性，接口可有直接实现方法
public class MyInterceptor1 implements HandlerInterceptor {
    //预处理，如果返回值是true，放行，执行下一个拦截器，如果没有，执行Controller里面的方法
    //false  不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor执行了..preHandle");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /*
        后处理
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor执行了..postHandle");
    }
}

运行测试，点击主页使用拦截器跳转链接，查看idea的控制台输出：
在这里插入图片描述
当然也可以后处理跳转拦截提醒页面：

运行测试：

执行顺序不变

加入afterCompletion测试

package com.tho.interceptor;

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

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

//实现接口没提示重写方法的原因是因为JDK8的新特性，接口可有直接实现方法
public class MyInterceptor1 implements HandlerInterceptor {
    //预处理，如果返回值是true，放行，执行下一个拦截器，如果没有，执行Controller里面的方法
    //false  不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor执行了..preHandle");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /*
        后处理
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor执行了..postHandle");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }
    /*
        最后执行，页面渲染完后执行,意思也是完成以后的意思，一般用于关闭流，或者关闭用不上的资源
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor执行了..afterCompletion");
    }
}

在这里插入图片描述
可得结论为在单个拦截器中：
一个请求进来，会先过预处理，预处理放行后，方法进行映射，方法映射后，后处理会进行处理，处理后才会去解析然后渲染页面，最后在执行最终执行方法。进一步验证了那张大家熟悉的SpringMVC执行流程图的正确:
在这里插入图片描述

多个拦截器执行顺序

首先复制多一个拦截器，并给拦截器的输出语句加上可辨识的数字111和222
在这里插入图片描述

package com.tho.interceptor;

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

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

//实现接口没提示重写方法的原因是因为JDK8的新特性，接口可有直接实现方法
public class MyInterceptor1 implements HandlerInterceptor {
    //预处理，如果返回值是true，放行，执行下一个拦截器，如果没有，执行Controller里面的方法
    //false  不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor执行了..preHandle111");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /*
        后处理
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor执行了..postHandle111");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }
    /*
        最后执行，页面渲染完后执行,意思也是完成以后的意思，一般用于关闭流，或者关闭用不上的资源
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor执行了..afterCompletion111");
    }
}

package com.tho.interceptor;

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

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

//实现接口没提示重写方法的原因是因为JDK8的新特性，接口可有直接实现方法
public class MyInterceptor2 implements HandlerInterceptor {
    //预处理，如果返回值是true，放行，执行下一个拦截器，如果没有，执行Controller里面的方法
    //false  不放行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor执行了..preHandle222");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /*
        后处理
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor执行了..postHandle222");
        //request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }
    /*
        最后执行，页面渲染完后执行,意思也是完成以后的意思，一般用于关闭流，或者关闭用不上的资源
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor执行了..afterCompletion222");
    }
}

配置web.xml：先配置1在2上面

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 配置spring创建容器时要扫描的包 -->

    <!-- 配置spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.tho"/>
    <!-- 配置视图解析器 -->
    <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--配置spring开启注解mvc的支持,开启转换器组件支持-->
    <mvc:annotation-driven/>

    <mvc:interceptors>
        <mvc:interceptor>
            <!--拦截路径-->
            <mvc:mapping path="/user/*"/>
            <bean class="com.tho.interceptor.MyInterceptor1"/>
            <!--
            //放行路径
            <mvc:exclude-mapping path=""/>
            -->
        </mvc:interceptor>
        <!--配置第二个拦截器-->
        <mvc:interceptor>
            <!--拦截路径-->
            <mvc:mapping path="/user/*"/>
            <bean class="com.tho.interceptor.MyInterceptor2"/>
            <!--
            //放行路径
            <mvc:exclude-mapping path=""/>
            -->
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

在这里插入图片描述

由于我们推测拦截器的执行，最上面的拦截器先执行，然后再往下拦截器执行，按照preHandle=>Mapping=>postHandle=>渲染页面=>afterCompletion，即在渲染页面前每个流程执行都是按配置顺序执行过滤器顺序当个流程，预处理是由上往下，而后处理一个最后执行都是下往上执行。总流程不变。

那我们推测如果将web.xml的1和2拦截器配置顺序换一下，他们的执行顺序也会和上面的结果反过来！！
在这里插入图片描述

事实证明我们的猜想没错。afterCompletion重点在于关闭资源，不处理视图方面的问题。所以我们上面的图也是没错的。在web.xml的上面的拦截器即相当于图里的外面的拦截器，下面的则是代表更里层的拦截器，执行顺序即预处理外到内，经过映射方法后，后处理由内到外执行。

相信更新做完这些小案例的你已经自信满满啦，这时候我相信你去看官方文档会更加的有信心而且有可能由意外收获噢！ https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/web.html#mvc-servlet
同样的附上，代码托管地址：https://gitee.com/calmtho/springmvcdemo

calmtho

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
玩转SpringMVC之拦截器过滤器区分以及单个多个拦截器执行顺序

文章目录SpringMVC框架中的拦截器简介拦截器的概述：搭建案件所需环境拦截器执行流程单个拦截器的执行顺序preHandle返回true测试执行顺序preHandle返回false进行拦截整合postHandle测试顺序加入afterCompletion测试多个拦截器执行顺序SpringMVC框架中的拦截器简介拦截器的概述：1.SpringMVC框架中的拦截器用于处理器进行预处理和后处理的技术。2.可以定义拦截器链，拦截器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链中的拦
复制链接

扫一扫

专栏目录