• 【SpringMVC】JSON数据返回及异常处理（相信我看完就懂的差不多了）

    目录

    一、JSON数据返回

    1、导入依赖

    2、配置文件

    3、Jackson

    3.1、介绍

    3.2、特点

    3.3、常用注解

    4、@ResponseBody注解使用

    4.1、Controller层

    4.2、biz层

    4.3、sql.xml

    4.4、页面

    4.5、测试

    4.6、注意@ResponseBody

    二、异常处理

    1、为什么要使用全局异常处理

    2、异常处理思路

    3、SpringMVC异常分类

    4、异常案例

    4.1、异常处理方法一

    4.2、异常处理方法二

    4.3、异常处理方法三

    一、JSON数据返回

    1、导入依赖

    在SpringMVC里的pom.xml文件里面添加jackson的依赖

    1. <dependency>
    2.     <groupId>com.fasterxml.jackson.coregroupId>
    3.     <artifactId>jackson-databindartifactId>
    4.     <version>2.9.3version>
    5. dependency>
    6. <dependency>
    7.     <groupId>com.fasterxml.jackson.coregroupId>
    8.     <artifactId>jackson-coreartifactId>
    9.     <version>2.9.3version>
    10. dependency>
    11. <dependency>
    12.     <groupId>com.fasterxml.jackson.coregroupId>
    13.     <artifactId>jackson-annotationsartifactId>
    14.     <version>2.9.3version>
    15. dependency>

    2、配置文件

    在自己配置的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.         
    11.         <property name="supportedMediaTypes">
    12.             <list>
    13.                 <value>text/html;charset=UTF-8value>
    14.                 <value>text/json;charset=UTF-8value>
    15.                 <value>application/json;charset=UTF-8value>
    16.             list>
    17.         property>
    18.     bean>

    3、Jackson

    3.1、介绍

    Jackson是一个用于Java对象和JSON数据之间相互转换的开源库。它提供了一组强大的API，可以将Java对象序列化为JSON格式的字符串，也可以将JSON字符串反序列化为Java对象。

    Jackson库由三个核心模块组成：

    1. Jackson Databind：用于将Java对象与JSON数据进行绑定（序列化和反序列化）。它提供了一系列注解，如@JsonProperty、@JsonFormat等，用于指定对象属性与JSON字段之间的映射关系，以及日期、时间等特殊类型的处理方式。Databind模块也提供了一些高级特性，如多态类型处理、双向引用处理等。

    2. Jackson Core：提供了JSON处理的核心功能，如JsonParser（用于解析JSON字符串）、JsonGenerator（用于生成JSON字符串）等。Core模块还提供了一些基本的数据类型和集合类型的序列化和反序列化支持。

    3. Jackson Annotation：提供了一些注解，用于在Java类中指定JSON字段的名称、顺序、默认值等属性。这些注解在Databind模块中使用。

    Jackson是一个简单基于Java应用库，Jackson可以轻松的将Java对象转换成json对象和xml文档，同样也可以将json、xml转换成Java对象。Jackson所依赖的jar包较少，简单易用并且性能也要相对高些，并且Jackson社区相对比较活跃，更新速度也比较快。

    3.2、特点

    • 容易使用，提供了高层次外观，简化常用的用例。
    • 无需创建映射，API提供了默认的映射大部分对象序列化。
    • 性能高，快速，低内存占用
    • 创建干净的json
    • 不依赖其他库
    • 代码开源

    3.3、常用注解

    Jackson库提供了一些常用的注解，用于在Java类中指定与JSON字段相关的属性和行为。

    常用注解
    注解说明
    @JsonIgnore
         		作用在字段或方法上，用来完全忽略被注解的字段和方法对应的属性
     
    @JsonProperty
         		作用在字段或方法上，用来对属性的序列化/反序列化，可以用来避免遗漏属性，同时提供对属性名称重命名
     
    @JsonIgnoreProperties
         		作用在类上，用来说明有些属性在序列化/反序列化时需要忽略掉
     
    @JsonUnwrapped
         		作用在属性字段或方法上，用来将子JSON对象的属性添加到封闭的JSON对象
     
    @JsonFormat
         		用于指定日期、时间等特殊类型的格式化方式。可以通过该注解的pattern属性指定日期格式。例如： 
    @JsonFormat(pattern="yyyy-MM-dd") private Date birthDate;

    1. @JsonInclude：用于控制序列化时是否包含某个属性。可以通过该注解的value属性指定包含属性的条件。例如：

      @JsonInclude(JsonInclude.Include.NON_NULL) private String address;

    2. @JsonAlias：用于指定多个JSON字段与同一个Java属性的映射关系。可以通过该注解的value属性指定多个JSON字段的名称。例如：

      @JsonAlias({"firstName", "first_name"}) private String name;

    3. @JsonGetter和@JsonSetter：用于指定自定义的getter和setter方法与JSON字段之间的映射关系。例如：

      @JsonGetter("name") public String getUserName() { return userName; }

    4. @JsonAnyGetter和@JsonAnySetter：用于处理不确定的属性（即不在Java类中定义的属性）。可以通过这些注解来动态地将这些属性转换为Map或其他形式。例如：

      @JsonAnyGetter public Map getAdditionalProperties() { return additionalProperties; }

    4、@ResponseBody注解使用

    @ResponseBody注解是Spring框架中常用的注解之一，它通常用于控制器方法或Restful API方法上，用于指示方法返回的结果直接写入HTTP响应体中，而不是通过视图解析器进行解析。它可以将方法返回的对象转换为指定的格式，如JSON、XML或其他格式，并将其作为HTTP响应体返回给客户端。

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

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

    @ResponseBody注解的方法，可以返回任何类型的对象作为响应体，包括普通对象、集合、字符串等。Spring会自动根据请求头中的"Accept"字段，选择合适的HttpMessageConverter进行转换。例如，如果请求头中指定了"Accept： http://localhost:8080/json"，则返回的对象会被转换为JSON格式的字符串。

    4.1、Controller层

    1. package com.tgq.web;
    2.  
    3. import com.tgq.biz.MyStudentBiz;
    4. import com.tgq.model.MyStudent;
    5. import com.tgq.utils.PageBean;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Controller;
    8. import org.springframework.web.bind.annotation.RequestMapping;
    9. import org.springframework.web.bind.annotation.ResponseBody;
    10.  
    11. import javax.servlet.http.HttpServletRequest;
    12. import java.util.HashMap;
    13. import java.util.List;
    14. import java.util.Map;
    15.  
    16. /**
    17.  * @软件包名 com.tgq.web
    18.  * @用户 tgq
    19.  * @create 2023-09-13 下午2:27
    20.  * @注释说明：
    21.  */
    22. @Controller
    23. //@ResponseBody
    24. //@RestController
    25. @RequestMapping("/sc/json")
    26. public class JsonController {
    27.     @Autowired
    28.     private MyStudentBiz myStudentBiz;
    29.  
    30.     @RequestMapping("/jsp")
    31.     public String updateByPrimaryKeySelective() {
    32.         return "json/list";
    33.     }
    34.  
    35.     /**
    36.      * 返回List
    37.      *
    38.      * @param req
    39.      * @param MyStudent
    40.      * @return
    41.      */
    42.     @ResponseBody
    43.     @RequestMapping("/list")
    44.     public List list(HttpServletRequest req, MyStudent MyStudent) {
    45.         PageBean pageBean = new PageBean();
    46.         pageBean.setRequest(req);
    47.         List list = this.myStudentBiz.selectPager(MyStudent, pageBean);
    48.         return list;
    49.     }
    50.  
    51.     /**
    52.      * 返回T
    53.      *
    54.      * @param req
    55.      * @param MyStudent
    56.      * @return
    57.      */
    58.     @ResponseBody
    59.     @RequestMapping("/load")
    60.     public MyStudent load(HttpServletRequest req, MyStudent MyStudent) {
    61.         if (MyStudent.getSname() != null) {
    62.             List list = this.myStudentBiz.selectPager(MyStudent, null);
    63.             return list.get(0);
    64.         }
    65.         return null;
    66.     }
    67.  
    68.  
    69.     /**
    70.      * 返回List
    71.      *
    72.      * @param req
    73.      * @param MyStudent
    74.      * @return
    75.      */
    76.     @ResponseBody
    77.     @RequestMapping("/mapList")
    78.     public List mapList(HttpServletRequest req, MyStudent MyStudent) {
    79.         PageBean pageBean = new PageBean();
    80.         pageBean.setRequest(req);
    81.         List list = this.myStudentBiz.mapSelectPager(MyStudent, pageBean);
    82.         return list;
    83.     }
    84.  
    85.     /**
    86.      * 返回Map
    87.      *
    88.      * @param req
    89.      * @param MyStudent
    90.      * @return
    91.      */
    92.     @ResponseBody
    93.     @RequestMapping("/mapLoad")
    94.     public Map mapLoad(HttpServletRequest req, MyStudent MyStudent) {
    95.         if (MyStudent.getSname() != null) {
    96.             List list = this.myStudentBiz.mapSelectPager(MyStudent, null);
    97.             return list.get(0);
    98.         }
    99.         return null;
    100.     }
    101.  
    102.  
    103.     @ResponseBody
    104.     @RequestMapping("/all")
    105.     public Map all(HttpServletRequest req, MyStudent MyStudent) {
    106.         PageBean pageBean = new PageBean();
    107.         pageBean.setRequest(req);
    108.         List list = this.myStudentBiz.selectPager(MyStudent, pageBean);
    109.         Map map = new HashMap();
    110.         map.put("list", list);
    111.         map.put("pageBean", pageBean);
    112.         return map;
    113.     }
    114.  
    115.     @ResponseBody//注释 跳的就是页面，就不是显示的字符串
    116.     @RequestMapping("/jsonStr")
    117.     public String jsonStr(HttpServletRequest req, MyStudent MyStudent) {
    118.         return "sc-edit";
    119.     }
    120.  
    121.  
    122. }

    4.2、biz层

    1.     @Override
    2.     public List mapSelectPager(MyStudent myStudent, PageBean pageBean) {
    3.         return myStudentMapper.mapSelectPager(myStudent);
    4.     }

    4.3、sql.xml

    1.     <select id="mapSelectPager" resultType="java.util.Map" parameterType="com.tgq.model.MyStudent">
    2.         select *
    3.         from t_mysql_student
    4.         <where>
    5.             <if test="sname != null"/>
    6.             and sname like concat('%',#{sname},'%')
    7.         where>
    8.     select>

    4.4、页面

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: tgq
    4.   Date: 13/9/2023
    5.   Time: 下午2:43
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <html>
    10. <head>
    11.     <title>Titletitle>
    12. head>
    13. <body>
    14. <h3>JSONh3>
    15. <a href="${pageContext.request.contextPath}/sc/json/list?sname=">返回List<T>a>
    16. <hr>
    17. <a href="${pageContext.request.contextPath}/sc/json/mapList?sname=">返回List<Map>a>
    18. <hr>
    19. <a href="${pageContext.request.contextPath}/sc/json/load?sname=三">返回Ta>
    20. <hr>
    21. <a href="${pageContext.request.contextPath}/sc/json/mapLoad?sname=三">返回Mapa>
    22. <hr>
    23. <a href="${pageContext.request.contextPath}/sc/json/all?sname=">返回混合a>
    24. <hr>
    25. <a href="${pageContext.request.contextPath}/sc/json/jsonStr">返回JSON字符串a>
    26. <hr>
    27. body>
    28. html>

    4.5、测试

    http://localhost:8080/sc/json/jsp

    4.6、注意@ResponseBody

    如果在类名上面加上@ResponseBody注解，里面所有的方法返回的都会是字符串，

    @RestController:可以代替@Controller和@ResponseBody

    二、异常处理

    1、为什么要使用全局异常处理

    全局异常处理是一种在应用程序中集中处理异常的方式。它的主要目的是提供一种统一的机制来处理应用程序中抛出的异常，而不是在每个可能抛出异常的地方都进行单独的处理。

    使用全局异常处理的好处：

    1. 代码简洁：通过全局异常处理，我们可以将异常处理逻辑从业务代码中分离出来，使业务代码更加简洁和清晰。业务代码只需要关注核心业务逻辑，而将异常处理交给专门的异常处理器。

    2. 统一异常处理：全局异常处理提供了一种统一的机制来处理应用程序中的异常。无论是在控制器中处理请求时抛出的异常，还是在服务层、持久层或其他地方抛出的异常，都可以在全局异常处理器中进行处理。这样可以确保应用程序中的所有异常都能得到统一的处理，提高开发效率和代码质量。

    3. 异常信息友好化：通过全局异常处理，我们可以自定义异常信息的格式和内容，使其更加友好和易于理解。我们可以根据具体的业务需求，将异常信息转化为适合用户展示的形式，或者记录到日志中以便问题排查。

    4. 统一异常返回：在全局异常处理中，我们可以统一定义异常返回的格式和内容。例如，可以定义一个通用的错误响应对象，用于封装异常信息，并统一返回给客户端。这样可以避免在每个控制器方法中都手动处理异常并返回错误信息。

    5. 安全性：通过全局异常处理，我们可以捕获并处理未被处理的异常，防止异常信息暴露给客户端，从而提高应用程序的安全性。

    全局异常处理提供了一种集中处理应用程序中异常的方式，简化了代码逻辑，提高了代码的可读性和可维护性。它使我们能够更好地处理异常、优化用户体验，并提高应用程序的稳定性和安全性。

    2、异常处理思路

    第一种思路：

    系统的dao、service、controller出现异常都通过throws Exception向上抛出，最后由springmvc前端控制器交由异常处理器进行异常处理。springmvc提供全局异常处理器（一个系统只有一个异常处理器）进行统一异常处理。

    也可以遵循第二种思路：

    1. 捕获异常：在代码中使用try-catch语句块捕获可能抛出的异常。在try块中放置可能抛出异常的代码，而在catch块中处理捕获的异常。可以根据不同的异常类型，使用多个catch块分别处理不同类型的异常。

    2. 日志记录：在异常处理过程中，应该记录异常信息，以便后续的问题排查和调试。可以使用日志框架（如Log4j、Slf4j等）记录异常信息，包括异常类型、异常消息、堆栈跟踪等。通过日志记录，可以及时发现和解决潜在的问题。

    3. 友好提示：根据具体的业务需求，可以将异常信息转化为友好的提示信息，以便用户理解和处理。可以通过自定义异常类，设置异常的错误码和错误信息，然后根据错误码返回相应的提示信息给用户。

    4. 异常返回：在Web应用中，可以使用全局异常处理器将异常信息封装为统一的错误响应，并返回给客户端。这样可以提供统一的异常处理逻辑，避免在每个控制器方法中都手动处理异常。

    5. 异常链传递：在捕获异常后，可以通过抛出新的异常或将原始异常作为参数传递给上层调用者，以便上层调用者能够处理该异常。通过异常链的方式，可以将异常信息传递到合适的地方进行处理。

    6. 异常处理策略：对于可恢复的异常，可以采取相应的处理策略，尝试恢复正常的程序执行。例如，可以重新连接数据库、重新发送请求等。对于不可恢复的异常，可以通知相关人员或进行紧急处理。

    7. 异常监控和统计：可以使用监控工具或日志分析工具对异常进行监控和统计，以便及时发现和解决异常问题。通过收集和分析异常信息，可以帮助优化系统性能和提高用户体验。

    处理异常的思路是捕获异常、记录异常、友好提示、异常返回，根据具体情况采取合适的处理策略，并进行异常监控和统计。通过良好的异常处理，可以提高应用程序的稳定性和可维护性，优化用户体验，并及时发现和解决潜在的问题。

    3、SpringMVC异常分类

    • 使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver； 
    • 实现Spring的异常处理接口HandlerExceptionResolver自定义自己的异常处理器；
    • 使用@ControllerAdvice + @ExceptionHandler

    1. 控制器异常：控制器异常是在处理客户端请求时发生的异常。这些异常通常由控制器方法抛出，可以包括验证错误、请求参数错误等。可以使用@ExceptionHandler注解来处理控制器异常，将异常处理逻辑集中在一个地方，统一返回错误信息给客户端。

    2. 服务层异常：服务层异常通常由业务逻辑引起，例如数据查询失败、业务规则校验失败等。服务层异常应该在服务层中进行捕获和处理，可以使用try-catch语句块或自定义的异常处理器来处理服务层异常。

    3. 数据访问异常：数据访问异常主要由数据库操作引起，例如数据库连接失败、SQL语句执行错误等。在Spring MVC中，可以使用Spring的数据访问框架（如Spring Data JPA、MyBatis等）来处理数据访问异常，框架会自动将底层的异常转化为Spring的数据访问异常（如DataAccessException）。

    4. 全局异常：全局异常是指在应用程序中没有被捕获和处理的异常，或者是无法预知的异常。可以使用全局异常处理器（@ControllerAdvice注解）来处理全局异常，将异常处理逻辑集中在一个地方，以便统一处理和返回错误信息。

    5. 运行时异常：运行时异常（RuntimeException）是一种不需要显式捕获和处理的异常。这些异常通常是由程序错误或逻辑错误引起的，例如空指针异常、数组越界异常等。在Spring MVC中，运行时异常会被Servlet容器捕获并返回默认的错误页面（如500 Internal Server Error页面）。

    对于不同类型的异常，可以根据具体需求选择不同的处理方式。有些异常可以通过捕获和处理来恢复正常的程序执行，而有些异常可能需要通知相关人员或进行紧急处理。通过合理分类和处理异常，可以提高应用程序的稳定性和可维护性。

    4、异常案例

    4.1、异常处理方法一

    SpringMVC中自带了一个异常处理器叫SimpleMappingExceptionResolver，该处理器实现了HandlerExceptionResolver 接口，全局异常处理器都需要实现该接口。

    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>

    页面跳转由SpringMVC来接管了，所以此处的定义默认的异常处理页面都应该配置成逻辑视图名。

    1.     @RequestMapping("/error")
    2.     public String error(MyStudent MyStudent) {
    3.         MyStudent = null;
    4.         MyStudent.getSname();
    5.         return "error";
    6.     }

    写一个异常的界面

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: tgq
    4.   Date: 13/9/2023
    5.   Time: 下午6:10
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <html>
    10. <head>
    11.     <title>errortitle>
    12. head>
    13. <body>
    14. 错误信息....
    15. ${ex}
    16. body>
    17. html>

    测试一下效果

    http://localhost:8080/sc/json/error

    4.2、异常处理方法二

    创建两个包里面写两个类

    GlobalException 

    1. package com.tgq.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.tgq.component;
    2.  
    3. import com.tgq.exception.GlobalException;
    4. import org.springframework.stereotype.Component;
    5. import org.springframework.web.servlet.HandlerExceptionResolver;
    6. import org.springframework.web.servlet.ModelAndView;
    7.  
    8. import javax.servlet.http.HttpServletRequest;
    9. import javax.servlet.http.HttpServletResponse;
    10.  
    11. @Component
    12. public class GlobalExceptionHandler implements HandlerExceptionResolver {
    13.     @Override
    14.     public ModelAndView resolveException(HttpServletRequest httpServletRequest,
    15.                                          HttpServletResponse httpServletResponse,
    16.                                          Object o, Exception e) {
    17.         ModelAndView mv = new ModelAndView();
    18.         mv.setViewName("error");
    19.         if (e instanceof GlobalException) {
    20.             GlobalException globalException = (GlobalException) e;
    21.             mv.addObject("ex", globalException.getMessage());
    22.             mv.addObject("msg", "全局异常....");
    23.         } else if (e instanceof RuntimeException) {
    24.             RuntimeException runtimeException = (RuntimeException) e;
    25.             mv.addObject("ex", runtimeException.getMessage());
    26.             mv.addObject("msg", "运行时异常....");
    27.         } else if (e instanceof RuntimeException) {
    28.             RuntimeException runtimeException = (RuntimeException) e;
    29.             mv.addObject("ex", e.getMessage());
    30.             mv.addObject("msg", "其他异常....");
    31.         }
    32.         return mv;
    33.     }
    34. }

    后面也可自定义异常

    写一个方法测试

    1.     @RequestMapping("/error02")
    2.     public String error2(HttpServletRequest req) {
    3.       if (true)
    4.           throw new GlobalException("老异常了");
    5.         return "error";
    6.     }

    页面代码

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

    http://localhost:8080/sc/json/error02

    4.3、异常处理方法三

    可以把component包里面的GlobalExceptionHandler 换成GlobalExceptionResolver 
    GlobalExceptionResolver     ：里面返回的json格式和跳转页面

    1. package com.tgq.component;
    2.  
    3. import com.tgq.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 GlobalExceptionResolver {
    13.  
    14. //    跳转错误页面
    15. //    @ExceptionHandler
    16. //    public ModelAndView handler(Exception e){
    17. //        ModelAndView mv = new ModelAndView();
    18. //        mv.setViewName("error");
    19. //        if (e instanceof GlobalException){
    20. //            GlobalException globalException = (GlobalException) e;
    21. //            mv.addObject("ex",globalException.getMessage());
    22. //            mv.addObject("msg","全局异常....");
    23. //        }else if (e instanceof RuntimeException){
    24. //            RuntimeException runtimeException = (RuntimeException) e;
    25. //            mv.addObject("ex",runtimeException.getMessage());
    26. //            mv.addObject("msg","运行时异常....");
    27. //        }
    28. //        return mv;
    29. //    }
    30.  
    31.     // 返回错误json数据
    32.     @ResponseBody
    33.     @ExceptionHandler
    34.     public Map handler(Exception e) {
    35.         Map map = new HashMap();
    36.         if (e instanceof GlobalException) {
    37.             GlobalException globalException = (GlobalException) e;
    38.             map.put("ex", globalException.getMessage());
    39.             map.put("msg", "全局异常....");
    40.         } else if (e instanceof RuntimeException) {
    41.             RuntimeException runtimeException = (RuntimeException) e;
    42.             map.put("ex", runtimeException.getMessage());
    43.             map.put("msg", "运行时异常....");
    44.         } else {
    45.             map.put("ex", e.getMessage());
    46.             map.put("msg", "其它异常....");
    47.         }
    48.         return map;
    49.     }
    50. }

    测试结果

    json格式

    页面

  • 相关阅读:
    基于Java+SpringCloud+Mybaties-plus+Vue+elememt 智能停车场管理系统 的设计与实现
    Python:实现first come first served先到先得算法(附完整源码)
    Kubernetes学习笔记-kubernetes API服务器的安全防护（1）通过基于角色的权限控制加强集群安全20220814
    什么是DeFi流动性资金池
    推荐一个基于Python开源的文档系统
    Java基础—循环栅栏CyclicBarrier
    postgrest API CURD数据库
    Java 异步编程 (5 种异步实现方式详解)
    关于写一个read_file的很多个为什么&如何用
    什么是HTML？
  • 原文地址：https://blog.csdn.net/weixin_74383330/article/details/132852735