SpringBoot：如何优雅地进行响应数据封装、异常处理？

背景

越来越多的项目开端根据前后端分离的方式进行开发，这对后端接口的报文格局便有了必定的要求。一般，咱们会选用JSON格局作为前后端交流数据格局，然后削减交流本钱等。

这篇文章，就带咱们了解一下根据SpringBoot结构来封装回来报文以及一致反常处理。

报文基本格局

一般报文格局一般会包括状况码、状况描述（或过错提示信息）、事务数据等信息。在此基础上，不同的架构师、项目搭建者或许会有所调整。但从全体上来说，基本上都是大同小异。

在SpringBoot项目中，一般接口回来的报文中至少包括三个特点：

• code：恳求接口的回来码，成功或者反常等回来编码，例如界说恳求成功。
• message：恳求接口的描述，也便是对回来编码的描述。
• data：恳求接口成功，回来的事务数据。

示例报文如下：

{
  "code":200,
  "message":"SUCCESS",
  "data":{
   "info":"测验成功"
  }
}

在上述报文格局中，不同的规划者是会有一些分歧的，特别是code值的界说。假如彻底根据RESTful API规划的话，code字段或许就不需求存在了，而是经过HTTP协议中提供的GET、POST、PUT、DELETE操作等来完结资源的拜访。

但在实践中，不论是出于目前国内大多数程序员的习惯，还是受限于HTTP协议提供的操作办法的局限性，很少彻底遵从RESTful API办法进行规划。一般都是经过自界说Code值的方式来赋予它事务意义或事务过错编码。

尽管能够不用彻底恪守RESTful API风格来界说Code，在Code值的自界说中，也存在两种方式：遵从HTTP状况码和自主界说。

像上面的示例，用200表明回来成功，这便是遵从HTTP响应状况码的方式来回来，比方还有其他的400、401、404、500等。当然，还有彻底自主界说的，比方用0表明成功，1表明失败，然后再跟进通用编码、事务分类编码等进行界说。

在此，笔者暂不谈论每种方式的好坏，只列举了惯例的几种方式，咱们了解对应的情况，做到心中有数，有所选择即可。

响应参数封装实践

创建一个SpringBoot项目，并引进Lombok依靠（精简代码），对应的核心依靠如下：

   <dependencies>
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
     </dependency>
   </dependencies>

创建枚举类，用于界说回来的过错码：

@Getter
@AllArgsConstructor
public enum ResponseCodeEnums {
​
  SUCCESS(200, "success"),
  FAIL(500, "failed"),
​
  HTTP_STATUS_200(200, "ok"),
  HTTP_STATUS_400(400, "request error"),
  HTTP_STATUS_401(401, "no authentication"),
  HTTP_STATUS_403(403, "no authorities"),
  HTTP_STATUS_500(500, "server error");
​
  private final int code;
​
  private final String message;
}

这儿只界说了一些通用的、根据的HTTP响应状况码，事务相关的编码可根据事务需求进行界说。

界说一致回来成果实体类：

@Data
public class ResponseInfo<T> {
​
  /**
   * 状况码
   */
  protected int code;
​
  /**
   * 响应信息
   */
  protected String message;
​
  /**
   * 回来数据
   */
  private T data;
​
  public static <T> ResponseInfo<T> success() {
    return new ResponseInfo<>();
  }
​
  public static <T> ResponseInfo<T> success(T data) {
    return new ResponseInfo<>(data);
  }
​
  public static <T> ResponseInfo<T> fail(String message) {
    return new ResponseInfo<>(ResponseCodeEnums.FAIL.getCode(), message);
  }
​
  public ResponseInfo() {
    this.code = ResponseCodeEnums.SUCCESS.getCode();
    this.message = ResponseCodeEnums.SUCCESS.getMessage();
  }
​
  public ResponseInfo(ResponseCodeEnums statusEnums) {
    this.code = statusEnums.getCode();
    this.message = statusEnums.getMessage();
  }
​
  /**
   * 若没有数据回来，能够人为指定状况码和提示信息
   */
  public ResponseInfo(int code, String msg) {
    this.code = code;
    this.message = msg;
  }
​
  /**
   * 有数据回来时，状况码为200，默认提示信息为“操作成功！”
   */
  public ResponseInfo(T data) {
    this.data = data;
    this.code = ResponseCodeEnums.SUCCESS.getCode();
    this.message = ResponseCodeEnums.SUCCESS.getMessage();
  }
​
  /**
   * 有数据回来，状况码为 200，人为指定提示信息
   */
  public ResponseInfo(T data, String msg) {
    this.data = data;
    this.code = ResponseCodeEnums.SUCCESS.getCode();
    this.message = msg;
  }
}

在ResponseInfo中运用了泛型和公共办法、结构办法的封装，便利在事务中使用。示例中只提供了部分办法的封装，根据自身事务场景和需求可进一步封装。

一致报文封装在接口中的使用：

@Slf4j
@RestController
public class TestController {
​
  @RequestMapping("/calc")
  public ResponseInfo<String> calc(Integer id) {
    try {
      // 模仿反常事务代码
      int num = 1 / id;
      log.info("计算成果num={}", num);
      return ResponseInfo.success();
    } catch (Exception e) {
      return ResponseInfo.fail("体系反常，请联络管理员！");
    }
  }
}

在浏览器中拜访：http://localhost:8080/calc，回来成果如下：

{
   "code": 500,
   "message": "体系反常，请联络管理员！",
   "data": null
}

这是因为没传递id参数，导致事务抛反常，走反常报文回来。

在浏览器中拜访：http://localhost:8080/calc?id=1，回来成果如下：

{
   "code": 200,
   "message": "success",
   "data": null
}

正常回来成果。

一致反常处理

在上述实例中，咱们经过try…catch的方式捕获反常，并进行处理。在SpringBoot中，咱们能够经过RestControllerAdvice注解来界说大局反常处理，这样就无需每处都try…catch了。

@Slf4j
@RestControllerAdvice
public class ExceptionHandlerAdvice {
​
  /**
   * 参数格局反常处理
   */
  @ExceptionHandler({IllegalArgumentException.class})
  @ResponseStatus(HttpStatus.BAD_REQUEST)
  public ResponseInfo<String> badRequestException(IllegalArgumentException ex) {
    log.error("参数格局不合法：{}", ex.getMessage());
    return new ResponseInfo<>(HttpStatus.BAD_REQUEST.value() + "", "参数格局不符！");
  }
​
  /**
   * 权限缺乏反常处理
   */
  @ExceptionHandler({AccessDeniedException.class})
  @ResponseStatus(HttpStatus.FORBIDDEN)
  public ResponseInfo<String> badRequestException(AccessDeniedException ex) {
    return new ResponseInfo<>(HttpStatus.FORBIDDEN.value() + "", ex.getMessage());
  }
​
  /**
   * 参数缺失反常处理
   */
  @ExceptionHandler({MissingServletRequestParameterException.class})
  @ResponseStatus(HttpStatus.BAD_REQUEST)
  public ResponseInfo<String> badRequestException(Exception ex) {
    return new ResponseInfo<>(HttpStatus.BAD_REQUEST.value() + "", "缺少必填参数！");
  }
​
  /**
   * 空指针反常
   */
  @ExceptionHandler(NullPointerException.class)
  @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
  public ResponseInfo<String> handleTypeMismatchException(NullPointerException ex) {
    log.error("空指针反常，{}", ex.getMessage());
    return ResponseInfo.fail("空指针反常");
  }
​
  @ExceptionHandler(Exception.class)
  @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
  public ResponseInfo<String> handleUnexpectedServer(Exception ex) {
    log.error("体系反常：", ex);
    return ResponseInfo.fail("体系产生反常，请联络管理员");
  }
​
  /**
   * 体系反常处理
   */
  @ExceptionHandler(Throwable.class)
  @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
  public ResponseInfo<String> exception(Throwable throwable) {
    log.error("体系反常", throwable);
    return new ResponseInfo<>(HttpStatus.INTERNAL_SERVER_ERROR.value() + "体系反常，请联络管理员！");
  }
}

在上述办法中，对一些常见的反常进行了一致处理。一般情况下，根据事务需求还会界说事务反常，并对事务反常进行处理，咱们能够根据自己项目中反常的使用情况进行拓宽。

关于@RestControllerAdvice的几点阐明：

• @RestControllerAdvice注解包括了@Component注解，会把被注解的类作为组件交给Spring来管理。
• @RestControllerAdvice注解包括了@ResponseBody注解，反常处理完之后给调用方输出一个JSON格局的封装数据。
• @RestControllerAdvice注解有一个basePackages特点，该特点用来阻拦哪个包中的反常信息，一般不指定，阻拦项目工程中的所有反常。
• 在办法上经过@ExceptionHandler注解来指定详细的反常，在办法中处理该反常信息，最终将成果经过一致的JSON结构体回来给调用者。

从头界说一个接口：

  @RequestMapping("/calc1")
  public ResponseInfo<String> calc1(Integer id) {
    // 模仿反常事务代码
    int num = 1 / id;
    log.info("计算成果num={}", num);
    return ResponseInfo.success();
  }

在恳求的时分，不传递id值，即在浏览器中拜访：

{
   "code": 500,
   "message": "空指针反常",
   "data": null
}

能够看到一致反常处理对空指针反常进行了阻拦处理，并回来了ExceptionHandlerAdvice中界说的一致报文格局。

小结

在使用SpringBoot或其他项目中，一致的报文格局和一致的反常处理都是有必要的。本篇文章介绍了根据SpringBoot的实现，假如你的项目中选用了其他的技能栈，则可考虑对应的处理办法。同时，日常中很多相似的功能都能够一致进行处理，防止很多无效的硬编码。

博主简介：《SpringBoot技能内情》技能图书作者，酷爱钻研技能，写技能干货文章。

大众号：「程序新视界」，博主的大众号，欢迎关注~

技能交流：请联络博主微信号：zhuan2quan