How SpringBoot implements unified encapsulation and returns the front-end result set-javaTutorial-php.cn

How do we encapsulate this result? We should pay attention to the information contained in the data returned to the front end.

Generally speaking, first of all, this time there must be a code to represent the status of the interface. For example, 0 means success, 1 means failure, 2 means wrong parameters had to be passed, 4 means system exception, and so on. This is just a simple example. Many people may have questions. The HTTP protocol itself already has corresponding return code definitions. For example: 200 means success, 500 means server error, 404 means page not found.

For example, 200 indicates that the request was successful, but it cannot describe the business results in the request. For example, the username already exists, in fact, the business is not successful, but the HTTP result is definitely 200, so we need a code to describe our business status.

In addition to the code, there are also some prompt messages, such as successful operation, system exception, user name already exists, etc., so we added a message field.

In addition, there is our core data. For example, I'm getting data based on ID. The specific content of this data must be returned to the front end, so there must be data. What type is used for this data? This type must be diverse, so we need to use a unified parent class so that the object can receive all types. Of course, we can use some general methods to facilitate operation.

Then there is our core data. For example, I'm getting data based on ID. The specific content of this data must be returned to the front end, so there must be data. What type is used for this data? This type must be diverse, so we need to use a unified parent class so that the object can receive all types. Of course, we can use general methods to facilitate operation.

Main code display:

public class Result<T> implements Serializable {
   private static final long serialVersionUID = -3960261604608758516L;
  private int code;
  private String msg;
  private T data;
  public static <T> Result<T> success() {
        return new Result<>();
    }
 
    /**
     * 成功,默认状态码,返回消息,自定义返回数据
     * @param data 自定义返回数据
     * @param <T>  返回类泛型,不能为String
     * @return 通用返回Result
     */
    public static <T> Result<T> success(T data) {
        return new Result<>(data);
    }
 
     /**
     * 成功,默认状态码,自定义返回消息,返回数据
     * @param msg  自定义返回消息
     * @param data 自定义返回数据
     * @param <T>  返回类泛型
     * @return 通用返回Result
     */
    public static <T> Result<T> success(String msg, T data) {
        return new Result<>(msg, data);
    }
           /**
     * 成功,默认状态码,自定义返回消息,无返回数据
     *
     * @param msg 自定义返回消息
     * @param <T> 返回类泛型
     * @return 通用返回Result
     */
    public static <T> Result<T> success(String msg) {
        return new Result<>(msg);
    }
     /**
     * 失败,默认状态码,返回消息,无返回数据
     * @param <T> 返回类泛型
     * @return 通用返回Result
     */
    public static <T> Result<T> error() {
        return new Result<>(ResultCode.ERROR);
    }
     /**
     * 失败,默认状态码,自定义返回消息,无返回数据
     * @param <T> 返回类泛型
     * @return 通用返回Result
     */
    public static <T> Result<T> error(String msg) {
        return new Result<>(ResultCode.ERROR.getCode(), msg);
    }
     /**
     * 失败,自定义状态码,返回消息,无返回数据
     * @param code 自定义状态码
     * @param msg  自定义返回消息
     * @param <T>  返回类泛型
     * @return 通用返回Result
     */
    public static <T> Result<T> error(int code, String msg) {
        return new Result<>(code, msg);
    }
     /**
     * 失败,使用CodeMsg状态码,返回消息,无返回数据
      * @param resultCode CodeMsg,参数如下:
     *                   <p> code 状态码
     *                   <p> msg  返回消息
     * @param <T>        返回类泛型
     * @return 通用返回Result
     */
    public static <T> Result<T> error(ResultCode resultCode) {
        return new Result<>(resultCode);
    }
     /**
     * 成功构造器,无返回数据
     */
    private Result() {
        this(ResultCode.SUCCESS);
    }
     /**
     * 成功构造器,自定义返回数据
     * @param data 返回数据
     */
    private Result(T data) {
        this(ResultCode.SUCCESS, data);
    }
     /**
     * 成功构造器,自定义返回消息,无返回数据
     * @param msg 返回消息
     */
    private Result(String msg) {
        this(ResultCode.SUCCESS.getCode(), msg);
    }
           /**
     * 构造器,自定义状态码,返回消息
     * @param code 状态码
     * @param msg  返回消息
     */
    private Result(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
     /**
     * 成功构造器,自定义返回信息,返回数据
     * @param msg  返回信息
     * @param data 返回数据
     */
    private Result(String msg, T data) {
        this(ResultCode.SUCCESS.getCode(), msg, data);
    }
 
    /**
     * 构造器,自定义状态码,返回消息,返回数据
     * @param code 状态码
     * @param msg  返回消息
     * @param data 返回数据
     */
    private Result(int code, String msg, T data) {
        this(code, msg);
        this.data = data;
    }
            /**
     * 构造器,使用CodeMsg状态码与返回信息,自定义返回数据
     * @param resultCode CodeMsg,参数如下:
     *                   <p> code 状态码
     *                   <p> msg  返回消息
     * @param data       返回数据
     */
    private Result(ResultCode resultCode, T data) {
        this(resultCode);
        this.data = data;
    }
  
    /**
     * 构造器,使用CodeMsg状态码与返回信息
     * @param resultCode CodeMsg,参数如下:
     *                   <p> code 状态码
     *                   <p> msg  返回消息
     */
    private Result(ResultCode resultCode) {
        this(resultCode.getCode(), resultCode.getMsg());
    }
 
}

Copy after login

You also need to define several common errors

@Builder
public class ResultCode implements Serializable {
     private static final long serialVersionUID = -6269841958947880397L;
     /** 状态码*/
    private int code;
     /**状态信息*/
    private String msg;
     /** 默认成功*/
    public final static ResultCode SUCCESS = dispose(ResultCodeEnum.SUCCESS);
    /**默认失败*/
   public final static ResultCode ERROR = dispose(ResultCodeEnum.ERROR);
    /**通用业务异常*/
    public final static ResultCode BIZ_ERROR = dispose(ResultCodeEnum.BIZ_ERROR);
    /**文件超出最大限制*/
    public final static ResultCode FILE_OUT_MAX = dispose(ResultCodeEnum.FILE_OUT_MAX);
    /**文件格式不正确*/
    public final static ResultCode FILE_FORMAT_ERROR = dispose(ResultCodeEnum.FILE_FORMAT_ERROR);
    /** 参数错误*/
    public final static ResultCode PARAM_ERROR = dispose(ResultCodeEnum.PARAM_ERROR);
    /**Json解析异常*/
    public final static ResultCode JSON_FORMAT_ERROR = dispose(ResultCodeEnum.JSON_FORMAT_ERROR);
    /** Sql解析异常*/
    public final static ResultCode SQL_ERROR = dispose(ResultCodeEnum.SQL_ERROR);
    /**网络超时*/
    public final static ResultCode NETWORK_TIMEOUT = dispose(ResultCodeEnum.NETWORK_TIMEOUT);
    /** 未知的接口*/
    public final static ResultCode UNKNOWN_INTERFACE = dispose(ResultCodeEnum.UNKNOWN_INTERFACE);
    /**请求方式不支持*/
    public final static ResultCode REQ_MODE_NOT_SUPPORTED = dispose(ResultCodeEnum.REQ_MODE_NOT_SUPPORTED);
    /**系统异常*/
    public final static ResultCode SYS_ERROR = dispose(ResultCodeEnum.SYS_ERROR);
    private static ResultCode dispose(ResultCodeEnum codeEnum) {
        return ResultCode.builder().code(codeEnum.getCode()).msg(codeEnum.getMsg()).build();
    }
     public ResultCode(int code, String msg) {
        this.code = code;
        this.msg = msg;
    }
}

Copy after login

The above is the detailed content of How SpringBoot implements unified encapsulation and returns the front-end result set. For more information, please follow other related articles on the PHP Chinese website!