• SpringMVC：拦截器（动力）

     

     

     

     

     

     

     

     

    web.xml:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
    5.          version="4.0">
    6.  
    7. <!--    声明，注册springmvc的核心对象DispatcherServlet-->
    8.     <servlet>
    9.         <servlet-name>myweb</servlet-name>
    10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    11.  
    12. <!--        自定义springmvc读取的配置文件的位置-->
    13.         <init-param>
    14.             <!--springmvc的配置文件属性-->
    15.             <param-name>contextConfigLocation</param-name>
    16.             <!-- 指定自定义文件的位置-->
    17.             <param-value>classpath:springmvc.xml</param-value>
    18.         </init-param>
    19.  
    20. <!--        在tomcat启动后，创建Servlet对象
    21.                load-on-startup:表示tomcat启动后创建对象的顺序，它的值是正数，数值越小 tomacat创建对象越早
    22. -->
    23.         <load-on-startup>1</load-on-startup>
    24.  
    25.     </servlet>
    26.  
    27. <!--    所有的*..do请求交给myweb中央处理器处理-->
    28.     <servlet-mapping>
    29.         <servlet-name>myweb</servlet-name>
    30.         <url-pattern>*.do</url-pattern>
    31.     </servlet-mapping>
    32.  
    33.     <!--注册声明过滤器，解决post请求乱码问题-->
    34.     <filter>
    35.         <filter-name>characterEncodingFilter</filter-name>
    36.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    37.  
    38.         <!--设置项目中使用的编码-->
    39.         <init-param>
    40.             <param-name>encoding</param-name>
    41.             <param-value>utf-8</param-value>
    42.         </init-param>
    43.         <!--强制请求对象（HttpServletRequest）使用encoding编码的值-->
    44.         <init-param>
    45.             <param-name>forceRequestEncoding</param-name>
    46.             <param-value>true</param-value>
    47.         </init-param>
    48.         <!--强制应答对象（HttpServletResponse）使用encoding编码的值-->
    49.         <init-param>
    50.             <param-name>forceReponsetEncoding</param-name>
    51.             <param-value>true</param-value>
    52.         </init-param>
    53.     </filter>
    54.     <filter-mapping>
    55.         <filter-name>characterEncodingFilter</filter-name>
    56.         <!--
    57.            /*:表示强制所有的请求先通过过滤器处理
    58.          -->
    59.         <url-pattern>/*</url-pattern>
    60.     </filter-mapping>
    61. </web-app>

     springmvc.xml:声明拦截器

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
    6.        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">
    7.  
    8. <!-- 用了注解需要注解扫描器：声明组件扫描器：包扫描-->
    9.     <context:component-scan base-package="com.bjpowernode.controller"/>
    10.  
    11. <!--    声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    12.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    13.         <!-- 前缀：视图文件的路径-->
    14.         <property name="prefix" value="/WEB-INF/view/"/>
    15.         <!-- 后缀：视图文件的扩展名-->
    16.         <property name="suffix" value=".jsp"/>
    17.     </bean>
    18.  
    19.     <!--声明拦截器：拦截器可以有0个或多个-->
    20.     <mvc:interceptors>
    21.         <!--声明第一个拦截器-->
    22.         <mvc:interceptor>
    23.             <!--
    24.                指定拦截器的请求uri地址
    25.                path：就是uri地址，可以通配符 ** 可以表示任意字符、文件或多级目录和目录中的文件
    26.                /user/**  :以user开头的请求都会诶拦截
    27.                /** :所有请求都会被拦截
    28.             -->
    29.             <mvc:mapping path="/**"/>
    30.             <!--声明拦截器对象-->
    31.             <bean class="com.bjpowernode.handler.MyInterceptor"/>
    32.         </mvc:interceptor>
    33.     </mvc:interceptors>
    34.  
    35. </beans>

    拦截器MyInterceptor：先展示拦截器的第一个方法preHandle方法

    1. package com.bjpowernode.handler;
    2.  
    3. import org.springframework.web.servlet.HandlerInterceptor;
    4. import org.springframework.web.servlet.ModelAndView;
    5.  
    6. import javax.servlet.http.HttpServletRequest;
    7. import javax.servlet.http.HttpServletResponse;
    8. import java.util.Date;
    9.  
    10. //拦截器类：拦截用户的请求
    11. public class MyInterceptor implements HandlerInterceptor {
    12.     /**
    13.      *preHandle预处理方法：
    14.      *   重要：是整个项目的入口，门户。当preHandle返回true 请求可以被处理
    15.      *       preHandle返回false 请求到此方法就被截止
    16.      * 参数：
    17.      *   Object hander：被拦截的对象
    18.      *   返回值boolean：
    19.      *   true：表示请求验证通过，可以执行处理器的方法
    20.      *     拦截器的MyInterceptor的preHandle()
    21.      *     =====打印MyController中的do.some（）方法===
    22.      *     拦截器的MyInterceptor的postHandle()
    23.      *     拦截器的MyInterceptor的afterCompletion()
    24.      *   false：请求没有通过拦截器验证，请求达到拦截器就截止了。请求没有被处理
    25.      *     拦截器的MyInterceptor的preHandle()
    26.      *
    27.      * 特点：
    28.      * 1.该方法是在控制器方法（MyController的doSome方法）之前先执行的,用户的请求先到达此方法。
    29.      * 2.在这个方法可以获取请求信息，验证请求是否符合要求。
    30.      *   可以验证用户是否登录，验证用户是否有权限访问某个链接地址（url）。
    31.      *   如果验证失败，可以截断请求，请求不能被处理。
    32.      *   如果验证成功，可以放行请求，此时控制器方法才能执行。
    33.      */
    34.  
    35.     @Override
    36.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    37.         System.out.println("拦截器的MyInterceptor的preHandle()");
    38.  
    39.         //计算的业务逻辑，根据计算结果，返回true或者false
    40.  
    41.         //当返回false时，给浏览器一个返回结果
    42.         //request.getRequestDispatcher("/tips.jsp").forward(request,response);
    43.         return true;
    44.     }
    45.  
    46.     /**
    47.      *postHandle:后处理方法。
    48.      * 参数：Object handler表示被拦截的处理器对象MyController
    49.      *       ModelAndView mv表示处理器方法的返回值
    50.      * 特点：
    51.      * 1.该方法是在控制器方法（MyController的doSome方法）之后先执行的
    52.      * 2.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的数据和视图，
    53.      *    可以影响到最后的执行结果
    54.      * 3.主要用来对原来的执行结果做二次修正
    55.      */
    56.     @Override
    57.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mv) throws Exception {
    58.         System.out.println("拦截器的MyInterceptor的postHandle()");
    59.     }
    60.  
    61.  
    62.     /* afterCompletion:最后执行的方法
    63.       参数：
    64.        Object handler：被拦截器的处理器对象
    65.        Exception ex：程序中发生的异常
    66.        特点：
    67.         1.在请求处理完成后执行的。框架中规定当你的视图解析器完成后，对视图执行了forward。
    68.           就认为请求完成。
    69.         2.主要用来做资源回收的工作，程序请求过程中创建了一些对象，在这里可以删除，
    70.           把占用的内存回收。
    71.      */
    72.     @Override
    73.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    74.         System.out.println("拦截器的MyInterceptor的afterCompletion()");
    75.     }
    76. }

    MyController：

    1. package com.bjpowernode.controller;
    2. import org.springframework.stereotype.Controller;
    3. import org.springframework.web.bind.annotation.RequestMapping;
    4. import org.springframework.web.servlet.ModelAndView;
    5.  
    6. @Controller
    7. public class MyController {
    8.  
    9.     @RequestMapping(value = "/some.do")
    10.     public ModelAndView doForword(String name,Integer age) {
    11.         System.out.println("=====打印MyController中的do.some（）方法===");
    12.         //处理some.do请求了，相当于service调用处理完成了
    13.         ModelAndView mv=new ModelAndView();
    14.  
    15.         mv.addObject("myname",name);
    16.         mv.addObject("myage",age);
    17.  
    18.         mv.setViewName("show");
    19.         return mv;
    20.     }
    21. }

    show.jsp:

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 19:01
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17. </head>
    18. <body>
    19.  <h3>/WEB-INF/view/show.jsp.从request作用域获取数据</h3>
    20.   <h3>myname数据：${myname}</h3>
    21.   <h3>myage数据：${myage}</h3>
    22. </body>
    23. </html>

    tips.jsp:

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/25
    5.   Time: 8:39
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17. </head>
    18. <body>
    19.    tips.jsp 请求被拦截，不能被执行
    20. </body>
    21. </html>

     index.jsp:

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 17:37
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17. </head>
    18. <body>
    19.   <p>一个拦截器</p>
    20.     <form action="some.do" method="post">
    21.       姓名：<input type="text" name="name"><br>
    22.       年龄：<input type="text" name="age"><br>
    23.     <input type="submit" value="提交请求">
    24.     </form>
    25.  
    26.  
    27. </body>
    28. </html>

    当第一个方法的返回值为true时：

     

     

     

    当返回false时：

    request.getRequestDispatcher("/tips.jsp").forward(request,response);
return false;

     

     

     

    MyInterceptor

     第二个方法postHandle（）：

    1. package com.bjpowernode.handler;
    2.  
    3. import org.springframework.web.servlet.HandlerInterceptor;
    4. import org.springframework.web.servlet.ModelAndView;
    5.  
    6. import javax.servlet.http.HttpServletRequest;
    7. import javax.servlet.http.HttpServletResponse;
    8. import java.util.Date;
    9.  
    10. //拦截器类：拦截用户的请求
    11. public class MyInterceptor implements HandlerInterceptor {
    12.     /**
    13.      *preHandle预处理方法：
    14.      *   重要：是整个项目的入口，门户。当preHandle返回true 请求可以被处理
    15.      *       preHandle返回false 请求到此方法就被截止
    16.      * 参数：
    17.      *   Object hander：被拦截的对象
    18.      *   返回值boolean：
    19.      *   true：表示请求验证通过，可以执行处理器的方法
    20.      *     拦截器的MyInterceptor的preHandle()
    21.      *     =====打印MyController中的do.some（）方法===
    22.      *     拦截器的MyInterceptor的postHandle()
    23.      *     拦截器的MyInterceptor的afterCompletion()
    24.      *   false：请求没有通过拦截器验证，请求达到拦截器就截止了。请求没有被处理
    25.      *     拦截器的MyInterceptor的preHandle()
    26.      *
    27.      * 特点：
    28.      * 1.该方法是在控制器方法（MyController的doSome方法）之前先执行的,用户的请求先到达此方法。
    29.      * 2.在这个方法可以获取请求信息，验证请求是否符合要求。
    30.      *   可以验证用户是否登录，验证用户是否有权限访问某个链接地址（url）。
    31.      *   如果验证失败，可以截断请求，请求不能被处理。
    32.      *   如果验证成功，可以放行请求，此时控制器方法才能执行。
    33.      */
    34.  
    35.     @Override
    36.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    37.         System.out.println("拦截器的MyInterceptor的preHandle()");
    38.  
    39.         //计算的业务逻辑，根据计算结果，返回true或者false
    40.  
    41.         //当返回false时，给浏览器一个返回结果
    42.         //request.getRequestDispatcher("/tips.jsp").forward(request,response);
    43.         return true;
    44.     }
    45.  
    46.     /**
    47.      *postHandle:后处理方法。
    48.      * 参数：Object handler表示被拦截的处理器对象MyController
    49.      *       ModelAndView mv表示处理器方法的返回值
    50.      * 特点：
    51.      * 1.该方法是在控制器方法（MyController的doSome方法）之后先执行的
    52.      * 2.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的数据和视图，
    53.      *    可以影响到最后的执行结果
    54.      * 3.主要用来对原来的执行结果做二次修正
    55.      */
    56.     @Override
    57.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mv) throws Exception {
    58.         System.out.println("拦截器的MyInterceptor的postHandle()");
    59.  
    60.         //对原来的dosome执行结果，进行调整
    61.         if (mv!=null){
    62.             //修改数据
    63.             mv.addObject("mydate",new Date());
    64.             //修改视图
    65.             mv.setViewName("other");
    66.         }
    67.     }
    68.  
    69.  
    70.     /* afterCompletion:最后执行的方法
    71.       参数：
    72.        Object handler：被拦截器的处理器对象
    73.        Exception ex：程序中发生的异常
    74.        特点：
    75.         1.在请求处理完成后执行的。框架中规定当你的视图解析器完成后，对视图执行了forward。
    76.           就认为请求完成。
    77.         2.主要用来做资源回收的工作，程序请求过程中创建了一些对象，在这里可以删除，
    78.           把占用的内存回收。
    79.      */
    80.     @Override
    81.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    82.         System.out.println("拦截器的MyInterceptor的afterCompletion()");
    83.     }
    84. }

    other.jsp:

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 19:01
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17. </head>
    18. <body>
    19.  <h3>/WEB-INF/view/other.jsp.从request作用域获取数据</h3>
    20.   <h3>myname数据：${myname}</h3>
    21.   <h3>myage数据：${myage}</h3>
    22.   <h3>拦截器中添加的数据${mydate}</h3>
    23. </body>
    24. </html>

     

    拦截器第三个方法： afterCompletion：

    计算请求处理完成的时间：

    1. package com.bjpowernode.handler;
    2.  
    3. import org.springframework.web.servlet.HandlerInterceptor;
    4. import org.springframework.web.servlet.ModelAndView;
    5.  
    6. import javax.servlet.http.HttpServletRequest;
    7. import javax.servlet.http.HttpServletResponse;
    8. import java.util.Date;
    9.  
    10. //拦截器类：拦截用户的请求
    11. public class MyInterceptor implements HandlerInterceptor {
    12.  
    13.     //计算请求的时间，定义成员变量
    14.     private long btime=0;
    15.  
    16.     /**
    17.      *preHandle预处理方法：
    18.      *   重要：是整个项目的入口，门户。当preHandle返回true 请求可以被处理
    19.      *       preHandle返回false 请求到此方法就被截止
    20.      * 参数：
    21.      *   Object hander：被拦截的对象
    22.      *   返回值boolean：
    23.      *   true：表示请求验证通过，可以执行处理器的方法
    24.      *     拦截器的MyInterceptor的preHandle()
    25.      *     =====打印MyController中的do.some（）方法===
    26.      *     拦截器的MyInterceptor的postHandle()
    27.      *     拦截器的MyInterceptor的afterCompletion()
    28.      *   false：请求没有通过拦截器验证，请求达到拦截器就截止了。请求没有被处理
    29.      *     拦截器的MyInterceptor的preHandle()
    30.      *
    31.      * 特点：
    32.      * 1.该方法是在控制器方法（MyController的doSome方法）之前先执行的,用户的请求先到达此方法。
    33.      * 2.在这个方法可以获取请求信息，验证请求是否符合要求。
    34.      *   可以验证用户是否登录，验证用户是否有权限访问某个链接地址（url）。
    35.      *   如果验证失败，可以截断请求，请求不能被处理。
    36.      *   如果验证成功，可以放行请求，此时控制器方法才能执行。
    37.      */
    38.  
    39.     @Override
    40.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    41.         btime=System.currentTimeMillis();//时间开始
    42.  
    43.         System.out.println("拦截器的MyInterceptor的preHandle()");
    44.  
    45.         //计算的业务逻辑，根据计算结果，返回true或者false
    46.  
    47.         //当返回false时，给浏览器一个返回结果
    48.         //request.getRequestDispatcher("/tips.jsp").forward(request,response);
    49.         return true;
    50.     }
    51.  
    52.     /**
    53.      *postHandle:后处理方法。
    54.      * 参数：Object handler表示被拦截的处理器对象MyController
    55.      *       ModelAndView mv表示处理器方法的返回值
    56.      * 特点：
    57.      * 1.该方法是在控制器方法（MyController的doSome方法）之后先执行的
    58.      * 2.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的数据和视图，
    59.      *    可以影响到最后的执行结果
    60.      * 3.主要用来对原来的执行结果做二次修正
    61.      */
    62.     @Override
    63.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView mv) throws Exception {
    64.         System.out.println("拦截器的MyInterceptor的postHandle()");
    65.  
    66.         //对原来的dosome执行结果，进行调整
    67.         if (mv!=null){
    68.             //修改数据
    69.             mv.addObject("mydate",new Date());
    70.             //修改视图
    71.             mv.setViewName("other");
    72.         }
    73.     }
    74.  
    75.  
    76.     /* afterCompletion:最后执行的方法
    77.       参数：
    78.        Object handler：被拦截器的处理器对象
    79.        Exception ex：程序中发生的异常
    80.        特点：
    81.         1.在请求处理完成后执行的。框架中规定当你的视图解析器完成后，对视图执行了forward。
    82.           就认为请求完成。
    83.         2.主要用来做资源回收的工作，程序请求过程中创建了一些对象，在这里可以删除，
    84.           把占用的内存回收。
    85.      */
    86.     @Override
    87.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    88.         System.out.println("拦截器的MyInterceptor的afterCompletion()");
    89.  
    90.         long etime=System.currentTimeMillis();
    91.         System.out.println("计算从preHandle到请求处理完成的时间："+(etime-btime));
    92.     }
    93. }

     

     

    再次发送 ：

     

     

     第一次需要的时间较长 ，因为jsp第一次需要编译，请求初始化操作，花费时间较长

    jsp编译成servlet才能使用，在以后访问时jsp已经编译完了，不用在重新编译，时间就花费较少

  • 相关阅读:
    【笔记篇】10仓管系统库内管理——之《实战供应链》
    PCL点云处理之基于FPFH特征的全局配准流程具体实现（二百二十一）
    Vue 路由 ElementUI组件库
    Centos7挂载磁盘（笔记）
    FTP主动模式和被动模式（2）- 防火墙对FTP的影响 ASPF
    国庆作业day6
    27.在springboot中使用thymeleaf的属性inline(text, javascript 和 none)
    Go语言入门【5】数组
    AL-实体抽取主动学习调研
    scannet v2 数据集下载
  • 原文地址：https://blog.csdn.net/dengfengling999/article/details/125455193