SpringMVC——核心技术：拦截器

最新推荐文章于 2023-01-10 09:24:38 发布

莫得情感的码农

最新推荐文章于 2023-01-10 09:24:38 发布

阅读量806

点赞数

分类专栏： SSM框架 # Spring MVC 文章标签： spring java

本文链接：https://blog.csdn.net/liuhaiyang98/article/details/119812739

版权

SSM框架同时被 2 个专栏收录

16 篇文章 6 订阅

订阅专栏

Spring MVC

9 篇文章 2 订阅

订阅专栏

1.拦截器介绍

SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。

2. 单个拦截器的实例

工作流程

2.1 控制器类

package com.liuhaiyang.controller;

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

import javax.servlet.http.HttpSession;

@Controller
public class MyController {
    @RequestMapping(value = "/some.do")
    public ModelAndView doforward(HttpSession session, String name, Integer age){
        System.out.println("执行了MyController的dosome方法");
        //添加一个临时数据
        session.setAttribute("attr","在controller中增加一个临时数据");
        ModelAndView mv=new ModelAndView();
        mv.addObject("name",name);
        mv.addObject("age",age);
        mv.setViewName("show");

        return  mv;
    }

}

2.2 拦截器类

package com.liuhaiyang.handler;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Date;

/**
 * 拦截器
 */
public class Myhandler implements HandlerInterceptor {
    /**
     *  preHandle:预先处理请求的方法 。相当于总开关 参数：Object handler：被拦截的控制器对象（Mycontroller）
     *      返回值：Boolean   当为真时，请求正确，可以被Controller处理，程序正常执行。
     *          当为假时，请求不能被处理，控制器方法不会执行。请求到此截止。
     *     特点：1.预处理方法的执行时间：在控制器方法之前先执行的. 2.可以对请求做处理，可以做登陆检查，全限的判断，统计数据等等
     *     3.决定请求是否被执行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("=====MyHandler拦截器的preHandler====");
       // request.getRequestDispatcher("/tips.jsp").forward(request,response);
        return true;
    }

    /**
     *  postHandler：后处理方法 参数：Object handler：被拦截的控制器对象(MyController)
     *          ModelAndView mv:控制器方法的返回值（请求的执行结果）
     *     特点：1.在控制器方法之后执行的。  2.能获取到控制器方法的执行结果。可以修改原来的执行结果
     *     可以修改数据，也可以修改视图。   3.可以做对请求的二次处理
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("=====MyHandler拦截器的postHandler====");
       if (mv!=null){
           mv.addObject("mydate",new Date());
           mv.setViewName("other");
       }
    }

    /**
     *  afterCompletion：最后执行的方法  参数：Object handler：被拦截的控制器对象(MyController) Exception ex：异常对象
     *  特点：1.在请求处理完成后执行的，请求处理完成的标志 是视图处理完成，对试图执行forward操作后
     *       2.可以做程序最后要做的工作，释放内存，清理临时变量
     *       3.方法的执行条件：1）当前的拦截器它的preHandler方法必须执行。 2）preHandler必须返回true
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("=====MyHandler拦截器的afterCompletion====");
        HttpSession session=request.getSession();
        Object obj=session.getAttribute("attr");
        System.out.println("attr==="+obj);
        //删除数据
        session.removeAttribute("attr");
        //检查
        obj=session.getAttribute("attr");
        System.out.println("删除后，检查是还存在，attr="+obj);
    }
}

2.3 springmvc配置文件

<?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">
<!--spring的配置文件  声明组件扫描器-->
    <context:component-scan base-package="com.liuhaiyang.controller"/>
<!--    声明视图解析器；帮助处理视图  主要帮助我们处理重复的多余的冗余路径等-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--        前缀：指定试图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
<!--        后缀，试图文件的扩展名-->
        <property name="suffix" value=".jsp"/>  <!--表示所有的jsp文件-->
    </bean>

<!--声明拦截器-->
    <mvc:interceptors>
<!--        声明第一个拦截器-->
        <mvc:interceptor>
<!--            指定拦截器的拦截地址 uri地址，可以使用 ** 通配符-->
            <mvc:mapping path="/**"/>  <!--表示所有的地址-->
<!--            指定拦截器-->
            <bean class="com.liuhaiyang.handler.Myhandler"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

2.4 web.xml

<?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"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
<!--声明springmvc的核心对象-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--        如果是自定义的文件，需要在这写自定义配置文件的位置    和监听器的是一样的-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>

<!--        在服务器启动时候创建对象，和容器的顺序    在启动时装载对象 随意给个值要求大于等于0  数值越小，创建的越早-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
<!--        url-pattern 作用：把一些请求交给servlet处理   就例如将/mymvc交给springmvc处理
            使用中央调度器（DispatcherServlet）  1.使用扩展名方式，格式/*.xxx  例如：xxx.xml表示以xml结尾的都算
-->
        <url-pattern>*.do</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>
        <init-param>
            <!--            强制请求（request）对象使用encoding的编码方式-->
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <!--            强制应答（response）对象使用encoding的编码方式-->
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
</web-app>

2.5 首页（index.jsp）


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>springmvc</title>
</head>
<body>
    <p>拦截器操作</p>
    <form action="some.do" method="post">
        姓名：<input type="text" name="name"/><br>
        年龄：<input type="text" name="age"/><br>
        操作：<input type="submit" value="提交"/><br>
    </form>
</body>
</html>

2.6响应页面（ other.jsp）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
        拦截器做出的输出,显示request作用域中的数据<br>
        <h2>name数据：<%=request.getAttribute("name")%></h2>
        <h2>age数据：${age}</h2>
        <h2>date时间数据：${mydate}</h2>
</body>
</html>

2.7 结果截图

当拦截器类中的 preHandle 方法返回 true 时，请求的执行顺序：用户发起some.do → preHandle → 控制器的doSome方法 → postHandle → afterCompletion。

当拦截器类中的 preHandle 方法返回 false 时，请求仅仅只会执行 preHandle 方法。

3.多个拦截器的实例

工作流程

3.1 控制器类

package com.liuhaiyang.controller;

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

import javax.servlet.http.HttpSession;

@Controller
public class MyController {
    @RequestMapping(value = "/some.do")
    public ModelAndView doforward(HttpSession session, String name, Integer age){
        System.out.println("执行了MyController的dosome方法");
        ModelAndView mv=new ModelAndView();
        mv.addObject("name",name);
        mv.addObject("age",age);
        mv.setViewName("show");

        return  mv;
    }

}

3.2 两个拦截器类

package com.liuhaiyang.handler;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Date;

public class Myhandler implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("=====MyHandler11111拦截器的preHandler====");
       // request.getRequestDispatcher("/tips.jsp").forward(request,response);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("=====MyHandler11111拦截器的postHandler====");
       if (mv!=null){
           mv.addObject("mydate",new Date());
           mv.setViewName("other");
       }
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("=====MyHandler11111拦截器的afterCompletion====");
        HttpSession session=request.getSession();
        Object obj=session.getAttribute("attr");
        System.out.println("attr==="+obj);
        //删除数据
        session.removeAttribute("attr");
        //检查
        obj=session.getAttribute("attr");
        System.out.println("删除后，检查是还存在，attr="+obj);
    }
}

package com.liuhaiyang.handler;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Date;

public class Myhandler2 implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("=====MyHandler22222拦截器的preHandler====");
       // request.getRequestDispatcher("/tips.jsp").forward(request,response);
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("=====MyHandler22222拦截器的postHandler====");
       if (mv!=null){
           mv.addObject("mydate",new Date());
           mv.setViewName("other");
       }
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("=====MyHandler22222拦截器的afterCompletion====");
        HttpSession session=request.getSession();
        Object obj=session.getAttribute("attr");
        System.out.println("attr==="+obj);
        //删除数据
        session.removeAttribute("attr");
    }
}

3.3 springmvc配置文件

<?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">
<!--spring的配置文件  声明组件扫描器-->
    <context:component-scan base-package="com.liuhaiyang.controller"/>
<!--    声明视图解析器；帮助处理视图  主要帮助我们处理重复的多余的冗余路径等-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--        前缀：指定试图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
<!--        后缀，试图文件的扩展名-->
        <property name="suffix" value=".jsp"/>  <!--表示所有的jsp文件-->
    </bean>

<!--声明拦截器   声明顺序就是拦截器的执行顺序-->
    <mvc:interceptors>
<!--        声明第一个拦截器-->
        <mvc:interceptor>
<!--            指定拦截器的拦截地址 uri地址，可以使用 ** 通配符-->
            <mvc:mapping path="/**"/>  <!--表示所有的地址-->
<!--            指定拦截器-->
            <bean class="com.liuhaiyang.handler.Myhandler"/>
        </mvc:interceptor>

<!--        声明第二个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="com.liuhaiyang.handler.Myhandler2"/>
        </mvc:interceptor>
    </mvc:interceptors>
</beans>

3.4web.xml文件同2.4

3.5 首页（index.jsp）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>多个拦截器</title>
</head>
<body>
    <p>拦截器操作</p>
    <form action="some.do" method="post">
        姓名：<input type="text" name="name"/><br>
        年龄：<input type="text" name="age"/><br>
        操作：<input type="submit" value="提交"/><br>
    </form>
</body>
</html>

3.6 响应页面（result.jsp）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
        拦截器做出的输出,显示request作用域中的数据<br>
        <h2>name数据：<%=request.getAttribute("name")%></h2>
        <h2>age数据：${age}</h2>
        <h2>date时间数据：${mydate}</h2>
</body>
</html>

3.7 运行结果

用户发起some.do → 拦截器1的 preHandle 方法 → 拦截器2的 preHandle 方法 → 控制器的doSome方法 → 拦截器2的postHandle方法 → 拦截器1的postHandle方法 → 拦截器2的 afterCompletion 方法 → 拦截器1的 afterCompletion 方法。

当第一个拦截器返回 true，第二个拦截器返回 false时，请求的执行顺序是这样的：

用户发起some.do → 拦截器1的 preHandle 方法 → 拦截器2的 preHandle 方法 → 拦截器1的 afterCompletion 方法。

当第一个拦截器返回 false，第二个拦截器返回值无论是 true 还是 false ，请求的执行顺序都只能是这样的：

用户发起some.do → 拦截器1的 preHandle 方法。因为拦截器1的 preHandle 方法返回 false之后，直接就切断了请求的执行，后面都不会再执行其他内容了。

4. 权限拦截器（简单的应用小实例）

4.1 控制器类

package com.liuhaiyang.controller;

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

import javax.servlet.http.HttpSession;

@Controller
public class MyController {
    @RequestMapping(value = "/some.do")
    public ModelAndView doforward(HttpSession session, String name, Integer age){
        System.out.println("执行了MyController的dosome方法");
        //添加一个临时数据
        session.setAttribute("attr","在controller中增加一个临时数据");
        ModelAndView mv=new ModelAndView();
        mv.addObject("name",name);
        mv.addObject("age",age);
        mv.setViewName("show");

        return  mv;
    }

}

4.2 拦截器类

package com.liuhaiyang.handler;

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

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Date;

public class Myhandler implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("=====MyHandler11111拦截器的preHandler====");
        String username="";
        //获取登录信息
       Object attr= request.getSession().getAttribute("username");
       if (attr!=null){
           username=(String) attr;
       }
       if ("zhangsan".equals(username)){
           return true;
       }else {
           request.getRequestDispatcher("/tips.jsp").forward(request,response);
           return false;
       }


    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("=====MyHandler11111拦截器的postHandler====");
       if (mv!=null){
           mv.addObject("mydate",new Date());
           mv.setViewName("other");
       }
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("=====MyHandler11111拦截器的afterCompletion====");
        HttpSession session=request.getSession();
        Object obj=session.getAttribute("attr");
        System.out.println("attr==="+obj);
        //删除数据
        session.removeAttribute("attr");
        //检查
        obj=session.getAttribute("attr");
        System.out.println("删除后，检查是还存在，attr="+obj);
    }
}

4.3 springmvc配置文件、web.xml文件与上面例子相同

4.4 首页（index.jsp）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>拦截器小例子</title>
</head>
<body>
    <p>拦截器操作</p>
    <form action="some.do" method="post">
        姓名：<input type="text" name="name"/><br>
        年龄：<input type="text" name="age"/><br>
        操作：<input type="submit" value="提交"/><br>
    </form>
</body>
</html>

4.5 响应页面（result.jsp用于显示index.jsp页面的提交结果）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
        拦截器做出的输出,显示request作用域中的数据<br>
        <h2>name数据：<%=request.getAttribute("name")%></h2>
        <h2>age数据：${age}</h2>
        <h2>date时间数据：${mydate}</h2>
</body>
</html>

4.6 模拟登录、登出页面、非法用户（login.jsp、logout.jsp、tips.jsp）

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
    登陆操作<%
        session.setAttribute("username","zhangsan");
    %>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>退出操作</title>
</head>
<body>
    退出系统！！！！<%
         session.removeAttribute("username");
    %>
</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    tips.jsp  系统不允许访问！！！
</body>
</html>

2.7 操作流程

首先通过 login.jsp 页面发起请求（获取会话作用域对象，此时的用户名只能是 zhangsan）；之后通过 index.jsp 首页，发起 some.do 请求进行登录，如果输入的用户名是 zhangsan，则会转到正确的页面：result.jsp；如果输入了其他用户名，则会通过请求转发，直接转到非用户无法登录的页面：tips.jsp。最后可以通过登出页面（logout.jsp），将自己的用户名信息进行删除。

2.8 结果截图：

5.拦截器和过滤器的差别（易混淆）

拦截器和过滤器的差别：

1.拦截器是springmvc框架中的对象。过滤器是servlet中的对象。
2.拦截器对象是由框架容器创建的。过滤器对象是由tomcat创建的。
2.拦截器侧重于对请求做判断处理的，可以截断请求。过滤器侧重于对request、response对象的属性、参数设置值的。
4.拦截器的执行时间有三个（控制器方法之前、控制器方法之后、请求完成之后）。过滤器执行时间只在请求之前。
5.拦截器是对controller、动态资源进行拦截的。过滤器可以过滤所以请求（动态、静态）。
6.拦截器和过滤器一起执行：先执行过滤器，后面是中央调度器，再后面是拦截器，最后才是控制器方法。

莫得情感的码农

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SpringMVC——核心技术：拦截器

1.拦截器介绍SpringMVC 中的 Interceptor 拦截器是非常重要和相当有用的，它的主要作用是拦截指定的用户请求，并进行相应的预处理与后处理。其拦截的时间点在“处理器映射器根据用户提交的请求映射出了所要执行的处理器类，并且也找到了要执行该处理器类的处理器适配器，在处理器适配器执行处理器之前”。当然，在处理器映射器映射出所要执行的处理器类时，已经将拦截器与处理器组合为了一个处理器执行链，并返回给了中央调度器。2.单个拦截器的实例工作流程2.1 控制器类p...
复制链接

扫一扫