Comment gérer le format de retour unifié SpringBoot

Contexte

Je pense que la plupart des développeurs back-end doivent s'interfacer avec le front-end dans le développement quotidien. Bien sûr, si vous faites le front-end et le back-end par vous-même, vous pouvez jouer comme vous le souhaitez, mais nous. encore faut-il respecter certaines normes. Dans un projet avec front-end et back-end séparés, le format renvoyé par le back-end doit être convivial et fixe, et ne peut pas être modifié fréquemment, sinon cela entraînera beaucoup de charge de travail pour les développeurs front-end.

SpringBoot Controller Format de retour commun

String

@PostMapping("/test")
public String test(){
    return "Hello World";
}

Résultat de l'appel postman :

Objet personnalisé

Retour normal

    @PostMapping("/getUser")
    public ActionResult getUser(){
        User user = new User();
        user.setId(UUID.randomUUID().toString());
        user.setName("MrDong");
        user.setAge(20);
        return ActionResult.defaultOk(user);
    }

Résultat de l'appel postman :

Erreur de retour

   @PostMapping("/error")
    public ActionResult error(){
        return ActionResult.defaultFail(1000,"服务器异常，请联系管理员");
    }

Résultat de l'appel du facteur :

Définir l'objet de retour

Je définis deux objets ActionResult pour encapsuler la valeur de retour, qui peut être modifiée en fonction de la situation réelle de votre entreprise :

package com.wxd.entity;
import com.wxd.enums.ResultCodeEnum;
import lombok.Data;

/**
 * @ClassName ActionResult
 * @Description 统一返回值封装
 * @Author Mr Dong
 * @Date 2022/7/26 14:51
 */
@Data
public class ActionResult {
    private Integer code;
    private String msg;
    private Integer count;
    private Object data;
    public static ActionResult defaultOk(Integer code, String msg, Integer count, Object data) {
        return new ActionResult(code, msg, count, data);
    }

    public static ActionResult defaultOk(Integer count, Object data) {
        return new ActionResult(ResultCodeEnum.RC200, count, data);
    }

    public static ActionResult defaultOk(Object data) {
        return new ActionResult(ResultCodeEnum.RC200, null, data);
    }

    public static ActionResult defaultOk() {
        return new ActionResult(ResultCodeEnum.RC200);
    }
    public static ActionResult defaultFail() {
        return new ActionResult(ResultCodeEnum.RC999);
    }
    public static ActionResult defaultFail(Integer code, String msg) {
        return new ActionResult(code, msg);
    }
    public static ActionResult defaultFail(ResultCodeEnum resultCodeEnum) {
        return new ActionResult(resultCodeEnum);
    }
    public ActionResult(Integer code, String msg, Integer count, Object data) {
        this.code = code;
        this.msg = msg;
        this.count = count;
        this.data = data;
    }
    public ActionResult(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }
    public ActionResult(ResultCodeEnum resultCodeEnum) {
        this.code = resultCodeEnum.getCode();
        this.msg = resultCodeEnum.getMessage();
    }
    public ActionResult(ResultCodeEnum resultCodeEnum, Integer count, Object data) {
        this.code = resultCodeEnum.getCode();
        this.msg = resultCodeEnum.getMessage();
        this.count = count;
        this.data = data;
    }
}

Définir l'énumération des statuts

package com.wxd.enums;

/**
 * @author wxd
 * @version V1.0
 * @description ResultCodeEnum
 * @date 2022/8/10 13:35
 **/
public enum ResultCodeEnum {
    /**
     * 操作成功
     */
    RC200(200, "操作成功"),
    /**
     * 未授权
     */
    RC401(401, "用户未授权"),
    /**
     * 请求被禁止
     */
    RC403(403, "请求被禁止"),
    /**
     * 服务异常
     */
    RC500(500, "服务器异常，请联系管理员"),
    /**
     * 操作失败
     */
    RC999(999, "操作失败"),

    RC1001(1001, "用户名密码错误"),
    RC1002(1002, "未授权的资源"),
    RC1003(1003, "未授权的资源"),
    RC1004(1004, "缺少请求参数异常"),
    RC1005(1005, "缺少请求体参数异常"),
    RC1006(1006, "参数绑定异常"),
    RC1007(1007, "方法参数无效异常");

    private Integer code;
    private String message;

    ResultCodeEnum(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

Unify Gestion des valeurs de retour et des exceptions

Principe d'implémentation : Il est nécessaire d'implémenter l'interface ResponseBodyAdvice fournie par SpringBoot pour terminer l'encapsulation des valeurs de retour unifiées et la gestion des exceptions. Après avoir implémenté cette interface, il vous suffit de renvoyer l'objet directement au retour du contrôleur. Certains qui n'ont pas besoin de valeur de retour peuvent renvoyer directement void.

package com.wxd.advice;

import com.wxd.entity.ActionResult;
import com.wxd.enums.ResultCodeEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.validation.BindException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

/**
 * @version: V1.0
 * @author: wxd
 * @description: 全局异常处理以及返回值的统一封装
 * @Date 2022/7/26 16:24
 */
@RestControllerAdvice(value = "com.wxd.controller")
@Slf4j
public class ResponseAdvice implements ResponseBodyAdvice {

    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        return true;
    }

    /**
     * 统一包装
     *
     * @param o
     * @param methodParameter
     * @param mediaType
     * @param aClass
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @return
     */
    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        /**
         * String、ActionResult不需要再包一层（不想包一层ActionResult对象的可以在这里把这个对象过滤掉）
         */
        if (o instanceof String || o instanceof ActionResult) {
            return o;
        }
        return ActionResult.defaultOk(o);
    }

    /**
     * 系统内部异常捕获
     *
     * @param e
     * @return
     */
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler(value = Exception.class)
    public Object exceptionHandler(Exception e) {
        log.error("系统内部异常，异常信息", e);
        return ActionResult.defaultFail(ResultCodeEnum.RC500);
    }
    /**
     * 忽略参数异常处理器;触发例子:带有@RequestParam注解的参数未给参数
     *
     * @param e 忽略参数异常
     * @return ResponseResult
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(MissingServletRequestParameterException.class)
    public Object parameterMissingExceptionHandler(MissingServletRequestParameterException e) {
        log.error("缺少Servlet请求参数异常", e);
        return ActionResult.defaultFail(ResultCodeEnum.RC1004);
    }
    /**
     * 缺少请求体异常处理器;触发例子:不给请求体参数
     *
     * @param e 缺少请求体异常
     * @return ResponseResult
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(HttpMessageNotReadableException.class)
    public Object parameterBodyMissingExceptionHandler(HttpMessageNotReadableException e) {
        log.error("参数请求体异常", e);
        return ActionResult.defaultFail(ResultCodeEnum.RC1005);
    }


    /**
     * 统一处理请求参数绑定错误(实体对象传参);
     *
     * @param e BindException
     * @return ResponseResult
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(BindException.class)
    public Object validExceptionHandler(BindException e) {
        log.error("方法参数绑定错误(实体对象传参)", e);
        return ActionResult.defaultFail(ResultCodeEnum.RC1006);
    }
    /**
     * 统一处理请求参数绑定错误(实体对象请求体传参);
     *
     * @param e 参数验证异常
     * @return ResponseResult
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler({MethodArgumentNotValidException.class})
    public Object parameterExceptionHandler(MethodArgumentNotValidException e) {
        log.error("方法参数无效异常(实体对象请求体传参)", e);
        return ActionResult.defaultFail(ResultCodeEnum.RC1007);
    }
}

void n'a pas de valeur de retour

a une valeur de retour

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!