devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringMVC-异步调用，拦截器与异常处理

作者：不正经 | 2024-03-12 10:32:09

赞

踩

SpringMVC-异步调用，拦截器与异常处理

1.异步调用

1.发送异步请求

  1. <a href="javascript:void(0);" id="testAjax">访问controller</a>
  2. <script type="text/javascript" src="js/jquery-3.7.1.js"></script>
  3. <script type="text/javascript">
  4.     $(function(){
  5.     $("#testAjax").click(function(){ //为id="testAjax"的组件绑定点击事件
  6.         $.ajax({ //发送异步调用
  7.             type:"POST", //请求方式： POST请求
  8.             url:"ajaxController", //请求参数（也就是请求内容）
  9.             data:'ajax message', //请求参数（也就是请求内容）
  10.             dataType:"text", //响应正文类型
  11.             contentType:"application/text", //请求正文的MIME类型
  12.         });
  13.     });
  14. });
  15. </script>

接收异步请求参数

名称： @RequestBody

类型： 形参注解

位置：处理器类中的方法形参前方

作用：将异步提交数据组织成标准请求参数格式，并赋值给形参

范例

  1. @RequestMapping("/ajaxController")
  2. public String ajaxController(@RequestBody String message){
  3.     System.out.println(message);
  4.     return "page.jsp";
  5. }

注解添加到Pojo参数前方时，封装的异步提交数据按照Pojo的属性格式进行关系映射

注解添加到集合参数前方时，封装的异步提交数据按照集合的存储结构进行关系映射

  1. @RequestMapping("/ajaxPojoToController")
  2. //如果处理参数是POJO，且页面发送的请求数据格式与POJO中的属性对应，@RequestBody注解可以自动映射对应请求数据到POJO中
  3. //注意：POJO中的属性如果请求数据中没有，属性值为null，POJO中没有的属性如果请求数据中有，不进行映射
  4. public String  ajaxPojoToController(@RequestBody User user){
  5.     System.out.println("controller pojo :"+user);
  6.     return "page.jsp";
  7. }
  8.  
  9. @RequestMapping("/ajaxListToController")
  10. //如果处理参数是List集合且封装了POJO，且页面发送的数据是JSON格式的对象数组，数据将自动映射到集合参数中
  11. public String  ajaxListToController(@RequestBody List<User> userList){
  12.     System.out.println("controller list :"+userList);
  13.     return "page.jsp";
  14. }

2.异步请求接受响应数据

方法返回值为Pojo时，自动封装数据成json对象数据

  1. @RequestMapping("/ajaxReturnJson")
  2. @ResponseBody
  3. public User ajaxReturnJson(){
  4.     System.out.println("controller return json pojo...");
  5.     User user = new User();
  6.     user.setName("Jockme");
  7.     user.setAge(40);
  8.     return user;
  9. }  
  1. @RequestMapping("/ajaxReturnJsonList")
  2. @ResponseBody
  3. //基于jackon技术，使用@ResponseBody注解可以将返回的保存POJO对象的集合转成json数组格式数据
  4. public List ajaxReturnJsonList(){
  5.     System.out.println("controller return json list...");
  6.     User user1 = new User();
  7.     user1.setName("Tom");
  8.     user1.setAge(3);
  9.  
  10.     User user2 = new User();
  11.     user2.setName("Jerry");
  12.     user2.setAge(5);
  13.  
  14.     ArrayList al = new ArrayList();
  15.     al.add(user1);
  16.     al.add(user2);
  17.  
  18.     return al;
  19. }

3.跨域访问

跨域访问介绍

当通过域名A下的操作访问域名B下的资源时，称为跨域访问

跨域访问时，会出现无法访问的现象

跨域环境搭建

为当前主机添加备用域名

        修改windows安装目录中的host文件

        格式：ip 域名

动态刷新DNS

        命令：ipconfig /displaydns

        命令：ipconfig /flushdns

跨域访问支持

名称： @CrossOrigin

类型： 方法注解 、 类注解

位置：处理器类中的方法上方 或 类上方

作用：设置当前处理器方法/处理器类中所有方法支持跨域访问

  1. @RequestMapping("/cross")
  2. @ResponseBody
  3. //使用@CrossOrigin开启跨域访问
  4. //标注在处理器方法上方表示该方法支持跨域访问
  5. //标注在处理器类上方表示该处理器类中的所有处理器方法均支持跨域访问
  6. @CrossOrigin
  7. public User cross(HttpServletRequest request){
  8.     System.out.println("controller cross..."+request.getRequestURL());
  9.     User user = new User();
  10.     user.setName("ljb");
  11.     user.setAge(21);
  12.     return user;
  13. }

2.拦截器

1.拦截器概述

请求处理过程解析

拦截器（ Interceptor）是一种动态拦截方法调用的机制

作用：

在指定的方法调用前后执行预先设定后的的代码

阻止原始方法的执行

核心原理： AOP思想

拦截器链：多个拦截器按照一定的顺序，对原始被调用功能进行增强

拦截器VS过滤器

归属不同： Filter属于Servlet技术， Interceptor属于SpringMVC技术

拦截内容不同： Filter对所有访问进行增强， Interceptor仅针对SpringMVC的访问进行增强

2.自定义拦截器的开发

  1. package com.controller;
  2.  
  3. import org.springframework.stereotype.Controller;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5.  
  6. @Controller
  7. public class InterceptorController {
  8.     @RequestMapping("/handleRun")
  9.     public String handleRun(){
  10.         System.out.println("业务处理器运行---------main");
  11.         return "page.jsp";
  12.     }
  13. }

实现HandlerInterceptor接口

  1. package com.interceptor;
  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.  
  9. //自定义拦截器需要实现HandleInterceptor接口
  10. public class MyInterceptor implements HandlerInterceptor {
  11.     //处理器运行之前执行
  12.     @Override
  13.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  14.         System.out.println("前置运行----a1");
  15.         //返回值为false将拦截原始处理器的运行
  16.         //如果配置多拦截器，返回值为false将终止当前拦截器后面配置的拦截器的运行
  17.         return true;
  18.     }
  19.  
  20.     //处理器运行之后执行
  21.     @Override
  22.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
  23.         System.out.println("后置运行----b1");
  24.     }
  25.  
  26.     //所有拦截器的后置执行全部结束后，执行该操作
  27.     @Override
  28.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  29.         System.out.println("完成运行----c1");
  30.     }
  31.  
  32.     //三个方法的运行顺序为    preHandle -> postHandle -> afterCompletion
  33.     //如果preHandle返回值为false，三个方法仅运行preHandle
  34. }
  1.  <context:component-scan base-package="com"/>
  2.  
  3.     <mvc:interceptors>
  4.         <mvc:interceptor>
  5.             <mvc:mapping path="/handleRun"/>
  6.             <bean class="com.interceptor.MyInterceptor"/>
  7.         </mvc:interceptor>
  8.     </mvc:interceptors>
  9.     <mvc:annotation-driven/>

 注意：配置顺序为先配置执行位置，后配置执行类

3.拦截器配置与方法参数 

前置处理方法

原始方法之前运行

  1. public boolean preHandle(HttpServletRequest request,
  2.                          HttpServletResponse response,
  3.                          Object handler) throws Exception {
  4.     System.out.println("preHandle");
  5.     return true;
  6. }

参数：

request:请求对象

response:响应对象

handler:被调用的处理器对象，本质上是一个方法对象，对反射中的Method对象进行了再包装

返回值：

返回值为false，被拦截的处理器将不执行

后置处理方法

原始方法运行后运行，如果原始方法被拦截，则不执行

  1. public void postHandle(HttpServletRequest request,
  2.                        HttpServletResponse response,
  3.                        Object handler,
  4.                        ModelAndView modelAndView) throws Exception {
  5.     System.out.println("postHandle");
  6. }

参数：

modelAndView：如果处理器执行完成具有返回结果，可以读取到对应数据与页面信息，并进行调整

完成处理方法

拦截器最后执行的方法，无论原始方法是否执行

  1. public void afterCompletion(HttpServletRequest request,
  2.                             HttpServletResponse response,
  3.                             Object handler,
  4.                             Exception ex) throws Exception {
  5.     System.out.println("afterCompletion");
  6. }

参数：

ex：如果处理器执行过程中出现异常对象，可以针对异常情况进行单独处理

拦截器配置项

  1. <mvc:interceptors>
  2.     <!--开启具体的拦截器的使用，可以配置多个-->
  3.     <mvc:interceptor>
  4.         <!--设置拦截器的拦截路径，支持*通配-->
  5.         <!--/**         表示拦截所有映射-->
  6.         <!--/*          表示拦截所有/开头的映射-->
  7.         <!--/user/*     表示拦截所有/user/开头的映射-->
  8.         <!--/user/add*  表示拦截所有/user/开头，且具体映射名称以add开头的映射-->
  9.         <!--/user/*All  表示拦截所有/user/开头，且具体映射名称以All结尾的映射-->
  10.         <mvc:mapping path="/*"/>
  11.         <mvc:mapping path="/**"/>
  12.         <mvc:mapping path="/handleRun*"/>
  13.         <!--设置拦截排除的路径，配置/**或/*，达到快速配置的目的-->
  14.         <mvc:exclude-mapping path="/b*"/>
  15.         <!--指定具体的拦截器类-->
  16.         <bean class="MyInterceptor"/>
  17.     </mvc:interceptor>
  18. </mvc:interceptors>

4.多拦截器配置

当配置多个拦截器时，形成拦截器链

拦截器链的运行顺序参照配置的先后顺序

当拦截器中出现对原始处理器的拦截，后面的拦截器均终止运行

当拦截器运行中断，仅运行配置在前面的拦截器的afterCompletion操作

附：责任链模式 

责任链模式是一种行为模式

特征：

沿着一条预先设定的任务链顺序执行，每个节点具有独立的工作任务

优势：

独立性：只关注当前节点的任务，对其他任务直接放行到下一节点

隔离性：具备链式传递特征，无需知晓整体链路结构，只需等待请求到达后进行处理即可

灵活性：可以任意修改链路结构动态新增或删减整体链路责任

解耦：将动态任务与原始任务解耦

弊端：

链路过长时，处理效率低下

可能存在节点上的循环引用现象，造成死循环，导致系统崩溃

3.异常处理

1.异常处理器

HandlerExceptionResolver接口（异常处理器）

  1. @Component
  2. public class ExceptionResolver implements HandlerExceptionResolver {
  3.     public ModelAndView resolveException(HttpServletRequest request,
  4.                                          HttpServletResponse response,
  5.                                          Object handler,
  6.                                          Exception ex) {
  7.         System.out.println("my exception is running...");
  8.         ModelAndView modelAndView = new ModelAndView();
  9.         //定义异常现象出现后，反馈给用户查看的信息
  10.         modelAndView.addObject("msg","出错啦！ ");
  11.         //定义异常现象出现后，反馈给用户查看的页面
  12.         modelAndView.setViewName("error.jsp");
  13.         return modelAndView;
  14.     }
  15. }

根据异常的种类不同，进行分门别类的管理，返回不同的信息

  1. public class ExceptionResolver implements HandlerExceptionResolver {
  2.     @Override
  3.     public ModelAndView resolveException(HttpServletRequest request,
  4.                                          HttpServletResponse response,
  5.                                          Object handler,
  6.                                          Exception ex) {
  7.         System.out.println("my exception is running ...."+ex);
  8.         ModelAndView modelAndView = new ModelAndView();
  9.         if( ex instanceof NullPointerException){
  10.             modelAndView.addObject("msg","空指针异常");
  11.         }else if ( ex instanceof  ArithmeticException){
  12.             modelAndView.addObject("msg","算数运算异常");
  13.         }else{
  14.             modelAndView.addObject("msg","未知的异常");
  15.         }
  16.         modelAndView.setViewName("error.jsp");
  17.         return modelAndView;
  18.     }
  19. }

2.注解开发异常处理器

使用注解实现异常分类管理

名称： @ControllerAdvice

类型： 类注解

位置：异常处理器类上方

作用：设置当前类为异常处理器类

名称： @ExceptionHandler

类型： 方法注解

位置：异常处理器类中针对指定异常进行处理的方法上方

作用：设置指定异常的处理方式

  1. @Component
  2. @ControllerAdvice
  3. public class ExceptionAdvice {
  4.     @ExceptionHandler(Exception.class)
  5.     @ResponseBody
  6.     public String doNullException(Exception ex){
  7.         return "空指针异常";
  8.     }
  9.  
  10. }

3.异常处理解决方案 

 

4.自定义异常

  1. package com.exception;
  2.  
  3. //自定义异常继承RuntimeException，覆盖父类所有的构造方法
  4. public class BusinessException extends RuntimeException {
  5.     public BusinessException() {
  6.     }
  7.  
  8.     public BusinessException(String message) {
  9.         super(message);
  10.     }
  11.  
  12.     public BusinessException(String message, Throwable cause) {
  13.         super(message, cause);
  14.     }
  15.  
  16.     public BusinessException(Throwable cause) {
  17.         super(cause);
  18.     }
  19.  
  20.     public BusinessException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
  21.         super(message, cause, enableSuppression, writableStackTrace);
  22.     }
  23. }

异常触发方式

  1. if(user.getName().trim().length()<4) {
  2.     throw new BusinessException("用户名长度必须在2-4位之间，请重新输入！ ");
  3. }

通过自定义异常将所有的异常现象进行分类管理，以统一的格式对外呈现异常消息

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/223646
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号