• 【推荐】SpringMVC与JSON数据返回及异常处理机制的使用

                                                     🎬 艳艳耶✌️：个人主页

                                                    🔥 个人专栏 ：《【推荐】Spring与Mybatis集成整合》

                                                    ⛺️  生活的理想，为了不断更新自己 !

     

     1.JSON

    在SpringMVC中，JSON数据返回通常是通过使用`@ResponseBody`注解将Java对象转换为JSON格式，并直接发送给客户端。该注解可以用于Controller中的方法，用于指示该方法的返回值应该作为响应的内容返回，而不是作为视图解析。当请求到达被注解的方法时，SpringMVC会自动将返回的对象转换为JSON格式，并将其作为HTTP响应发送给客户端。这个过程通常是通过使用Jackson、Gson等JSON转换库来完成的。JSON数据的返回使得前后端可以方便地进行数据交换和通信。

    需要注意的是，为了使Java对象正确地被转换为JSON格式，需要为对象提供相应的getter方法，并确保对象的属性与JSON键值一致。

    当客户端收到这个响应后，它可以解析JSON数据，并根据其中的信息进行相应的处理。常见的客户端处理方式可以是使用JavaScript进行解析和展示，或者使用其他的后端程序进行数据处理。

    以上就是在SpringMVC中返回JSON数据的一般过程。

    2.异常处理机制

    在异常处理过程中，当发生异常时，SpringMVC会自动寻找匹配的异常处理方法进行处理。首先会寻找当前Controller类中标注的@ExceptionHandler注解方法，如果找不到，则会寻找全局异常处理器中匹配的方法。然后，根据处理方法的返回值，进行适当的处理，例如返回错误页面视图或JSON格式的错误信息。

    通过异常处理机制，我们可以对特定类型的异常进行定制化处理，提高应用程序的可靠性和友好性。同时，全局异常处理器和自定义异常处理器的使用可以有效地统一和简化异常处理逻辑，提高代码的可维护性。

    3.JSON数据返回

    当使用`@ResponseBody`注解返回JSON数据时，SpringMVC会自动将Java对象序列化为JSON格式。以下是SpringMVC返回JSON数据的一般步骤：

    1. 配置Jackson或其他JSON处理库：SpringMVC默认使用Jackson库来进行JSON转换，因此你需要在项目中添加相关的依赖，或者确保已经正确配置了Jackson库。
    2. 在Controller方法上标注`@ResponseBody`注解：在需要返回JSON数据的方法上添加`@ResponseBody`注解，以指示返回值应当被转换为JSON格式。
    3. 创建Java对象并返回：在被`@ResponseBody`注解标注的方法中，构造一个需要返回的对象，并将其返回。这个对象将被自动序列化为JSON格式。
    4. 响应头和内容：SpringMVC会自动设置HTTP响应头的Content-Type为`application/json`，以指示返回的是JSON数据类型。同时，将序列化后的JSON数据作为HTTP响应内容返回给客户端。

    3.1代码演示

    导入依赖

    1. <dependency>
    2.     <groupId>com.fasterxml.jackson.core</groupId>
    3.     <artifactId>jackson-databind</artifactId>
    4.     <version>2.9.3</version>
    5. </dependency>
    6. <dependency>
    7.     <groupId>com.fasterxml.jackson.core</groupId>
    8.     <artifactId>jackson-core</artifactId>
    9.     <version>2.9.3</version>
    10. </dependency>
    11. <dependency>
    12.     <groupId>com.fasterxml.jackson.core</groupId>
    13.     <artifactId>jackson-annotations</artifactId>
    14.     <version>2.9.3</version>
    15. </dependency>

    配置 spring-mvc.xml

    在项目中找到自己创建的配置文件， spring-mvc.xml 配置文件，进行配置

    1. <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    2.     <property name="messageConverters">
    3.         <list>
    4.         	<ref bean="mappingJackson2HttpMessageConverter"/>
    5.         </list>
    6.     </property>
    7. </bean>
    8. <bean id="mappingJackson2HttpMessageConverter"
    9. class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
    10.     <!--处理中文乱码以及避免IE执行AJAX时，返回JSON出现下载文件-->
    11.     <property name="supportedMediaTypes">
    12.         <list>
    13.             <value>text/html;charset=UTF-8</value>
    14.             <value>text/json;charset=UTF-8</value>
    15.             <value>application/json;charset=UTF-8</value>
    16.         </list>
    17.     </property>
    18. </bean>

    使用@ResponseBody注解

    @ResponseBody 注解的作用是将Controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。

        注意：在使用此注解之后不会再走视图解析器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。

    创建一个名为 JsonController 的类，类编写访问地址的方法进行数据返回。

    1. package com.sy.web;
    2.  
    3.  
    4. import com.sy.biz.BookBiz;
    5. import com.sy.exception.GlobalException;
    6. import com.sy.model.Book;
    7. import com.sy.utis.PageBean;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.web.bind.annotation.RequestMapping;
    10. import org.springframework.web.bind.annotation.ResponseBody;
    11. import org.springframework.web.bind.annotation.RestController;
    12.  
    13. import javax.servlet.http.HttpServletRequest;
    14. import java.util.HashMap;
    15. import java.util.List;
    16. import java.util.Map;
    17.  
    18. //@ResponseBody
    19. //@Controller
    20.  
    21. @RestController
    22.  
    23. @RequestMapping("/book/json")
    24. public class JsonController {
    25.     @Autowired
    26.     private BookBiz bookBiz;
    27.  
    28.     /**
    29.      * 返回List
    30.      * @param req
    31.      * @param book
    32.      * @return
    33.      */
    34. //    @ResponseBody
    35.     @RequestMapping("/list")
    36.     public List list(HttpServletRequest req, Book book){
    37.         PageBean pageBean = new PageBean();
    38.         pageBean.setRequest(req);
    39.         List lst = this.bookBiz.selectByBookPager(book, pageBean);
    40.         return lst;
    41.     }
    42.  
    43.     /**
    44.      * 返回T
    45.      * @param req
    46.      * @param book
    47.      * @return
    48.      */
    49.     @ResponseBody
    50.     @RequestMapping("/load")
    51.     public Book load(HttpServletRequest req, Book book){
    52.         if(book.getBid() != null){
    53.             List lst = this.bookBiz.selectByBookPager(book, null);
    54.             return lst.get(0);
    55.         }
    56.         return null;
    57.     }
    58.  
    59.  
    60.     /**
    61.      * 返回List
    62.      * @param req
    63.      * @param book
    64.      * @return
    65.      */
    66.     @ResponseBody
    67.     @RequestMapping("/mapList")
    68.     public List mapList(HttpServletRequest req, Book book){
    69.         PageBean pageBean = new PageBean();
    70.         pageBean.setRequest(req);
    71.         List lst = this.bookBiz.mapListPager(book, pageBean);
    72.         System.out.println(1 / 0);
    73.         return lst;
    74.     }
    75.  
    76.     /**
    77.      * 返回Map
    78.      * @param req
    79.      * @param book
    80.      * @return
    81.      */
    82.     @ResponseBody
    83.     @RequestMapping("/mapLoad")
    84.     public Map mapLoad(HttpServletRequest req, Book book){
    85.         if(book.getBid() != null){
    86.             List lst = this.bookBiz.mapListPager(book, null);
    87.             return lst.get(0);
    88.         }
    89.         return null;
    90.     }
    91.  
    92.  
    93.     @ResponseBody
    94.     @RequestMapping("/all")
    95.     public Map all(HttpServletRequest req, Book book){
    96.         PageBean pageBean = new PageBean();
    97.         pageBean.setRequest(req);
    98.         List lst = this.bookBiz.selectByBookPager(book, pageBean);
    99.         Map map = new HashMap();
    100.         map.put("lst",lst);
    101.         map.put("pageBean",pageBean);
    102.         return map;
    103.     }
    104.  
    105. //    @ResponseBody
    106.     @RequestMapping("/jsonStr")
    107.     public String jsonStr(HttpServletRequest req, Book book){
    108.         if(true)
    109.         throw new GlobalException("温馨提示：信号不稳定！！！");
    110.         return "clzEdit";
    111.     }
    112.  
    113.  
    114. }

    在自动生成的配置文件中，配置动态SQL( mapListPager )来查询数据。

    1. <select id="mapListPager" resultType="java.util.Map" parameterType="com.sy.model.Book" >
    2.     select
    3.     *
    4.     from t_mvc_book
    5.     <where>
    6.       <if test="bname != null">
    7.         and bname like concat('%',#{bname},'%')
    8.       </if>
    9.     </where>
    10.   </select>

    在自动生成的接口中，编写需要访问文件的方法

     List  mapListPager(Book book);

    在自己创建的接口中增加该方法

       List  mapListPager(Book book, PageBean pageBean);

    在自己创建的实现类中重写该方法

    1.  @Override
    2.     public List<Map> mapListPager(Book book, PageBean pageBean) {
    3.         book = null;
    4.         return bookMapper.mapListPager(book);
    5.     }

    之后就可以直接开启服务器，在浏览器中进行访问地址输入进行测试

    4.异常处理机制

    4.1 为什么

    编译时异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试通过手段减少运行时异常的发生。在开发中，不管是dao层、service层还是controller层，都有可能抛出异常，在springmvc中，能将所有类型的异常处理从各处理过程解耦出来，既保证了相关处理过程的功能较单一，也实现了异常信息的统一处理和维护。

    SpringMVC作为一个优秀的Web层开发框架，在框架中已经集成了异常处理机制，可以帮我们我们灵活地处理程序中发生的异常，提高了我们程序的稳定性，令我们对程序运行中发生的异常更加可以控制，今天我们讲的就是SpringMVC框架中的对于异常的处理机制。
    本文中的所有程序都是基于SSM框架环境，以上一篇博文SSM框架整合为基础。

    4.2代码演示

    在项目中名为 spring-mvc.xml 配置文件中 增加异常处理的配置，增加以下配置。

    2. <bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">
    3.     
    4.     <property name="defaultErrorView" value="error"/>
    5.      
    6.     <property name="exceptionAttribute" value="ex"/>
    7.      
    8.     <property name="exceptionMappings">
    9.         <props>
    10.             <prop key="java.lang.RuntimeException">errorprop>
    11.         props>
    12.     	
    13.     property>
    14. bean>

    创建一个名为 : error.jsp 的显示页面

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <html>
    3. <head></head>
    4. <title>Title</title>
    5. <h1>错误信息</h1>
    6. <hr>
    7. ${ex}
    8. <hr>
    9. ${msg}
    10. </body>
    11. </html>

    异常一：

    首先创造一个错误进行测试，在创建的接口实现类中，找到mapListPage方法，增加一行代码 : 

    book= null;

    如下👇👇👇:

    再之后在 JsonController 类中找到 jsonStr 方法 进行修改。 

    结果展示： 

    异常二：

    创建一个处理异常类 名为: GlobalException

    1. package com.sy.exception;
    2.  
    3. public class GlobalException extends RuntimeException {
    4.     public GlobalException() {
    5.     }
    6.  
    7.     public GlobalException(String message) {
    8.         super(message);
    9.     }
    10.  
    11.     public GlobalException(String message, Throwable cause) {
    12.         super(message, cause);
    13.     }
    14.  
    15.     public GlobalException(Throwable cause) {
    16.         super(cause);
    17.     }
    18.  
    19.     public GlobalException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
    20.         super(message, cause, enableSuppression, writableStackTrace);
    21.     }
    22. }

    创建一个处理异常类 名为: GlobalExceptionHandler

    1. package com.sy.component;
    2.  
    3. import org.springframework.stereotype.Component;
    4. import org.springframework.web.bind.annotation.ControllerAdvice;
    5. import org.springframework.web.bind.annotation.ExceptionHandler;
    6. import org.springframework.web.bind.annotation.ResponseBody;
    7. import org.springframework.web.servlet.HandlerExceptionResolver;
    8. import org.springframework.web.servlet.ModelAndView;
    9.  
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import java.util.HashMap;
    13. import java.util.Map;
    14.  
    15. @Component
    16. public class GlobalExceptionHandler implements HandlerExceptionResolver {
    17.     @Override
    18.     public ModelAndView resolveException(HttpServletRequest httpServletRequest,
    19.                                          HttpServletResponse httpServletResponse,
    20.                                          Object o, Exception e) {
    21.         ModelAndView mv = new ModelAndView();
    22.         mv.setViewName("error");
    23.         if (e instanceof GlobalException){
    24.             GlobalException globalException = (GlobalException) e;
    25.             mv.addObject("ex",globalException.getMessage());
    26.             mv.addObject("msg","全局错误异常....");
    27.         }else if (e instanceof RuntimeException){
    28.             RuntimeException runtimeException = (RuntimeException) e;
    29.             mv.addObject("ex",runtimeException.getMessage());
    30.             mv.addObject("msg","运行时错误异常....");
    31.         }else{
    32.             mv.addObject("ex",e.getMessage());
    33.             mv.addObject("msg","其他错误异常....");
    34.         }
    35.         return mv;
    36.     }
    37.  
    38. }

    结果展示：

    异常三：

    将创建的处理异常类(GlobalExceptionHandler) 中所有代码修改为以下代码 : 

    1. package com.sy.component;
    2.  
    3. import com.sy.exception.GlobalException;
    4. import org.springframework.web.bind.annotation.ControllerAdvice;
    5. import org.springframework.web.bind.annotation.ExceptionHandler;
    6. import org.springframework.web.bind.annotation.ResponseBody;
    7.  
    8. import java.util.HashMap;
    9. import java.util.Map;
    10.  
    11. @ControllerAdvice
    12. public class GlobalExceptionHandler{
    13.     // 返回错误json数据
    14.     @ResponseBody
    15.     @ExceptionHandler
    16.     public Map handler(Exception e){
    17.         Map map = new HashMap();
    18.         if (e instanceof GlobalException){
    19.             GlobalException globalException = (GlobalException) e;
    20.             map.put("ex",globalException.getMessage());
    21.             map.put("msg","全局异常....");
    22.         }else if (e instanceof RuntimeException){
    23.             RuntimeException runtimeException = (RuntimeException) e;
    24.             map.put("ex",runtimeException.getMessage());
    25.             map.put("msg","运行时异常....");
    26.         }else {
    27.             map.put("ex",e.getMessage());
    28.             map.put("msg","其它异常....");
    29.         }
    30.         return map;
    31.     }
    32. }

    结果展示：

                                                                  今日分享结束！                                                                   

  • 相关阅读:
    SpringBoot工程打包与运行(Windows版)
    通讯网关软件004——利用CommGate X2Mbt实现Modbus TCP访问Mysql服务器
    C++ 中迭代器的使用
    vscode使用git
    string
    LogCat工具
    Docker安装以及修改Docker的默认存储路径
    ES6继承和ES5继承的区别
    sealos一键部署K8S环境（sealos3.0时代教程过时了，目前已经4.0了，请移步使用Sealos一键安装K8S）
    R语言移除列表中的空元素（列表数据中包含NULL，移除NULL元素）、使用purrr包的compact函数删除NULL元素
  • 原文地址：https://blog.csdn.net/2301_76988707/article/details/132859616