5、SpringBoot全局异常处理

# 一.SpringBoot全局异常处理

### 1.1 全局异常处理的好处

1. 后端开发人员职责单一，只需要将异常捕获并转换为自定义异常一直对外抛出。不需要去想页面跳转404，以及异常响应的数据结构的设计。
2. 面向前端人员友好，后端返回给前端的数据应该有统一的数据结构，统一的规范。而在此过程中不需要后端开发人员做更多的工作，交给全局异常处理器去处理“异常”到“响应数据结构”的转换。
3. 面向用户友好，用户能够清楚的知道异常产生的原因。这就要求自定义异常，全局统一处理，接口请求响应统一的异常数据结构，页面模板请求统一跳转到404页面。
4. 面向运维友好，将异常信息合理规范的持久化，以日志的形式存储起来，以便查询。

### 1.2开发规范

1. Controller、Service、Repository层拦截异常转换为自定义异常，不允许将异常私自截留。必须对外抛出。
2. 统一数据响应代码，默认使用http状态码（200、400、500等少数几个），特殊场景可自定义。
3. 自定义异常里面有message属性，用对用户友好的语言描述异常的发生情况，并赋值给message。
4. 不允许对父类Exception统一catch，要分小类catch，这样能够清楚地将异常转换为自定义异常传递给前端。

# 二.自定义异常和相关数据结构

### 2.1 自定义异常

1.枚举异常的类型

```java
public enum CustomExceptionType {

OK(HttpStatus.OK.value(),null),
    BAD_REQUEST(HttpStatus.BAD_REQUEST.value(),"您输入的数据错误或您没有权限访问资源！"),
    INTERNAL_SERVER_ERROR (HttpStatus.INTERNAL_SERVER_ERROR.value(),"系统出现异常，请您稍后再试或联系管理员！"),
    OTHER_ERROR(999,"系统出现未知异常，请联系管理员！");

CustomExceptionType(int code, String desc) {
        this.code = code;
        this.desc = desc;
    }

private String desc;//异常类型中文描述

private int code; //code

public String getDesc() {
        return desc;
    }

public int getCode() {
        return code;
    }
}
```

2.自定义异常

```java
public class CustomException extends RuntimeException {
    //异常错误编码
    private int code ;
    //异常信息
    private String message;

private CustomException(){}

public CustomException(CustomExceptionType exceptionTypeEnum) {
        this.code = exceptionTypeEnum.getCode();
        this.message = exceptionTypeEnum.getDesc();
    }

public CustomException(CustomExceptionType exceptionTypeEnum, String message) {
        this.code = exceptionTypeEnum.getCode();
        this.message = message;
    }

public int getCode() {
        return code;
    }

@Override
    public String getMessage() {
        return message;
    }
}
```

- 自定义异常有两个核心内容，一个是code。使用CustomExceptionType 来限定范围。
- 另外一个是message，这个message信息是要最后返回给前端的，所以需要用友好的提示来表达异常发生的原因或内容

### 2.2 请求接口统一响应数据结构

对于1.2节中的配置文件，可以通过@ConfigurationProperties注解获取配置信息并对的Java类属性进行赋值。

```java
@Data
public class ApiResponse {

private boolean isok;  //请求是否处理成功
    private int code; //请求响应状态码（200、400、500）
    private String message;  //请求结果描述信息
    private Object data; //请求结果数据（通常用于查询操作）

private ApiResponse(){}

public static ApiResponse error(CustomException e) {
        ApiResponse resultBean = new ApiResponse();
        resultBean.setIsok(false);
        resultBean.setCode(e.getCode());
        resultBean.setMessage(e.getMessage());
        return resultBean;
    }

public static ApiResponse error(CustomExceptionType customExceptionType,
                                     String errorMessage) {
        ApiResponse resultBean = new ApiResponse();
        resultBean.setIsok(false);
        resultBean.setCode(customExceptionType.getCode());
        resultBean.setMessage(errorMessage);
        return resultBean;
    }

public static ApiResponse success(){
        ApiResponse apiResponse = new ApiResponse();
        apiResponse.setIsok(true);
        apiResponse.setCode(200);
        apiResponse.setMessage("请求响应成功!");
        return apiResponse;
    }

public static ApiResponse success(Object obj){
        ApiResponse apiResponse = new ApiResponse();
        apiResponse.setIsok(true);
        apiResponse.setCode(200);
        apiResponse.setMessage("请求响应成功!");
        apiResponse.setData(obj);
        return apiResponse;
    }

public static ApiResponse success(Object obj,String message){
        ApiResponse apiResponse = new ApiResponse();
        apiResponse.setIsok(true);
        apiResponse.setCode(200);
        apiResponse.setMessage(message);
        apiResponse.setData(obj);
        return apiResponse;
    }
}
```

为了解决不同的开发人员使用不同的结构来响应给前端，导致规范不统一，开发混乱的问题。我们使用如下代码定义统一数据响应结构

- isok表示该请求是否处理成功（即是否发生异常）。true表示请求处理成功，false表示处理失败。
- code对响应结果进一步细化，200表示请求成功，400表示用户操作导致的异常，500表示系统异常，999表示其他异常。与CustomExceptionType枚举一致。
- message：友好的提示信息，或者请求结果提示信息。如果请求成功这个信息通常没什么用，如果请求失败，该信息需要展示给用户。
- data：通常用于查询数据请求，成功之后将查询数据响应给前端。

# 三.通用全局异常处理逻辑

程序员的异常处理逻辑要十分的单一：无论在Controller层、Service层还是什么其他位置，程序员只负责一件事：**那就是捕获异常，并将异常转换为自定义异常。使用用户友好的信息去填充CustomException的message,并将CustomException抛出去。**###3.1 对绑定的属性值进行校验

### 3.1 全局异常处理器

通过团队内的编码规范的要求，我们已经知道了：不允许程序员截留处理Exception，必须把异常转换为自定义异常CustomException全都抛出去。那么程序员把异常跑出去之后由谁来处理？那就是ControllerAdvice。
 ControllerAdvice注解的作用就是监听所有的Controller，一旦Controller抛出CustomException，就会在@ExceptionHandler(CustomException.class)注解的方法里面对该异常进行处理。处理方法很简单就是**使用`ApiResponse.error(e)`包装为通用的接口数据结构返回给前端。**

```java
@ControllerAdvice
public class WebExceptionHandler {

//处理程序员主动转换的自定义异常
    @ExceptionHandler(CustomException.class)
    @ResponseBody
    public ApiResponse customerException(CustomException e) {
        if(e.getCode() == CustomExceptionType.SYSTEM_ERROR.getCode()){
                 //400异常不需要持久化，将异常信息以友好的方式告知用户就可以
                //TODO 将500异常信息持久化处理，方便运维人员处理
        }
        return ApiResponse.error(e);
    }

//处理程序员在程序中未能捕获（遗漏的）异常
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public ApiResponse exception(Exception e) {
        return ApiResponse.error(new CustomException(CustomExceptionType.OTHER_ERROR));
    }

//处理异常校验失败
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseBody
    public ApiResponse handleBindException(MethodArgumentNotValidException ex) {
        FieldError fieldError = ex.getBindingResult().getFieldError();
        return ApiResponse.error(new CustomException(CustomExceptionType.BAD_REQUEST,
                fieldError.getDefaultMessage()));
    }

//处理异常校验失败
    @ExceptionHandler(BindException.class)
    @ResponseBody
    public ApiResponse handleBindException(BindException ex) {
        FieldError fieldError = ex.getBindingResult().getFieldError();
        return ApiResponse.error(new CustomException(CustomExceptionType.BAD_REQUEST,
                fieldError.getDefaultMessage()));
    }

@ExceptionHandler(IllegalArgumentException.class)
    @ResponseBody
    public ApiResponse handleIllegalArgumentException(IllegalArgumentException e) {
        return ApiResponse.error(
                new CustomException(CustomExceptionType.BAD_REQUEST, e.getMessage())
        );
    }

@ExceptionHandler(ModelViewException.class)
    public ModelAndView viewExceptionHandler(HttpServletRequest req, ModelViewException e) {
        ModelAndView modelAndView = new ModelAndView();

//将异常信息设置如modelAndView
        modelAndView.addObject("exception", e);
        modelAndView.addObject("url", req.getRequestURL());
        modelAndView.setViewName("error");

//返回ModelAndView
        return modelAndView;
    }
}
```

### 3.2 让业务状态与HTTP协议状态一致

```java
@ControllerAdvice
public class GlobalResponseAdvice implements ResponseBodyAdvice {

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

@Override
    public Object beforeBodyWrite(Object body,
                                  MethodParameter methodParameter,
                                  MediaType mediaType,
                                  Class aClass,
                                  ServerHttpRequest serverHttpRequest,
                                  ServerHttpResponse serverHttpResponse) {
        //如果响应结果是JSON数据类型
        if(mediaType.equalsTypeAndSubtype(MediaType.APPLICATION_JSON)) {
            if(body instanceof ApiResponse) {
                ApiResponse apiResponse = (ApiResponse)body;
                if(apiResponse.getCode() != 999) { //999 不是标准的HTTP状态码，特殊处理
                    serverHttpResponse.setStatusCode(HttpStatus.valueOf(apiResponse.getCode()));
                }
              return body;
            } else {
                serverHttpResponse.setStatusCode(HttpStatus.OK);
                return ApiResponse.success(body);
            }
        }
        return body;
    }
}
```