@Data
@AllArgsConstructor
@NoArgsConstructor
public class ApiResult<T> implements Serializable {
    private static final long serialVersionUID = 2747440445733983051L;

    /**
     * 状态
     */
    private Integer status;

    /**
     * 信息
     */
    private String msg;

    /**
     * 响应数据
     */
    private T payload;

    /**
     * 程序异常信息
     */
    private String exception;
}

@Getter
@AllArgsConstructor
public enum ApiStatusEnum {

    /**
     * 成功
     */
    SUCCESS(200, "处理成功"),

    /**
     * 未授权（登录信息有误，需要重新登录）
     */
    UNAUTHORIZED(401, "未授权（登录信息有误 需要重新登录）"),

    /**
     * 无操作权限
     */
    NO_PERMISSIONS(403, "无操作权限"),

    /**
     * 失败
     */
    FAIL(500, "处理失败");

    /**
     * 状态码
     */
    private final Integer status;

    /**
     * 提示消息
     */
    private final String msg;
}

@Data
@ConfigurationProperties(prefix = "swagger")
public class SwaggerProperties {

    /**
     * 是否启用 Swagger，默认关闭
     */
    private Boolean enabled = Boolean.FALSE;
}

@Configuration
@RequiredArgsConstructor
public class SwaggerConfig {

    private final SwaggerProperties swaggerProperties;

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.OAS_30)
                .enable(swaggerProperties.getEnabled())
                .apiInfo(apiInfo())
                .select()
                //指定需要被 Swagger 扫描到的包名
                .apis(RequestHandlerSelectors.basePackage("com.xxxxx.xxxx.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    /**
     * 创建该API的基本信息（这些基本信息会展现在文档页面中）
     *
     * @return ApiInfo
     */
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("xxx项目")
                .description("")
                .termsOfServiceUrl("")
                .version("1.0")
                .build();
    }
}

@PostMapping("/add")
@ApiOperation(value = "保存用户信息")
public ApiResult<?> add(@RequestBody @Validated UserAddReq req) {
    userService.add(req);
    return ApiResult.success();
}

import javax.validation.constraints.NotNull;

@Data
@ApiModel(description = "保存用户信息请求参数")
public class UserAddReq implements Serializable {
    private static final long serialVersionUID = -2749806305785349883L;

    /**
     * 年龄
     */
    @NotNull(message = "年龄不允许为空")
    @ApiModelProperty(value = "年龄", required = true)
    private Integer age;

}

package com.sincland.insurance.partner.config;

import com.sincland.insurance.partner.exception.BusinessException;
import com.sincland.insurance.partner.pojo.other.ApiResult;
import org.apache.commons.lang3.ObjectUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.servlet.http.HttpServletRequest;

/**
 * 异常处理
 */
@RestControllerAdvice
public class ExceptionHandlerConfig {

    private final Logger log = LoggerFactory.getLogger(this.getClass());

    /**
     * 处理其他所有异常
     *
     * @param req 请求参数
     * @param e   异常信息
     * @return ApiResult
     */
    @ExceptionHandler(value = Exception.class)
    public ApiResult<?> exceptionHandler(HttpServletRequest req, Exception e) {
        String msg;
        if (ObjectUtils.isNotEmpty(e.getCause())) {
            msg = e.getCause().getMessage();
        } else {
            msg = e.getMessage();
        }
        log.error("接口:{} 发生运行时异常:{}", req.getRequestURI(), msg);
        e.printStackTrace();
        return ApiResult.exception(msg);
    }


    /**
     * 校验参数异常
     *
     * @param req HttpServletRequest
     * @param e   异常信息
     * @return ApiResult
     */
    @ExceptionHandler(value = MethodArgumentNotValidException.class)
    public ApiResult<?> handleMethodArgumentNotValidException(HttpServletRequest req, MethodArgumentNotValidException e) {
        BindingResult bindingResult = e.getBindingResult();
        StringBuilder msg = new StringBuilder("请求参数校验不通过: ");
        for (FieldError fieldError : bindingResult.getFieldErrors()) {
            msg.append(fieldError.getField()).append(":").append(fieldError.getDefaultMessage()).append("，");
        }
        msg.replace(msg.length() - 1, msg.length(), "");
        log.error("接口:{} {}", req.getRequestURI(), msg);
        return ApiResult.exception(msg.toString());
    }

    /**
     * 处理业务异常
     *
     * @param req 请求参数
     * @param e   异常信息
     * @return ApiResult
     */
    @ExceptionHandler(value = BusinessException.class)
    public ApiResult<?> businessExceptionHandler(HttpServletRequest req, BusinessException e) {
        log.error("接口:{} 发生业务性异常:{}", req.getRequestURI(), e.getMessage());
        return e.getApiResultIsException() ? ApiResult.exception(e.getStatus(), e.getMessage())
                : ApiResult.fail(e.getStatus(), e.getMessage());
    }

    /**
     * 处理空指针异常
     *
     * @param req 请求参数
     * @param e   异常信息
     * @return ApiResult
     */
    @ExceptionHandler(value = NullPointerException.class)
    public ApiResult<?> nullPointerExceptionHandler(HttpServletRequest req, NullPointerException e) {
        log.error("接口:{} 发生空指针异常:{}", req.getRequestURI(), e.getStackTrace()[0]);
        e.printStackTrace();
        return ApiResult.exception("发生空指针异常:" + e.getStackTrace()[0]);
    }

    /**
     * 请求消息无法解析异常
     *
     * @param req 请求参数
     * @param e   异常信息
     * @return ApiResult
     */
    @ExceptionHandler(value = HttpMessageNotReadableException.class)
    public ApiResult<?> httpMessageNotReadableExceptionHandler(HttpServletRequest req, HttpMessageNotReadableException e) {
        log.error("接口:{} 请求消息无法解析异常:{}", req.getRequestURI(), e.getMessage());
        e.printStackTrace();
        return ApiResult.fail("请检查请求体格式");
    }

}