How to handle SpringBoot unified interface returns and global exceptions

1. SpringBoot does not use a unified return format

By default, SpringBoot will have the following three return situations.

1.1 Use string to return

@GetMapping("/getUserName")
public String getUserName(){
    return "HuaGe";
}

Call the interface to return the result:

HuaGe

1.2 Use entity class to return

@GetMapping("/getUserName")
public User getUserName(){
    return new User("HuaGe",18,"男");
}

Call the interface to return the result:

{
  "name": "HuaGe",
  "age": "18",
  "性别": "男", 
}

1.3 Return under abnormal circumstances

@GetMapping("/getUserName")
public static String getUserName(){
    HashMap hashMap = Maps.newHashMap();
    return hashMap.get(0).toString();
}

Simulates a null pointer exception. Without any exception handling, you can look at the default return result of SpringBoot:

{
    "timestamp": "2021-08-09T06:56:41.524+00:00",
    "status": 500,
    "error": "Internal Server Error",
    "path": "/sysUser/getUserName"
}

For the above situations, if the entire project does not define a unified return format and five backend developers define five return formats, not only will the code be bloated, the front-end and back-end docking efficiency will be low, but there will also be some inconsistencies. When certain situations occur, such as the front-end directly displaying exception details, etc., this gives the user a very poor experience.

2. Basic gameplay

The most common thing in projects is to encapsulate a tool class. The field information that needs to be returned is defined in the class, and the interface information that needs to be returned to the front end is encapsulated through this class. , this can solve the problem of inconsistent return formats.

2.1 Parameter Description

• code： Status code, the background can maintain a unified set of status codes;

• message: Description information, prompt information of success/failure of interface call;

• data: Return data.

2.2 Process Description

• New Result class

public class Result {
    
    private int code;
    
    private String message;
    
    private T data;

    public Result() {}
    public Result(int code, String message) {
        this.code = code;
        this.message = message;
    }
    
    /**
     * 成功
     */
    public static  Result success(T data) {
        Result result = new Result();
        result.setCode(ResultMsgEnum.SUCCESS.getCode());
        result.setMessage(ResultMsgEnum.SUCCESS.getMessage());
        result.setData(data);
        return result;
    }

    /**
     * 失败
     */
    public static  Result error(int code, String message) {
        return new Result(code, message);
    }
}

Define the return status code

public enum ResultMsgEnum {
    SUCCESS(0, "成功"),
    FAIL(-1, "失败"),
    AUTH_ERROR(502, "授权失败!"),
    SERVER_BUSY(503, "服务器正忙，请稍后再试!"),
    DATABASE_OPERATION_FAILED(504, "数据库操作失败");
    private int code;
    private String message;

    ResultMsgEnum(int code, String message) {
        this.code = code;
        this.message = message;
    }
    public int getCode() {
        return this.code;
    }
    
    public String getMessage() {
        return this.message;
    }
}

• Usage

The above two steps define Data return format and status code , next we need to see how to use it in the interface.

@GetMapping("/getUserName")
public Result getUserName(){
    return Result.success("huage");
}

The calling result is as follows. You can see that it is the parameter type we defined in Result.

{
    "code": 0,
    "message": "成功",
    "data": "huage"
}

Although writing this way can meet daily needs, and I believe many friends use it this way, but if we have a large number of interfaces, then use Result.success## in each interface # to package the returned information will add a lot of repeated code, which is not elegant enough and even embarrassing to show off. There must be a way to improve the code again and achieve the optimal solution.

3. Advanced Usage

After learning the basic usage, let’s look at the ultimate version, which mainly uses the following two knowledge points. The usage is simple, whether it is used to teach girls, or Giving guidance to young ladies is a necessary skill.

3.1 Class introduction

• ResponseBodyAdvice: This interface is provided by SpringMVC 4.1, which allows the execution of @ResponseBody Customized return data is used to encapsulate unified data format returns;

• @RestControllerAdvice: This annotation is an enhancement to the Controller and can globally capture thrown exceptions .

3.2 Usage instructions

• Create a new

  ResponseAdvice class;

• implementation

  ResponseBodyAdvice interface, implements supports, beforeBodyWrite methods;

• This class is used to uniformly encapsulate the return of the interface in the controller result.

@RestControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice