3.1 拦截器（interceptor）的使用

3.1.1 监听器、过滤器和拦截器对比

  1. Servlet：处理Request请求和Response响应
  2. 过滤器（Filter）：对Request请求起到过滤的作⽤，作⽤在Servlet之前，如果配置为/*可以对所有的资源访问（servlet、js/css静态资源等）进⾏过滤处理
  3. 监听器（Listener）：实现了javax.servlet.ServletContextListener 接⼝的服务器端组件，它随Web应⽤的启动⽽启动，只初始化⼀次，然后会⼀直运⾏监视，随Web应⽤的停⽌⽽销毁
  • 作⽤⼀：做⼀些初始化⼯作，web应⽤中spring容器启动ContextLoaderListener
  • 作⽤⼆：监听web中的特定事件，⽐如HttpSession,ServletRequest的创建和销毁；变量的创建、销毁和修改等。可以在某些动作前后增加处理，实现监控，⽐如统计在线⼈数，利⽤HttpSessionLisener等。
  1. 拦截器（Interceptor）：是SpringMVC、Struts等表现层框架⾃⼰的，不会拦截jsp/html/css/image的访问等，只会拦截访问的控制器⽅法（Handler）。
  • 在Handler业务逻辑执⾏之前拦截⼀次
  • 在Handler逻辑执⾏完毕但未跳转⻚⾯之前拦截⼀次
  • 在跳转⻚⾯之后拦截⼀次
  1. 从配置的⻆度也能够总结发现：serlvet、filter、listener是配置在web.xml中的，⽽interceptor是配置在表现层框架⾃⼰的配置⽂件中的

1649822473(1).jpg

3.2.2 拦截器的编写和执行流程

  1. 代码如下，继承HandlerInterceptor重写方法

    1. public class MyIntercepter01 implements HandlerInterceptor {
    2. /**
    3. * 会在handler⽅法业务逻辑执⾏之前执⾏
    4. * 往往在这⾥完成权限校验⼯作
    5. * @param request
    6. * @param response
    7. * @param handler
    8. * @return 返回值boolean代表是否放⾏，true代表放⾏，false代表中⽌
    9. * @throws Exception
    10. */
    11. @Override
    12. public boolean preHandle(HttpServletRequest request, HttpServletResponse
    13.      response, Object handler) throws Exception {
    14.  System.out.println("MyIntercepter01 preHandle......");
    15.  return true;
    16. }
    18. /**
    19. * 会在handler⽅法业务逻辑执⾏之后尚未跳转⻚⾯时执⾏
    20. * @param request
    21. * @param response
    22. * @param handler
    23. * @param modelAndView 封装了视图和数据，此时尚未跳转⻚⾯呢，你可以在这⾥针对返回的
    24. *                                         数据和视图信息进⾏修改
    25. * @throws Exception
    26. */
    27. @Override
    28. public void postHandle(HttpServletRequest request, HttpServletResponse
    29.    response, Object handler, ModelAndView modelAndView) throws Exception {
    30.  System.out.println("MyIntercepter01 postHandle......");
    31. }
    33. /**
    34. * ⻚⾯已经跳转渲染完毕之后执⾏
    35. * @param request
    36. * @param response
    37. * @param handler
    38. * @param ex 可以在这⾥捕获异常
    39. * @throws Exception
    40. */
    41. @Override
    42. public void afterCompletion(HttpServletRequest request,
    43. HttpServletResponse response, Object handler, Exception ex) throws Exception {
    44.  System.out.println("MyIntercepter01 afterCompletion......");
    45. }
    46. }
    1. <mvc:interceptors>
    2. <!--拦截所有handler-->
    3. <!--<bean class="com.lagou.edu.interceptor.MyIntercepter01"/>-->
    4. <mvc:interceptor>
    5.  <!--配置当前拦截器的url拦截规则，**代表当前⽬录下及其⼦⽬录下的所有url-->
    6.  <mvc:mapping path="/**"/>
    7.  <!--exclude-mapping可以在mapping的基础上排除⼀些url拦截-->
    8.  <!--<mvc:exclude-mapping path="/demo/**"/>-->
    9.  <bean class="com.lagou.edu.interceptor.MyIntercepter01"/>
    10. </mvc:interceptor>
    11. <mvc:interceptor>
    12.  <mvc:mapping path="/**"/>
    13.  <bean class="com.lagou.edu.interceptor.MyIntercepter02"/>
    14. </mvc:interceptor>
    15. </mvc:interceptors>

  2. 单个拦截器的执行流程

3. SpringMVC的高级应用 - 图2

  • 程序先执⾏preHandle()⽅法，如果该⽅法的返回值为true，则程序会继续向下执⾏处理器中的⽅法，否则将不再向下执⾏。
  • 在业务处理器（即控制器Controller类）处理完请求后，会执⾏postHandle()⽅法，然后会通过DispatcherServlet向客户端返回响应。
  • 在DispatcherServlet处理完请求后，才会执⾏afterCompletion()⽅法。
  1. 多个拦截器执行流程：

多个拦截器（假设有两个拦截器Interceptor1和Interceptor2，并且在配置⽂件中， Interceptor1拦截
器配置在前），在程序中的执⾏流程如下图所示：
3. SpringMVC的高级应用 - 图3

  • 从图可以看出，当有多个拦截器同时⼯作时，它们的preHandle()⽅法会按照配置⽂件中拦截器的配置顺序执⾏，⽽它们的postHandle()⽅法和afterCompletion()⽅法则会按照配置顺序的反序执⾏。

3.2 处理multipart形式的数据

  1. 引入依赖

    1. <!--⽂件上传所需jar坐标-->
    2. <dependency>
    3. <groupId>commons-fileupload</groupId>
    4. <artifactId>commons-fileupload</artifactId>
    5. <version>1.3.1</version>
    6. </dependency>

  2. 配置⽂件上传解析器

    1. <!--配置⽂件上传解析器，id是固定的multipartResolver-->
    2. <bean id="multipartResolver"
    3.    class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    4. <!--设置上传⼤⼩，单位字节-->
    5. <property name="maxUploadSize" value="1000000000"/>
    6. </bean>

  3. 前端Form

    1. <!--
    2. 1 method="post"
    3. 2 enctype="multipart/form-data"
    4. 3 type="file"
    5. -->
    6. <form method="post" enctype="multipart/form-data" action="/demo/upload">
    7. <input type="file" name="uploadFile"/>
    8. <input type="submit" value="上传"/>
    9. </form>

  4. 后端接收handler

    1. @RequestMapping("upload")
    2. public String upload(MultipartFile uploadFile, HttpServletRequest request)
    3.  throws IOException {
    4.  // ⽂件原名，如xxx.jpg
    5.  String originalFilename = uploadFile.getOriginalFilename();
    6.  // 获取⽂件的扩展名,如jpg
    7.  String extendName =
    8.      originalFilename.substring(originalFilename.lastIndexOf(".") + 1,
    9.                                 originalFilename.length());
    10.  String uuid = UUID.randomUUID().toString();
    11.  // 新的⽂件名字
    12.  String newName = uuid + "." + extendName;
    13.  String realPath =
    14.      request.getSession().getServletContext().getRealPath("/uploads");
    15.  // 解决⽂件夹存放⽂件数量限制，按⽇期存放
    16.  String datePath = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
    17.  File floder = new File(realPath + "/" + datePath);
    18.  if(!floder.exists()) {
    19.      floder.mkdirs();
    20.  }
    21.  uploadFile.transferTo(new File(floder,newName));
    22.  return "success";
    23. }

    3.3 SpringMVC的异常处理机制

    1. // 可以让我们优雅的捕获所有Controller对象handler⽅法抛出的异常
    2. @ControllerAdvice
    3. public class GlobalExceptionResolver {
    4.  @ExceptionHandler(ArithmeticException.class)
    5.  public ModelAndView handleException(ArithmeticException exception,
    6.                                      HttpServletResponse response) {
    7.      ModelAndView modelAndView = new ModelAndView();
    8.      modelAndView.addObject("msg",exception.getMessage());
    9.      modelAndView.setViewName("error");
    10.      return modelAndView;
    11.  }
    12. }

    3.4 基于Flash属性的跨重定向请求数据传递

  5. 重定向时请求参数会丢失，我们往往需要重新携带请求参数，我们可以进⾏⼿动参数拼接如下：

    • return “redirect:handle01?name=” + name;
  6. 但是上述拼接参数的⽅法属于get请求，携带参数⻓度有限制，参数安全性也不⾼，此时，我们可以使⽤SpringMVC提供的flash属性机制，向上下⽂中添加flash属性，框架会在session中记录该属性值，当跳转到⻚⾯之后框架会⾃动删除flash属性，不需要我们⼿动删除，通过这种⽅式进⾏重定向参数传递，参数⻓度和安全性都得到了保障，如下： ```java /**
  • SpringMVC 重定向时参数传递的问题
  • 转发：A 找 B 借钱400，B没有钱但是悄悄的找到C借了400块钱给A
  • url不会变,参数也不会丢失,⼀个请求
  • 重定向：A 找 B 借钱400，B 说我没有钱，你找别⼈借去，那么A ⼜带着400块的借钱需求找到C
  • url会变,参数会丢失需要重新携带参数,两个请求 */ @RequestMapping(“/handleRedirect”) public String handleRedirect(String name,RedirectAttributes redirectAttributes) { // return “redirect:handle01?name=” + name; // 拼接参数安全性、参数⻓度都有局限 // addFlashAttribute⽅法设置了⼀个flash类型属性，该属性会被暂存到session中，在 // 跳转到⻚⾯之后该属性销毁 redirectAttributes.addFlashAttribute(“name”,name); return “redirect:handle01”; } ```