SpringMVC--配置拦截器_高级框架用于拦截资源的是-CSDN博客

本文链接：https://blog.csdn.net/Lzy410992/article/details/109313131

SpringMVC目录：

SpringMVC–快速入门
SpringMVC–常用注解
SpringMVC–请求参数绑定
SpringMVC–返回不同类型的数据
SpringMVC–文件上传
SpringMVC–异常处理
SpringMVC–配置拦截器
Spring+SpringMVC+Mybatis框架整合（SSM整合）

SpringMVC 中的拦截器

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

拦截器与过滤器

Spring MVC中拦截器（Interceptor）方法都是通过代理的方式来调用的，其类似于Servlet中的过滤器（Filter），它主要用于拦截用户请求并作相应的处理，也就是用于对处理器进行预处理和后处理。两者的比较：

1、过滤器是依赖于Servlet容器，基于回调函数，Interceptor依赖与框架，基于反射机制。
2、过滤器的过滤范围更大,还可以过滤一些静态资源,拦截器只拦截请求。
3、拦截器是基于Java的反射机制的，而过滤器是基于函数回调。
4、拦截器不依赖与Servlet容器，过滤器依赖与Servlet容器。
5、拦截器只能对Action请求起作用，而过滤器则可以对几乎所有的请求起作用。
6、拦截器可以访问Action上下文、值栈里的对象，而过滤器不能访问。
7、在Action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

Spring MVC中的拦截器提供的是非系统级别的拦截，就覆盖面来说，拦截器没有过滤器强大，但是比较更有针对性。Spring MVC中的拦截器是基于Java反射机制实现的，准确说是基于JDK实现的动态代理，它依赖于具体的接口，在运行期间动态生成字节码。

关于过滤器
过滤器实际上就是对Web资源进行拦截，做一些处理后再交给下一个过滤器或Servlet处理，通常都是用来拦截Request进行处理的，也可以对返回的Response进行拦截处理。过滤器是一个程序，它先于与之相关的Servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个Servlet或JSP页面上，并且可以检查进入这些资源的请求信息。
Servlet过滤器的基本原理：在Servlet作为过滤器使用时，它可以对客户的请求进行处理。处理完成后，它会交给下一个过滤器处理，这样客户的请求会逐个依次处理，直到请求发送到目标为止。例如，某个网站里有提交“修改的注册信息”的网页，当用户填写完修改信息并提交后，服务器在进行处理时需要做两项工作：判断客户端的会话是否有效；对提交的数据进行统一编码。这两项工作可以在由两个过滤器组成的过滤链里进行处理。当过滤器处理成功后，把提交的数据发送到成功的目标中；如果过滤器处理不成功，将把视图派发到指定的错误页面。

拦截器类的实现

实现拦截器类首先要实现HandlerInterceptor接口，并实现接口中的三个方法(preHandle、postHandle 、afterCompletion)。这个接口是继承自AbstractInterceptor类的，并且对里面的init()和destroy()方法进行空实现，而把intercept()方法设置为抽象方法，让继承它的子类去实现，这样的话，子类只要实现这个intercept()方法就可以了，比直接实现接口要简单。
在这里插入图片描述

自定义拦截器

编写一个普通类实现 HandlerInterceptor 接口

拦截器是动态拦截Action调用的对象，它提供了一种机制可以使开发者在一个Action执行的前后执行一段代码，也可以在一个Action执行前阻止其执行，同时也提供了一种可以提取Action中可重用部分代码的方式。在AOP中，拦截器用于在某个方法或者字段被访问之前，进行拦截然后再之前或者之后加入某些操作。Spring MVC的拦截器主要是用在插件上，扩展件上，例如：Hibernate、Spring、Struts2等。

/**
 * 自定义拦截器
 */
public class MyInterceptor implements HandlerInterceptor{

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

    /**
     * 后处理方法，controller方法执行后，success.jsp执行之前,在该方法中对用户请求 request 进行处理
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor1执行了...后1111");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }

    /**
     *  只有 preHandle 返回 true 才调用,success.jsp页面执行后，该方法会执行
     * 可以在该方法中进行一些资源清理的操作
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor执行了...最后1111");
    }

}

配置拦截器：Spring MVC使用的拦截器可以在XML中进行配置，在spring-mvc.xml中添加响应的代码

<!--配置拦截器-->
<mvc:interceptors>
    <!--配置拦截器-->
    <mvc:interceptor>
        <!--要拦截的具体的方法-->
        <mvc:mapping path="/user/*"/>
        <!--不要拦截的方法
        <mvc:exclude-mapping path=""/>
        -->
        <!--配置拦截器对象-->
        <bean class="com.ly.interceptor.MyInterceptor" />
    </mvc:interceptor>
</mvc:interceptors>

测试运行结果：
控制器类实现

/**
 * @Author: Ly
 * @Date: 2020-09-28 22:26
 */
@Controller
@RequestMapping("/user")
public class UserController {

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

}

开始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>

成功界面：

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

</body>
</html>

运行结果：

MyInterceptor1执行了...前1111
testInterceptor执行了...
MyInterceptor1执行了...后1111
MyInterceptor1执行了...最后1111

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

配置多个拦截器

当拦截多个或部分请求时，可以写多个bean来实现，在XML文件进行配置即可。
拦截器链（Interceptor Chain）：拦截器链就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。
在这里插入图片描述

流程测试

在springmvc.xml文件中进行配置：

<!--配置拦截器-->
<mvc:interceptors>
    <!--配置拦截器-->
    <mvc:interceptor>
        <!--要拦截的具体的方法-->
        <mvc:mapping path="/user/*"/>
        <!--不要拦截的方法
        <mvc:exclude-mapping path=""/>
        -->
        <!--配置拦截器对象-->
        <bean class="com.ly.interceptor.MyInterceptor1" />
    </mvc:interceptor>

    <!--配置第二个拦截器-->
    <mvc:interceptor>
        <!--要拦截的具体的方法-->
        <mvc:mapping path="/**"/>
        <!--不要拦截的方法
        <mvc:exclude-mapping path=""/>
        -->
        <!--配置拦截器对象-->
        <bean class="com.ly.interceptor.MyInterceptor2" />
    </mvc:interceptor>
</mvc:interceptors>

拦截器 1 的代码：

/**
 * 自定义拦截器1
 */
public class MyInterceptor1 implements HandlerInterceptor{

    /**
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor1执行了...前1111");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /**
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor1执行了...后1111");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }

    /**
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor1执行了...最后1111");
    }

}

拦截器 2 的代码：

/**
 * 自定义拦截器2
 */
public class MyInterceptor2 implements HandlerInterceptor{

    /**
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor2执行了...前2222");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
        return true;
    }

    /**
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor2执行了...后2222");
        // request.getRequestDispatcher("/WEB-INF/pages/error.jsp").forward(request,response);
    }

    /**
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor2执行了...最后2222");
    }

}

运行结果：

MyInterceptor1执行了...前1111
MyInterceptor2执行了...前2222
testInterceptor执行了...
MyInterceptor2执行了...后2222
MyInterceptor1执行了...后1111
MyInterceptor2执行了...最后2222
MyInterceptor1执行了...最后1111