【Spring MVC学习笔记七】深入理解SpringMVC拦截器原理

最新推荐文章于 2024-04-15 19:37:59 发布

存在morning

最新推荐文章于 2024-04-15 19:37:59 发布

阅读量878

点赞数 1

分类专栏： # Spring MVC 文章标签： spring mvc 拦截器

本文链接：https://blog.csdn.net/sinat_33087001/article/details/120252134

版权

Spring MVC 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

上篇Blog中我们介绍了SpringMVC中AJAX的使用，上上篇Blog中我们聊到了SpringMVC中Jackson的使用，也就是我们简单聊了下框架整合日常功能的一些细节，本篇Blog我们来看下SpringMVC的拦截器，可以说是框架核心原理的一部分，也是AOP设计思想的一种体现。

拦截器概念

什么是拦截器呢？SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理。

拦截器和过滤器区别

说它和Servlet中的过滤器类似，但不是相同，因为过滤器和拦截器的概念上还是有些差别的：

过滤器：依赖于servlet容器。在实现上基于函数回调，可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的是用来做一些过滤操作，比如：在过滤器中修改字符编码；在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等。
- 过滤器是servlet规范中的一部分，任何java web工程都可以使用
- 过滤器在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截
- 一个过滤器实例只能在容器初始化时调用一次
拦截器：依赖于web框架，在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种运用。由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用
- 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用
- 拦截器只会拦截访问的控制器方法，如果访问的是jsp/html/css/image/js是不会进行拦截的
- 一个拦截器实例在一个controller生命周期之内可以多次调用

搞清楚了拦截器和过滤器的基本概念后我们才能更好的明白其使用场景。

拦截器应用场景

拦截器的应用场景和过滤器类似，也和Spring中的AOP类似，都是一种切面编程的应用：

日志记录：记录请求信息的日志，以便进行信息监控、信息统计、计算PV（Page View）等。
权限检查：如登录检测，进入处理器检测是否登录，如果没有直接返回到登录页面；
性能监控：有时候系统在某段时间莫名其妙的慢，可以通过拦截器在进入处理器之前记录开始时间，在处理完后记录结束时间，从而得到该请求的处理时间（如果有反向代理，如apache可以自动记录）；
通用行为：读取cookie得到用户信息并将用户对象放入请求，从而方便后续流程使用，还有如提取Locale、Theme信息等，只要是多个Controller中的处理方法都需要的，我们就可以使用拦截器实现。
OpenSessionInView：如Hibernate，在进入处理器打开Session，在完成后关闭Session。

注意，不同的是拦截器和过滤器处理的都是URL，而AOP处理的是类的元数据（包、类、方法名、参数等），相比于拦截器更加细致一些，因为是面对方法的动态代理嘛。

拦截器使用

拦截器使用时要实现拦截器接口或者拦截适配器接口，事实上，我们大多时候使用拦截适配器接口即可。
在这里插入图片描述

拦截器接口HandlerInterceptor

SpringMVC提供三个拦截器接口用于处理方法逻辑：


package org.springframework.web.servlet;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.lang.Nullable;

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

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

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

拦截器的三个回调方法作用如下:

preHandle：预处理回调方法，实现处理器的预处理（如登录检查），第三个参数为响应。处理器返回值：true表示继续流程（如调用下一个拦截器或处理器）；false表示流程中断（如登录检查失败），不会继续调用其他的拦截器或处理器，此时我们需要通过response来产生响应；
postHandle：后处理回调方法，实现处理器的后处理（但在渲染视图之前），此时我们可以通过modelAndView（模型和视图对象）对模型数据进行处理或对视图进行处理，modelAndView也可能为null。
afterCompletion：整个请求处理完毕回调方法，即在视图渲染完毕时回调，如性能监控中我们可以在此记录结束时间并输出消耗时间，还可以进行一些资源清理，类似于try-catch-finally中的finally，但仅调用处理器执行链中preHandle返回true的拦截器才会执行afterCompletion。

有时我们可能只需要实现三个回调方法中的某一个，如果实现HandlerInterceptor接口的话，三个方法必须实现，此时spring提供了一个HandlerInterceptorAdapter适配器（一种适配器设计模式的实现），允许我们只实现需要的回调方法

拦截适配器抽象类HandlerInterceptorAdapter

大多数时候我们使用的是拦截适配器，允许我们只实现需要的回调方法
在这里插入图片描述
拦截适配器包含的方法如下：

public abstract class HandlerInterceptorAdapter implements AsyncHandlerInterceptor {
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
		throws Exception {
		return true;
	}
 
	public void postHandle(
			HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
			throws Exception {
	}
 
	public void afterCompletion(
			HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
	}
 
	public void afterConcurrentHandlingStarted(
			HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
	}
}

SpringMVC使用拦截器

我们来简单实现下拦截器，这里就不引入复杂场景，只简单打印实现结果：

1 新建一个项目

首先我们新建一个拦截器Interceptor的SpringMVC项目
在这里插入图片描述

配置pom.xml依赖，同时也引入jackson包

 <!--https://mvnrepository.com/仓库获取的最新包 20210831-->
    <dependencies>
        <!-- jackson包引入-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.12.1</version>
        </dependency>
        <!--Spring MVC框架依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <!--JSP相关依赖-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!--servlet相关依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <!--单元测试相关依赖-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

2 创建Model类

我们创建一个Model类，这个Model类就是要返回给前端的VO

package com.example.ajax.model;

import lombok.Data;

@Data
public class User {
    private String username;
    private String password;
}

3 编写正常逻辑的控制器Controller

我们需要编写一个控制器，注意控制器可以使用注解@RestController来标明所有返回的数据都将被序列化为Json格式：

package com.example.interceptor.controller;

import com.example.interceptor.model.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

//@RestController  如果使用的是RestController注解，那么不会跳转jsp页面
@Controller
@RequestMapping("/user")
public class UserController {
    @GetMapping("/addUser")
    public String addUser(User user){
        System.out.println("新增用户的用户名为："+user.getUsername()+" 密码为： "+user.getPassword());
        return "result";
    }
}

4 编写拦截器

拦截器我们配置一个日志拦截器，看看打印的日志如何：

package com.example.interceptor.interceptor;

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

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

public class LogInterceptor implements HandlerInterceptor {
    //在请求处理的方法之前执行,如果返回true执行下一个拦截器,如果返回false就不执行下一个拦截器
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("------------处理前------------"+o.toString());
        return true;
    }

    //在请求处理方法执行之后执行
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("------------处理后------------"+o.toString());
    }

    //在dispatcherServlet处理后执行,做清理工作.
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("------------清理------------"+o.toString());
    }
}

5 注册DispatcherServlet

接着是我们的传统艺能，注册SpringMVC过滤器来拦截请求

<?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"
         xmlns:context="http://www.springframework.org/schema/context"
         xmlns:mvc="http://www.springframework.org/schema/mvc"
         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>
        <!--1.注册DispatcherServlet-->
        <servlet-name>springMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通过初始化参数指定SpringMVC配置文件的位置，进行关联-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <!--关联一个springMVC的配置文件:【servlet-name】-servlet.xml-->
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1,在Tomcat启动时就初始化Spring容器-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的请求；（不包括.jsp）-->
    <!--/* 匹配所有的请求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    
</web-app>

6 编写springmvc-servlet.xml配置文件

编写springmvc-servlet.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
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.example.interceptor.controller"/>
    <!-- 让Spring MVC不处理静态资源 -->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
     -->
    <mvc:annotation-driven />

    <!--视图解析器-->
    <!--通过视图解析器解析处理器返回的逻辑视图名并传递给DispatcherServlet-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前缀-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后缀-->
        <property name="suffix" value=".jsp"/>
    </bean>
    <mvc:annotation-driven>
        <mvc:message-converters register-defaults="true">
            <bean class="org.springframework.http.converter.StringHttpMessageConverter">
                <constructor-arg value="UTF-8"/>
            </bean>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
                <property name="objectMapper">
                    <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                        <property name="failOnEmptyBeans" value="false"/>
                    </bean>
                </property>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!--关于拦截器的配置-->
    <mvc:interceptors>
        <mvc:interceptor>
            <!--/** 包括所有路径及其子路径-->
            <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
            <!--/admin/** 拦截的是/admin/下的所有-->
            <mvc:mapping path="/**"/>
            <!--bean配置的就是拦截器-->
            <bean class="com.example.interceptor.interceptor.LogInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

7 返回结果Jsp页面

我们增加一个返回结果jsp页面：

<%--
  Created by IntelliJ IDEA.
  User: 13304
  Date: 2021/9/12
  Time: 17:10
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<a href="${pageContext.request.contextPath}/interceptor">返回到前端了</a>
</body>
</html>

8 配置Tomcat服务器并测试

最后我们配置并启动Tomcat服务器来测试：
在这里插入图片描述

在浏览器中输入：http://localhost:8080/interceptor/user/addUser?username=tml&password=111111，打印结果为：
在这里插入图片描述
可以看到拦截器的代码执行了。当然我们可以通过拦截器实现之前Servlet实现的登录验证，这里就不详述了

public class LoginInterceptor implements HandlerInterceptor {

   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws ServletException, IOException {
       // 如果是登陆页面则放行
       System.out.println("uri: " + request.getRequestURI());
       if (request.getRequestURI().contains("login")) {
           return true;
      }

       HttpSession session = request.getSession();

       // 如果用户已登陆也放行
       if(session.getAttribute("user") != null) {
           return true;
      }

       // 用户没有登陆跳转到登陆页面
       request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
       return false;
  }

   public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

  }
   
   public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

  }
}

总结一下

拦截器其实和AOP的实现是类似的，主要是拦截用户的请求然后进行一些额外的操作，所以如果是在整合SSM之后我觉得用AOP配置实现更好一些，毕竟粒度可以更细些，且不限于Controller层，至于拦截器，我认为只要知道SpringMVC框架有这个内容，有一些作用即可。

存在morning

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
1
评论
【Spring MVC学习笔记七】深入理解SpringMVC拦截器原理

上篇Blog中我们介绍了SpringMVC中AJAX的使用，上上篇Blog中我们聊到了SpringMVC中Jackson的使用，也就是我们简单聊了下框架整合日常功能的一些细节，本篇Blog我们来看下SpringMVC的拦截器，可以说是框架核心原理的一部分，也是AOP设计思想的一种体现。拦截器概念什么是拦截器呢？SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理。拦截器和过滤器区别说它和Servlet中的过滤器类似，但不是相同，因为过滤器和拦
复制链接

扫一扫