全局异常统一处理

全局异常处理的原理：在独立的一个类中，定义一套对各种异常的处理机制，然后用@ControllerAdvice注解该类，统一对不同位置的不同异常进行处理。

实现步骤：

1.封装自定义异常类

public class GlobalException extends RuntimeException {
    private int code;

    public GlobalException() {
    }

    /**
     * MyException
     * @param code 错误代码
     */
    public GlobalException(int code) {
        super("code=" + code);
        this.code = code;
    }

    /**
     * MyException
     * @param message 错误消息
     */
    public GlobalException(String message) {
        super(message);
    }

    /**
     * MyException
     * @param cause 捕获的异常
     */
    public GlobalException(Throwable cause) {
        super(cause);
    }

    /**
     * MyException
     * @param message 错误消息
     * @param cause 捕获的异常
     */
    public GlobalException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * MyException
     * @param code 错误代码
     * @param message 错误消息
     */
    public GlobalException(int code, String message) {
        super(message);
        this.code = code;
    }

    public int getCode() {
        return code;
    }

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

2.自定义全局异常处理类：

/**
 * 全局异常处理的原理：在独立的一个类中，定义一套对各种异常的处理机制，然后用@ControllerAdvice注解该类，统一对不同位置的不同异常进行处理。
 */

@ControllerAdvice
//@ControllerAdvice 作用为将被@ExceptionHandler修饰的异常处理方法应用与所有的Controller类
public class GlobalExceptionHandler {
    private static Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ResponseBody
    //当抛出自定义异常时由该方法捕获处理 添加自定义异常的异常码及信息返回Result对象
    @ExceptionHandler(GlobalException.class)
    public Result MyExceptionHandler(Exception ex) {
        return  Result.error(((GlobalException)ex).getCode(), ex.getMessage());
    }

    @ResponseBody
    //抛出空指针异常时 日志纪录 返回空指针状态码及信息
    @ExceptionHandler(NullPointerException.class)
    public Result nullPointerExceptionHandler(NullPointerException ex) {
        log.error(ex.getMessage(),ex);
        return Result.error(ApiCodeConstant.RESULT_NULLPOINT_EXCEPTION, ex.toString());
    }

    @ResponseBody
    //通用的未知异常处理
    @ExceptionHandler(Exception.class)
    public Result otherExcptionHandler(Exception ex) {
        log.error(ex.getMessage(), ex);
        return  Result.error(ApiCodeConstant.RESULT_OTHER_EXCEPTION, ex.toString());
    }


    /**
     * 控制器参数校验异常
     * @param ex
     * @return
     */
    @ExceptionHandler({MethodArgumentNotValidException.class})
    @ResponseBody
    public Result handleMethodArgumentNotValidException(MethodArgumentNotValidException ex) {
        Map<String, Object> result = new HashMap<>();
        BindingResult bindingResult = ex.getBindingResult();
        StringBuilder sb = new StringBuilder("参数校验异常  ");
        for (FieldError fieldError : bindingResult.getFieldErrors()) {
            sb.append(fieldError.getField()).append("：").append(fieldError.getDefaultMessage()).append(";");
        }
        String msg = sb.toString();
        return Result.error(ApiCodeConstant.PARAMETER_VALIDATION_ERROR,msg);
    }

    /**
     * Bean约束异常
     * @param ex
     * @return
     */
    @ExceptionHandler({ConstraintViolationException.class})
    @ResponseBody
    public Result handleConstraintViolationException(ConstraintViolationException ex) {

        return Result.error(ApiCodeConstant.PARAMETER_VALIDATION_ERROR,ex.getMessage());
    }

}