【SpringMVC】SpringMVC的拦截器

Spring MVC 的处理器拦截器类似于 Servlet 开发中的过滤器 Filter，用于对处理器进行预处理和后处理。用户可以自己定义一些拦截器来实现特定的功能。

谈到拦截器，还要向大家提一个词——拦截器链（Interceptor Chain）。拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。

说到这里，可能大家脑海中有了一个疑问，这不是我们之前学的过滤器吗？是的它和过滤器是有几分相似，但是也有区别，接下来我们就来说说他们的区别：

  • 过滤器是 servlet 规范中的一部分， 任何 java web 工程都可以使用。
  • 拦截器是 SpringMVC 框架自己的，只有使用了 SpringMVC 框架的工程才能用。
  • 过滤器在 url-pattern 中配置了/*之后，可以对所有要访问的资源拦截。
  • 拦截器它是只会拦截访问的控制器方法，如果访问的是 jsp， html,css,image 或者 js 是不会进行拦
    截的。

拦截器也是 AOP 思想的具体应用。
我们要想自定义拦截器， 要求必须实现： HandlerInterceptor 接口。

那么我们的第一步就是实现HandlerInterceptor接口

package com.siyi.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 MyInterceptor1 implements HandlerInterceptor {
    /**
     * 预处理，controller方法执行前
     * @param request
     * @param response
     * @param handler
     * @return true 放行，执行下一个拦截器，如果没有，执行controller中的方法
     *         false 不放行
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor1执行了...111");
//        request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /**
     * 后处理方法，controller方法执行后，success.jsp执行之前
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor1执行了....后置111");
//        request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }

    /**
     * success.jsp页面执行后，该方法会执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion方法执行了...111");
    }
}

然后我们得让前端控制器知道我们写了拦截器。所以我们需要配置拦截器：

<?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">

    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.siyi"/>

    <!-- 视图解析对象 -->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/"/>
        <property name="suffix" value=".jsp"/>
    </bean>

    <!-- 配置拦截器 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <!-- 要拦截的具体方法 -->
            <mvc:mapping path="/user/*"/>
            <!-- 不要拦截的方法 -->
            <!--<mvc:exclude-mapping path=""/>-->
            <!-- 配置拦截器对象 -->
            <bean class="com.siyi.interceptor.MyInterceptor1"/>
        </mvc:interceptor>
    </mvc:interceptors>
    
    <!-- 开启springmvc注解支持 -->
    <mvc:annotation-driven/>
</beans>
  • controller
package com.siyi.controller;

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

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

    @RequestMapping("/testInterceptor")
    public String testInterceptor(){
        System.out.println("testInterceptor执行了...");
        return "success";
    }
}
  • seccess.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h2>执行成功</h2>
<%
    System.out.println("success.jsp执行了。。。");
%>
</body>
</html>

运行结果如下：

springmvc 拦截html springmvc 拦截 域名_springmvc 拦截html


由此我们可以看出当存在拦截器时，首先页面访问时先经过拦截器的preHandle方法，当preHandle方法放行后，在执行controller，然后又经过拦截器，执行postHandle方法，最后加载页面，页面加载之后才执行afterCompletion方法。

放行的含义是指，如果有下一个拦截器就执行下一个，如果该拦截器处于拦截器链的最后一个，则执行控制器中的方法。

public interface HandlerInterceptor {
	/**
	* 如何调用：
	* 	按拦截器定义顺序调用
	* 何时调用：
	* 	只要配置了都会调用
	* 有什么用：
	* 	如果程序员决定该拦截器对请求进行拦截处理后还要调用其他的拦截器，或者是业务处理器去进行处理，则返回 true。
	* 	如果程序员决定不需要再调用其他的组件去处理请求，则返回 false。
	*/
	default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
		return true;
	}
	/**
	* 如何调用：
	* 	按拦截器定义逆序调用
	* 何时调用：
	* 	在拦截器链内所有拦截器返成功调用
	* 有什么用：
	* 	在业务处理器处理完请求后，但是 DispatcherServlet 向客户端返回响应前被调用，
	* 	在该方法中对用户请求 request 进行处理。
	*/
	default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
	}
	/**
	* 如何调用：
	* 	按拦截器定义逆序调用
	* 何时调用：
	* 	只有 preHandle 返回 true 才调用
	* 有什么用：
	* 	在 DispatcherServlet 完全处理完请求后被调用，
	* 	可以在该方法中进行一些资源清理的操作。
	*/
	default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
	}
}