1、GlobalExceptionHandler 全局异常处理拦截器，捕获400,405和自定义等controller之后的异常
import com.dm.exception.BSException;
import com.dm.model.Result;
import com.dm.model.StatusCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.HttpRequestMethodNotSupportedException;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.ServletRequestBindingException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import javax.validation.ConstraintViolationException;
import java.net.BindException;
/**
* 解决Controller之后的异常
*/
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
/**
* 400 - Bad Request
*/
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler({HttpMessageNotReadableException.class, MissingServletRequestParameterException.class, BindException.class,
ServletRequestBindingException.class, MethodArgumentNotValidException.class, ConstraintViolationException.class})
public Result handleHttpMessageNotReadableException(Exception e) {
log.error("------err------Bad Request: " + e.getMessage(), e);
return new Result(StatusCode.BAD_REQUEST, "参数解析失败");
}
/**
* 405 - Method Not Allowed
*/
@ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public Result handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
log.error("------err------Method Not Allowed: " + e.getMessage(), e);
return new Result(StatusCode.METHOD_NOT_ALLOWED, "不支持当前请求方法");
}
/**
* 自定义异常在此捕获
*/
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ExceptionHandler(Throwable.class)
public Result handleException(Throwable e) {
log.error("------err------Service Run Exception: " + e.getMessage(), e);
if (e instanceof BSException) {
return new Result(((BSException) e).getCode(), ((BSException) e).getMsg());
}
return new Result(StatusCode.SYSTEM_ERR, "服务器运行异常");
}
}
注意：自定义异常在方法handleException中进行捕获
2、FrontErrHandler，404异常是全局异常捕获不到的，所以放在FrontErrHandler进行处理
import com.dm.model.Result;
import com.dm.model.StatusCode;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.servlet.error.ErrorController;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* 解决Controller之前的异常
*/
@RestController
@Slf4j
@Api(tags = "FrontErrHandler", description = "FrontErrHandler相关接口")
public class FrontErrHandler implements ErrorController {
@Override
public String getErrorPath() {
return "/error";
}
@GetMapping(value = "/error")
@ResponseStatus(HttpStatus.NOT_FOUND)
public Object error(HttpServletRequest request, HttpServletResponse response) {
log.error("------err------Response Error,HttpCode: " + response.getStatus());
// 错误处理逻辑
int status = response.getStatus();
if (status == 404) {
return new Result(StatusCode.REQUEST_NOT_FOUND, "访问地址不存在");
} else if (status == 500) {
return new Result(StatusCode.SYSTEM_ERR, "服务器运行异常");
} else if (status >= 100 && status < 200) {
return new Result(StatusCode.HTTP_ERROR_100, null);
} else if (status >= 300 && status < 400) {
return new Result(StatusCode.HTTP_ERROR_300, null);
} else if (status >= 400 && status < 500) {
return new Result(StatusCode.HTTP_ERROR_400, null);
} else {
return new Result(StatusCode.SYSTEM_ERR, "服务器运行异常");
}
}
}
3、捕获到异常以后将返回结果统一封装到Result中，封装Result时有两种方式，
1）采用普通返回码，如返回正常，400，500等可以直接从普通返回码类中拿CODE进行返回的直接封装
return new Result(StatusCode.OK, "添加成功")
return new Result(StatusCode.SYSTEM_ERR, "服务器运行异常");
2）从自定义异常中拿到code和msg封装最终返回，code和msg来自异常枚举
return new Result(((BSException) e).getCode(), ((BSException) e).getMsg());
3）Result定义
import io.swagger.annotations.ApiModel;
/**
* 返回结果实体类
*/
@ApiModel(description = "Result",value = "Result")
public class Result<T> {
private Integer code;//返回码
private String message;//返回消息
private T data;//返回数据
public Result(Integer code, String message, Object data) {
this.code = code;
this.message = message;
this.data = (T)data;
}
public Result(Integer code, String message) {
this.code = code;
this.message = message;
}
public Result() {
this.code = StatusCode.OK;
this.message = "执行成功";
}
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
4）普通返回码定义
/**
* 普通返回码
*/
public class StatusCode {
public static final int OK = 200;//成功
public static final int SYSTEM_ERR = 500;//服务器运行异常
public static final int REQUEST_NOT_FOUND = 404;//访问地址不存在
public static final int HTTP_ERROR_100 = 100;//1XX错误
public static final int HTTP_ERROR_300 = 300;//3XX错误
public static final int HTTP_ERROR_400 = 400;//4XX错误
public static final int HTTP_ERROR_500 = 500;//5XX错误
public static final int BAD_REQUEST = 407;//参数解析失败
public static final int METHOD_NOT_ALLOWED = 405;//不支持当前请求方法
}
4、exception目录下定义异常类和异常枚举
1）自定义异常类
public class BSException extends RuntimeException {
private int code;
private String msg;
public BSException(ErrorEnum errEnum, Exception e) {
super(e);
this.code = errEnum.getCode();
this.msg = errEnum.getMsg();
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
2）自定义异常枚举
/**
* 自定义异Enum
*/
public enum ErrorEnum {
//CUSTOM_EXCEPTION(6007, "自定义异常7"),
CUSTOM_EXCEPTION(6008, "自定义异常8");
private final Integer code;
private final String msg;
public Integer getCode() {
return code;
}
public String getMsg() {
return msg;
}
ErrorEnum(int code, String msg) {
this.code = code;
this.msg = msg;
}
}
5、自定义异常的使用
/**
* 根据ID查询BsCategory
*/
@Override
public BsCategory findById(Integer id) {
try {
int i = 1 / 0;
} catch (Exception e) {
log.info("...err：：：{}", e.getMessage());
throw new BSException(ErrorEnum.CUSTOM_EXCEPTION,e);
}
return bsCategoryMapper.selectById(id);
}
6、总结
通过两个全局异常处理器将controller之前和之后的异常全部捕获到，然后通过Result通过封装结果进行返回，利用自定义异常和枚举来定义自己想要处理的异常。