• Springboot项目中的异常处理与返回结果的统一

    背景

    在创建项目的初期，我们需要规范后端返回的数据结构，以便更好地与前端开发人员合作。比如后端返回的数据为：

    1. {
    2.   "msg": "请跳转登陆页面",
    3. }
    4. 复制代码

    此时前端无法确定后端服务的处理结果是成功的还是失败的。在前端展示页面，成功与失败的展示是要作区分的，甚至不同的成功或失败结果要做出不同的展现效果，这也就是我们为什么要对返回结果做出统一规范的原因。

    返回结果定义

    1. public class ResultWrap<T, M> {
    2.   //  方便前端判断当前请求处理结果是否正常
    3.   private int code;
    4.   //  业务处理结果
    5.   private T data;
    6.   //  产生错误的情况下，提示用户信息
    7.   private String message;
    8.   //  产生错误情况下的异常堆栈，提示开发人员
    9.   private String error;
    10.   //  发生错误的时候，返回的附加信息
    11.   private M metaInfo;
    12. }
    13. 复制代码

    1.为了把模糊的消息定性，我们给所有的返回结果都带上一个code字段，前端可以根据这个字段来判断我们的处理结果到底是成功的还是失败的；比如code=200的时候，我们的处理结果一定是成功的，其他的code值全都是失败的，并且我们会有多种code值，以便前端页面可以根据不同的code值做出不同的交互动作。

    2.一般在处理成功的情况下，后端会返回一些业务数据，比如返回订单列表等，那么这些数据我们就放在字段data里面，只有业务逻辑处理成功的情况下，data字段里面才可能有数据。

    3.如若我们的处理失败了，那么我们应该会有对应的消息提醒用户为什么处理失败了。比如文件上传失败了，用户名或密码错误等等，都是需要告知用户的。

    4.除了需要告知用户失败原因，我们也需要保留一个字段给开发人员，当错误是服务器内部错误的时候，我们需要让开发人员能第一时间定位是啥原因引起的，我们会把错误的堆栈信息给到error字段。

    5.当发生异常的时候，我们还会需要返回一些额外的补充数据给前端，比如用户登陆失败一次和失败多次需要不同的交互效果，此时我们会在metaInfo里面返回登陆失败次数；或者在用户操作没有权限的时候，根据用户是否已登陆来确定此时是跳转登陆页面还是直接弹窗提示当前操作没有权限。

    定义好返回结果后，我们和前端的交互数据结果就统一好了。

    异常的定义

    之所以定义一个统一的异常类，是为了把所有的异常全部汇总成一个异常，最终我们只需要在异常处理的时候单独处理这一个异常即可。

    1. @Data
    2. public class AwesomeException extends Throwable {
    3.   // 错误码
    4.   private int code;
    5.   // 提示消息
    6.   private String msg;
    7. ​
    8.   public AwesomeException(int code, String msg, Exception e) {
    9.     super(e);
    10.     this.code = code;
    11.     this.msg = msg;
    12.   }
    13. ​
    14.   public AwesomeException(int code, String msg) {
    15.     this.code = code;
    16.     this.msg = msg;
    17.   }
    18. }
    19. 复制代码

    1.我们同样需要一个与返回结果一致的code字段，这样的话，我们在异常处理的时候，才能把当前异常转换成最终的ResultWrap结果。

    2.msg就是在产生异常的时候，需要给到用户的提示消息。

    这样的话，我们的后端开发人员遇到异常的情况，只需要通过创建AwesomeException异常对象抛出即可，不需要再为创建什么异常而烦恼了。

    异常的处理

    我们下面需要针对所有抛出的异常进行统一的处理：

    1. import com.example.awesomespring.exception.AwesomeException;
    2. import com.example.awesomespring.vo.ResultWrap;
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.apache.shiro.authz.AuthorizationException;
    5. import org.springframework.web.bind.annotation.ExceptionHandler;
    6. import org.springframework.web.bind.annotation.RestControllerAdvice;
    7. ​
    8. import javax.servlet.http.HttpServletRequest;
    9. import javax.servlet.http.HttpServletResponse;
    10. ​
    11. /**
    12.  * @author zouwei
    13.  * @className ExceptionHandler
    14.  * @date: 2022/8/6 下午10:44
    15.  * @description:
    16.  */
    17. @Slf4j
    18. @RestControllerAdvice
    19. public class AwesomeExceptionHandler {
    20.   /**
    21.    * 捕获没有用户权限的异常
    22.    *
    23.    * @return
    24.    */
    25.   @ExceptionHandler(AuthorizationException.class)
    26.   public ResultWrap handleException(AuthorizationException e) {
    27.     return ResultWrap.failure(401, "您暂时没有访问权限！", e);
    28.   }
    29. ​
    30.   /**
    31.    * 处理AwesomeException
    32.    *
    33.    * @param e
    34.    * @param request
    35.    * @param response
    36.    * @return
    37.    */
    38.   @ExceptionHandler(AwesomeException.class)
    39.   public ResultWrap handleAwesomeException(AwesomeException e, HttpServletRequest request, HttpServletResponse response) {
    40.     return ResultWrap.failure(e);
    41.   }
    42. ​
    43.   /**
    44.    * 专门针对运行时异常
    45.    *
    46.    * @param e
    47.    * @return
    48.    */
    49.   @ExceptionHandler(RuntimeException.class)
    50.   public ResultWrap handleRuntimeException(RuntimeException e) {
    51.     return ResultWrap.failure(e);
    52.   }
    53. }
    54. 复制代码
    1. 在项目中，我们集成了shiro权限管理框架，因为它抛出的异常没有被我们的AwesomeException包装，所以这个AuthorizationException异常需要我们单独处理。
    2. AwesomeException是我们大多数业务逻辑抛出来的异常，我们根据AwesomeException里面的code、msg和它包装的cause，封装成一个最终的响应数据ResultWrap。
    3. 另一个RuntimeException是必须要额外处理的，任何开发人员都无法保证自己的代码是完全没有bug的，任何的空指针异常都会影响用户体验，这种编码性的错误我们需要通过统一的错误处理让它变得更柔和一点。

    返回结果的处理

    我们需要针对所有的返回结果进行检查，如果不是ResultWrap类型的返回数据，我们需要包装一下，以便保证我们和前端开发人员达成的共识。

    1. import com.example.awesomespring.vo.ResultWrap;
    2. import org.springframework.core.MethodParameter;
    3. import org.springframework.http.MediaType;
    4. import org.springframework.http.converter.StringHttpMessageConverter;
    5. import org.springframework.http.server.ServerHttpRequest;
    6. import org.springframework.http.server.ServerHttpResponse;
    7. import org.springframework.web.bind.annotation.RestController;
    8. import org.springframework.web.bind.annotation.RestControllerAdvice;
    9. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    10. ​
    11. import java.util.Objects;
    12. ​
    13. /**
    14.  * @author zouwei
    15.  * @className AwesomeResponseAdvice
    16.  * @date: 2022/8/7 上午12:16
    17.  * @description:
    18.  */
    19. @RestControllerAdvice
    20. public class AwesomeResponseAdvice implements ResponseBodyAdvice {
    21.   @Override
    22.   public boolean supports(MethodParameter returnType, Class converterType) {
    23.     // 如果返回String，那么就不包装了。
    24.     if (StringHttpMessageConverter.class.isAssignableFrom(converterType)) {
    25.       return false;
    26.     }
    27.     // 有一些情况是不需要包装的，比如调用第三方API返回的数据，所以我们做了一个自定义注解来避免所以的结果都被包装成ResultWrap。
    28.     boolean ignore = false;
    29.     IgnoreResponseAdvice ignoreResponseAdvice =
    30.         returnType.getMethodAnnotation(IgnoreResponseAdvice.class);
    31.     // 如果我们在方法上添加了IgnoreResponseAdvice注解，那么就不要拦截包装了
    32.     if (Objects.nonNull(ignoreResponseAdvice)) {
    33.       ignore = ignoreResponseAdvice.value();
    34.       return !ignore;
    35.     }
    36.     // 如果我们在类上面添加了IgnoreResponseAdvice注解，也在方法上面添加了IgnoreResponseAdvice注解，那么以方法上的注解为准。
    37.     Class clazz = returnType.getDeclaringClass();
    38.     ignoreResponseAdvice = clazz.getDeclaredAnnotation(IgnoreResponseAdvice.class);
    39.     RestController restController = clazz.getDeclaredAnnotation(RestController.class);
    40.     if (Objects.nonNull(ignoreResponseAdvice)) {
    41.       ignore = ignoreResponseAdvice.value();
    42.     } else if (Objects.isNull(restController)) {
    43.       ignore = true;
    44.     }
    45.     return !ignore;
    46.   }
    47. ​
    48.   @Override
    49.   public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
    50.     // 如果返回结果为null，那么我们直接返回ResultWrap.success()
    51.     if (Objects.isNull(body)) {
    52.       return ResultWrap.success();
    53.     }
    54.     // // 如果返回结果已经是ResultWrap，直接返回
    55.     if (body instanceof ResultWrap) {
    56.       return body;
    57.     }
    58.     // 否则我们把返回结果包装成ResultWrap
    59.     return ResultWrap.success(body);
    60.   }
    61. }
    62. ​
    63. ​
    64. import java.lang.annotation.ElementType;
    65. import java.lang.annotation.Retention;
    66. import java.lang.annotation.RetentionPolicy;
    67. import java.lang.annotation.Target;
    68. ​
    69. /**
    70.  * @author zouwei
    71.  * @className IgnoreResponseAdvice
    72.  * @date: 2022/8/7 下午12:35
    73.  * @description:
    74.  */
    75. @Target({ElementType.METHOD, ElementType.TYPE})
    76. @Retention(RetentionPolicy.RUNTIME)
    77. public @interface IgnoreResponseAdvice {
    78.   // 是否忽略ResponseAdvice；决定了是否要包装返回数据
    79.   boolean value() default true;
    80. }
    81. 复制代码

    至此，我们把整个异常处理与返回结果的统一处理全部关联起来了，我们后端的开发人员无论是返回异常还是返回ResultWrap或者其他数据结果，都能很好地保证与前端开发人员的正常协作，不必为数据结构的变化过多地沟通。

    完整代码

    ResultWrap.java

    1. import com.example.awesomespring.exception.AwesomeException;
    2. import com.example.awesomespring.util.JsonUtil;
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import org.apache.commons.lang3.StringUtils;
    6. import org.springframework.http.HttpStatus;
    7. ​
    8. import javax.servlet.http.HttpServletResponse;
    9. import java.io.IOException;
    10. import java.io.PrintWriter;
    11. import java.io.StringWriter;
    12. import java.util.Objects;
    13. ​
    14. /**
    15.  * @author zouwei
    16.  * @className ResultWrap
    17.  * @date: 2022/8/2 下午2:02
    18.  * @description:
    19.  */
    20. @Data
    21. @AllArgsConstructor
    22. public class ResultWrap {
    23.   //  方便前端判断当前请求处理结果是否正常
    24.   private int code;
    25.   //  业务处理结果
    26.   private T data;
    27.   //  产生错误的情况下，提示用户信息
    28.   private String message;
    29.   //  产生错误情况下的异常堆栈，提示开发人员
    30.   private String error;
    31.   //  发生错误的时候，返回的附加信息
    32.   private M metaInfo;
    33. ​
    34.   /**
    35.    * 成功带处理结果
    36.    *
    37.    * @param data
    38.    * @param 
    39.    * @return
    40.    */
    41.   public static  ResultWrap success(T data) {
    42.     return new ResultWrap(HttpStatus.OK.value(), data, StringUtils.EMPTY, StringUtils.EMPTY, null);
    43.   }
    44. ​
    45.   /**
    46.    * 成功不带处理结果
    47.    *
    48.    * @return
    49.    */
    50.   public static ResultWrap success() {
    51.     return success(HttpStatus.OK.name());
    52.   }
    53. ​
    54.   /**
    55.    * 失败
    56.    *
    57.    * @param code
    58.    * @param message
    59.    * @param error
    60.    * @return
    61.    */
    62.   public static  ResultWrap failure(int code, String message, String error, M metaInfo) {
    63.     return new ResultWrap(code, null, message, error, metaInfo);
    64.   }
    65. ​
    66.   /**
    67.    * 失败
    68.    *
    69.    * @param code
    70.    * @param message
    71.    * @param error
    72.    * @param metaInfo
    73.    * @param 
    74.    * @return
    75.    */
    76.   public static  ResultWrap failure(int code, String message, Throwable error, M metaInfo) {
    77.     String errorMessage = StringUtils.EMPTY;
    78.     if (Objects.nonNull(error)) {
    79.       errorMessage = toStackTrace(error);
    80.     }
    81.     return failure(code, message, errorMessage, metaInfo);
    82.   }
    83. ​
    84.   /**
    85.    * 失败
    86.    *
    87.    * @param code
    88.    * @param message
    89.    * @param error
    90.    * @return
    91.    */
    92.   public static ResultWrap failure(int code, String message, Throwable error) {
    93.     return failure(code, message, error, null);
    94.   }
    95. ​
    96.   /**
    97.    * 失败
    98.    *
    99.    * @param code
    100.    * @param message
    101.    * @param metaInfo
    102.    * @param 
    103.    * @return
    104.    */
    105.   public static  ResultWrap failure(int code, String message, M metaInfo) {
    106.     return failure(code, message, StringUtils.EMPTY, metaInfo);
    107.   }
    108. ​
    109.   /**
    110.    * 失败
    111.    *
    112.    * @param e
    113.    * @return
    114.    */
    115.   public static ResultWrap failure(AwesomeException e) {
    116.     return failure(e.getCode(), e.getMsg(), e.getCause());
    117.   }
    118. ​
    119. ​
    120.   /**
    121.    * 失败
    122.    *
    123.    * @param e
    124.    * @return
    125.    */
    126.   public static ResultWrap failure(RuntimeException e) {
    127.     return failure(500, "服务异常，请稍后访问！", e.getCause());
    128.   }
    129. ​
    130.   private static final String APPLICATION_JSON_VALUE = "application/json;charset=UTF-8";
    131. ​
    132.   /**
    133.    * 把结果写入响应中
    134.    *
    135.    * @param response
    136.    */
    137.   public void writeToResponse(HttpServletResponse response) {
    138.     int code = this.getCode();
    139.     if (Objects.isNull(HttpStatus.resolve(code))) {
    140.       response.setStatus(HttpStatus.OK.value());
    141.     } else {
    142.       response.setStatus(code);
    143.     }
    144.     response.setContentType(APPLICATION_JSON_VALUE);
    145.     try (PrintWriter writer = response.getWriter()) {
    146.       writer.write(JsonUtil.obj2String(this));
    147.       writer.flush();
    148.     } catch (IOException e) {
    149.       e.printStackTrace();
    150.     }
    151.   }
    152. ​
    153.   /**
    154.    * 获取异常堆栈信息
    155.    *
    156.    * @param e
    157.    * @return
    158.    */
    159.   private static String toStackTrace(Throwable e) {
    160.     if (Objects.isNull(e)) {
    161.       return StringUtils.EMPTY;
    162.     }
    163.     StringWriter sw = new StringWriter();
    164.     PrintWriter pw = new PrintWriter(sw);
    165.     try {
    166.       e.printStackTrace(pw);
    167.       return sw.toString();
    168.     } catch (Exception e1) {
    169.       return StringUtils.EMPTY;
    170.     }
    171.   }
    172. }
    173. 复制代码

    AwesomeException.java

    1. ​
    2. import lombok.Data;
    3. ​
    4. /**
    5.  * @author zouwei
    6.  * @className AwesomeException
    7.  * @date: 2022/8/6 下午11:00
    8.  * @description:
    9.  */
    10. @Data
    11. public class AwesomeException extends Throwable {
    12. ​
    13.   private int code;
    14.   private String msg;
    15. ​
    16. ​
    17.   public AwesomeException(int code, String msg, Exception e) {
    18.     super(e);
    19.     this.code = code;
    20.     this.msg = msg;
    21.   }
    22. ​
    23.   public AwesomeException(int code, String msg) {
    24.     this.code = code;
    25.     this.msg = msg;
    26.   }
    27. }
    28. 复制代码

    AwesomeExceptionHandler.java

    1. import com.example.awesomespring.exception.AwesomeException;
    2. import com.example.awesomespring.vo.ResultWrap;
    3. import lombok.extern.slf4j.Slf4j;
    4. import org.apache.shiro.authz.AuthorizationException;
    5. import org.springframework.web.bind.annotation.ExceptionHandler;
    6. import org.springframework.web.bind.annotation.RestControllerAdvice;
    7. ​
    8. import javax.servlet.http.HttpServletRequest;
    9. import javax.servlet.http.HttpServletResponse;
    10. ​
    11. /**
    12.  * @author zouwei
    13.  * @className ExceptionHandler
    14.  * @date: 2022/8/6 下午10:44
    15.  * @description:
    16.  */
    17. @Slf4j
    18. @RestControllerAdvice
    19. public class AwesomeExceptionHandler {
    20.   /**
    21.    * 捕获没有用户权限的异常
    22.    *
    23.    * @return
    24.    */
    25.   @ExceptionHandler(AuthorizationException.class)
    26.   public ResultWrap handleException(AuthorizationException e) {
    27.     return ResultWrap.failure(401, "您暂时没有访问权限！", e);
    28.   }
    29. ​
    30.   /**
    31.    * 处理AwesomeException
    32.    *
    33.    * @param e
    34.    * @param request
    35.    * @param response
    36.    * @return
    37.    */
    38.   @ExceptionHandler(AwesomeException.class)
    39.   public ResultWrap handleAwesomeException(AwesomeException e, HttpServletRequest request, HttpServletResponse response) {
    40.     return ResultWrap.failure(e);
    41.   }
    42. ​
    43.   /**
    44.    * 专门针对运行时异常
    45.    *
    46.    * @param e
    47.    * @return
    48.    */
    49.   @ExceptionHandler(RuntimeException.class)
    50.   public ResultWrap handleRuntimeException(RuntimeException e) {
    51.     return ResultWrap.failure(e);
    52.   }
    53. }
    54. 复制代码

    IgnoreResponseAdvice.java

    1. import java.lang.annotation.ElementType;
    2. import java.lang.annotation.Retention;
    3. import java.lang.annotation.RetentionPolicy;
    4. import java.lang.annotation.Target;
    5. ​
    6. /**
    7.  * @author zouwei
    8.  * @className IgnoreResponseAdvice
    9.  * @date: 2022/8/7 下午12:35
    10.  * @description:
    11.  */
    12. @Target({ElementType.METHOD, ElementType.TYPE})
    13. @Retention(RetentionPolicy.RUNTIME)
    14. public @interface IgnoreResponseAdvice {
    15. ​
    16.   boolean value() default true;
    17. }
    18. 复制代码

    AwesomeResponseAdvice.java

    1. import com.example.awesomespring.vo.ResultWrap;
    2. import org.springframework.core.MethodParameter;
    3. import org.springframework.http.MediaType;
    4. import org.springframework.http.converter.StringHttpMessageConverter;
    5. import org.springframework.http.server.ServerHttpRequest;
    6. import org.springframework.http.server.ServerHttpResponse;
    7. import org.springframework.web.bind.annotation.RestController;
    8. import org.springframework.web.bind.annotation.RestControllerAdvice;
    9. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    10. ​
    11. import java.util.Objects;
    12. ​
    13. /**
    14.  * @author zouwei
    15.  * @className AwesomeResponseAdvice
    16.  * @date: 2022/8/7 上午12:16
    17.  * @description:
    18.  */
    19. @RestControllerAdvice
    20. public class AwesomeResponseAdvice implements ResponseBodyAdvice {
    21.   @Override
    22.   public boolean supports(MethodParameter returnType, Class converterType) {
    23.     if (StringHttpMessageConverter.class.isAssignableFrom(converterType)) {
    24.       return false;
    25.     }
    26.     boolean ignore = false;
    27.     IgnoreResponseAdvice ignoreResponseAdvice =
    28.         returnType.getMethodAnnotation(IgnoreResponseAdvice.class);
    29.     if (Objects.nonNull(ignoreResponseAdvice)) {
    30.       ignore = ignoreResponseAdvice.value();
    31.       return !ignore;
    32.     }
    33.     Class clazz = returnType.getDeclaringClass();
    34.     ignoreResponseAdvice = clazz.getDeclaredAnnotation(IgnoreResponseAdvice.class);
    35.     RestController restController = clazz.getDeclaredAnnotation(RestController.class);
    36.     if (Objects.nonNull(ignoreResponseAdvice)) {
    37.       ignore = ignoreResponseAdvice.value();
    38.     } else if (Objects.isNull(restController)) {
    39.       ignore = true;
    40.     }
    41.     return !ignore;
    42.   }
    43. ​
    44.   @Override
    45.   public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
    46.     if (Objects.isNull(body)) {
    47.       return ResultWrap.success();
    48.     }
    49.     if (body instanceof ResultWrap) {
    50.       return body;
    51.     }
    52.     return ResultWrap.success(body);
    53.   }
    54. }
    55. 复制代码

    使用示例

    1. // 这里只要返回AwesomeException，就会被ExceptionHandler处理掉，包装成ResultWrap
    2. @PostMapping("/image/upload")
    3. String upload(@RequestPart("userImage") MultipartFile userImage) throws AwesomeException {
    4.     fileService.putObject("video", userImage);
    5.     return "success";
    6. }
    7. ​
    8. // 加上IgnoreResponseAdvice注解，该返回结果就不会被包装
    9. @IgnoreResponseAdvice
    10. @GetMapping("/read")
    11. Boolean read() {
    12.     return true;
    13. }

     

  • 相关阅读:
    研发必会-异步编程利器之CompletableFuture(上)
    2023最新SSM计算机毕业设计选题大全（附源码+LW）之java新冠疫苗接种管理系统nt3mc
    Can We Edit Multimodal Large Language Models?
    【计算机网络系列】数据链路层④：扩展的以太网及其高速以太网
    JSP自定义标签之自定义分页01
    AXI协议详解(10)-非对齐传输
    Spring框架概述以及入门案例
    GBase 8c 数据库审计概述（二）
    AM@导数求导法则
    LeetCode 2344. 使数组可以被整除的最少删除次数 最大公约数
  • 原文地址：https://blog.csdn.net/m0_71777195/article/details/126266072