全局异常处理

（1）异常定义

GlobalException：
@Data
public class GlobalException extends Exception {

    private int code;

    public GlobalException(String message, int code) {
        super(message);
        this.code = code;
    }

    public GlobalException(String message){
        super(message);
    }

    public GlobalException(Throwable cause) {
        super(cause);
    }

    public GlobalException(int code, Exception e) {
        super(e);
        this.code = code;
    }
}

（2）其他异常继承，业务代码使用throw new BusinessException

业务异常：
public class BusinessException extends GlobalException {

    public BusinessException(String message) {
        super(message, ResponseCode.BUSINESS_ERROR.getCode());
    }
}


NotFound异常
public class NotFoundException extends GlobalException {

    public NotFoundException(String message) {
        super(message, ResponseCode.NOT_FOUND.getCode());
    }
}


参数异常
public class ParamException extends GlobalException {


    public ParamException(String message) {
        super(message, ResponseCode.PARAM_ERROR.getCode());
    }
}

(3)异常捕获：

@RestControllerAdvice
public class GlobalExceptionHandler {

    private Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    /**
     * 全局异常捕获并返回接口统一格式
     * @param e
     * @return
     */
    @ExceptionHandler(value = GlobalException.class)
    @ResponseBody
    public ResponseData globalExceptionHandler(GlobalException e){
        ResponseData responseData = new ResponseData();
        responseData.setMessage(e.getMessage());
        responseData.setCode(e.getCode());
        responseData.setStatus(false);
        responseData.setData(null);
        return responseData;
    }


    /**
     * 对于一些Exception，也需要捕获拦截，需要处理
     * @param e
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public ResponseData systemExceptionHandler(Exception e){
        ResponseData responseData = new ResponseData();
        responseData.setStatus(false);
        responseData.setData(null);
        responseData.setMessage(e.getMessage());
        if(e instanceof NotFoundException){
            responseData.setCode(HttpStatus.NOT_FOUND.value());
        }else if(e instanceof MethodArgumentNotValidException){
            responseData.setCode(HttpStatus.INTERNAL_SERVER_ERROR.value());
            responseData.setData("参数不可用异常");
        }else if(e instanceof IllegalArgumentException) {
            responseData.setCode(HttpStatus.BAD_REQUEST.value());
            responseData.setData("请求参数异常");
        }else if(e instanceof ClassCastException){
            responseData.setCode(HttpStatus.INTERNAL_SERVER_ERROR.value());
            responseData.setData("类型转化异常");
        }else {
            responseData.setCode(HttpStatus.INTERNAL_SERVER_ERROR.value());
            responseData.setData("系统异常");
        }
        return responseData;
    }

}

如果需要对其他继承Exception的异常进行捕获，并做详细处理，可以再写一个@ExceptionHandler(value = ***Exception.class)进行处理

（4）异常配置，使其生效

#全局异常处理
#出现错误时, 直接抛出异常
spring.mvc.throw-exception-if-no-handler-found=true
#不要为我们工程中的资源文件建立映射
spring.resources.add-mappings=false

（5）Response设置：

public enum ResponseCode {

    NOT_FOUND(404),
    PARAM_ERROR(400),
    SERVER_ERROR(500),
    LIMIT_ERROR(401),
    BUSINESS_ERROR(999);

    private int code;

    ResponseCode(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }
}

@Data
public class ResponseData {

    /**
     * 状态
     */
    private Boolean status = true;

    /**
     * 状态码
     */
    private int code = 200;

    /**
     * 提示信息
     */
    private String message;

    /**
     * 返回结果数据
     */
    private Object data;


    /**
     * 通用成功返回
     * @param data
     * @return
     */
    public static ResponseData success(Object data){
        ResponseData responseData = new ResponseData(data);
        responseData.setMessage("成功");
        return responseData;
    }

    /**
     * 成功返回指定提示信息
     * @param message
     * @param data
     * @return
     */
    public static ResponseData success(String message, Object data){
        return new ResponseData(message,data);
    }

    /**
     * 通用失败返回，500
     * @param message
     * @return
     */
    public static ResponseData failed(String message){
        return new ResponseData(false,500,message);
    }

    /**
     * 指定异常码失败返回
     * @param code
     * @param message
     * @return
     */
    public static ResponseData failed(int code, String message){
        return new ResponseData(false,code,message);
    }


    public static ResponseData failed(Boolean status, int code, String message, Object data){
        return new ResponseData(status, code, message, data);
    }

    public ResponseData() {
        super();
    }

    public ResponseData(Object data) {
        this.data = data;
    }


    public ResponseData(Boolean status, int code, String message) {
        this.status = status;
        this.code = code;
        this.message = message;
    }

    public ResponseData(String message, Object data) {
        this.message = message;
        this.data = data;
    }

    public ResponseData(Boolean status, int code, String message, Object data) {
        this.status = status;
        this.code = code;
        this.message = message;
        this.data = data;
    }
}

（6）使用效果：