微服务中如何处理全局异常
微服务中，全局异常处理是一个必须解决的客观课题，如果这些异常处理不好的话，就会给用户看到一些不友好的错误信息，比如客户看到了空指针异常，SQL执行错误等异常，客户肯定是看不懂的，从而大大降低用户体验。
全局异常处理的常见解决方案
- 定义一个处理异常的类，需要处理异常的Controller直接继承这个类，从而获取到异常处理的方法。虽然这种方式可以解决问题，但是极其不灵活，因为动用了继承机制就只为获取一个默认的方法，这显然是不好的。
- 将这个基类变为接口，提供此方法的默认实现（也就是接口中的default方法，java8开始支持接口方法的默认实现），几乎所有的Controller都需要进行异常处理，所以Controller都需要去写implement XXXException，这个方法显然看起来不是很好。况且这种方式依赖java8才有的语法，这是一个很大的局限。
- 使用
@controllerAdvice + @ExpectionHandler，接下来就以这种方式来实现一些全局异常处理。@ControllerAdvice作为Spring中默认的注解，提供对所有（你的项目包扫描范围内）Controller的异常捕获功能。
定义默认返回实体
public class JsonEntity implements java.io.Serializable {
private static final long serialVersionUID = -1771426378340695807L;
T data;
private int status = 200;
private String message;
public JsonEntity() {
}
public JsonEntity(T data) {
this.data = data;
}
// 省略getter/setter
@Override
public String toString() {
return "JsonEntity{" +
"status=" + status +
", message='" + message + '\'' +
", data=" + data +
'}';
}
}
定义ExceptionResponse，当发生异常时返回的实体，放在JsonEntity的data里
public class ExceptionResponse implements Serializable {
private static final long serialVersionUID = -5599209786899732586L;
private String errorMessage;
private String classType;
// 省略getter/setter
}
定义BaseException，继承RuntimeException
@Slf4j
public abstract class BaseException extends RuntimeException implements Serializable {
private static final long serialVersionUID = 5047454682872098494L;
private int responseStatus = HttpStatus.INTERNAL_SERVER_ERROR.value();
private Object[] parameters = null;
private Logger logger = LoggerFactory.getLogger(BaseException.class);
public BaseException() {
}
public BaseException(String message) {
super(message);
}
public BaseException(String message, Throwable cause) {
super(message, cause);
}
public BaseException(Throwable cause) {
super(cause);
}
public BaseException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
public BaseException(Object[] parameters) {
this.parameters = parameters;
}
public BaseException(String message, Object[] parameters) {
super(message);
this.parameters = parameters;
}
public static int determineResponseStatus(Throwable throwable) {
if (throwable instanceof BaseException) {
return ((BaseException) throwable).responseStatus();
}
return HttpStatus.INTERNAL_SERVER_ERROR.value();
}
public static int determineResponseStatus(Throwable throwable, int defaultValue) {
if (throwable == null) {
return defaultValue;
}
return determineResponseStatus(throwable);
}
public BaseException responseStatus(int responseStatus) {
this.responseStatus = responseStatus;
return this;
}
public int responseStatus() {
return responseStatus;
}
public String getMessage(String fmt) {
if (ObjectUtil.isEmpty(parameters)) {//NOPMD
return fmt;
}
return String.format(fmt, parameters);
}
public String getMessage() {
return (super.getMessage() == null ? "" : super.getMessage()) + formatParameters();
}
public String getLocalizedMessage() {
return getLocalizedMessage(LocaleContextHolder.getLocale());
}
public String getLocalizedMessage(Locale locale) {
Assert.notNull(locale);
return getFromMessageSource(super.getMessage(), parameters, locale);
}
private String getFromMessageSource(String messageCode, Object[] params, Locale locale) {
try {
MessageSource messageSource = SpringContextHelper.afterSpringFullyStarted().getBeanSilently(MessageSource.class);
if (messageSource != null) {
return messageSource.getMessage(messageCode, params, locale);
}
} catch (Exception e) {
logger.trace("error: {}, fallback to non-localized code, code: {}", e.getMessage(), messageCode);
}
logger.trace("messageSource absent, fallback to non-localized message, code: {}", messageCode);
return getMessage();
}
private String formatParameters() {
StringBuffer sb = new StringBuffer();
if (!isEmpty(parameters)) {
sb.append(" [params: ");
for (int i = 0; i < parameters.length; i++) {
sb.append(i).append(":").append(parameters[i]);
if (i < parameters.length - 1) {
sb.append(", ");
}
}
sb.append("] ");
}
return sb.toString();
}
public Object[] getParameters() {
return parameters;
}
public void throwIf(boolean condition) {
if (condition) {
throw this;
}
}
定义BizException，继承BaseException用来处理业务异常
public class BizException extends BaseException {
private static final long serialVersionUID = 4328407468288938158L;
public BizException() {
}
public BizException(String message) {
super(message);
}
public BizException(String message, int status) {
super(message);
this.responseStatus(status);
}
public BizException(String message, Throwable cause) {
super(message, cause);
}
public BizException(String message, Throwable cause, int status) {
super(message, cause);
this.responseStatus(status);
}
public BizException(Throwable cause) {
super(cause);
}
public BizException(Throwable cause, int status) {
super(cause);
this.responseStatus(status);
}
public BizException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
public BizException(Object[] params) {
super(params);
}
public BizException(String message, Object[] params) {
super(message, params);
}
public static BaseException ofMessage(String message) {
return new BizException(message);
}
}
定义GlobalExceptionHandler，并使用@ControllerAdvice
@Controller
@ControllerAdvice
public class GlobalExceptionHandler {
private static Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
@Autowired(required = false)
private ResponseStatusExceptionResolver responseStatusExceptionResolver;
@Autowired(required = false)
private DefaultHandlerExceptionResolver defaultHandlerExceptionResolver;
@PostConstruct
public final void postInit() {
if (responseStatusExceptionResolver == null) {
responseStatusExceptionResolver = new ResponseStatusExceptionResolver();
}
if (defaultHandlerExceptionResolver == null) {
defaultHandlerExceptionResolver = new DefaultHandlerExceptionResolver();
}
}
protected ResponseEntity jsonResponse(HttpServletRequest request, HttpServletResponse response, int status, Exception e) {//NOPMD
JsonEntity resp = ResponseHelper.createInstance(ExceptionUtil.getExceptionResponse(request, e));
resp.setStatus(status);
resp.setMessage(ExceptionUtil.getErrorMessage(e));
return new ResponseEntity<>(resp, HttpStatus.valueOf(status));
}
@ExceptionHandler(value = Exception.class)
@Order(Ordered.LOWEST_PRECEDENCE)
public final Object defaultErrorHandler(HttpServletRequest req, HttpServletResponse response, @Nullable Object handler, Exception e) {
if (e instanceof InternalHttpException) {
log.warn(e.getMessage());
} else {
log.error(e.getMessage(), e);
}
ErrorWrapperResponse wrapperResponse = new ErrorWrapperResponse(response);
ModelAndView modelAndView = responseStatusExceptionResolver.resolveException(req, wrapperResponse, handler, e);
if (modelAndView == null) {
modelAndView = defaultHandlerExceptionResolver.resolveException(req, wrapperResponse, handler, e);
}
int status;
if (modelAndView == null) {
if (e instanceof BaseException) {
status = ((BaseException) e).responseStatus();
} else {
status = HttpStatus.INTERNAL_SERVER_ERROR.value();
}
modelAndView = new ModelAndView();
req.setAttribute("javax.servlet.error.exception", e);
} else {
status = wrapperResponse.getStatus();
}
if (WebUtil.isAjax(req)) {
return jsonResponse(req, response, status, e);
} else {
return htmlResponse(req, response, modelAndView, status, e);
}
}
private Object htmlResponse(HttpServletRequest request, HttpServletResponse response, ModelAndView modelAndView, int status, Exception e) {//NOPMD
modelAndView.addObject("requestId", WebUtil.getRequestId());
modelAndView.addObject("javax.servlet.error.exception", e);
modelAndView.addObject("errorStatus", status);
modelAndView.setStatus(HttpStatus.valueOf(status));
switch (status) {
case 400:
case 401:
case 403:
case 404:
case 405:
case 410:
case 415:
case 500:
modelAndView.setViewName("error/" + status);
break;
default:
modelAndView.setViewName("error/500");
break;
}
return modelAndView;
}
private static class ErrorWrapperResponse extends HttpServletResponseWrapper {
private int status = 200;
private String message;
private boolean hasErrorToSend = false;
ErrorWrapperResponse(HttpServletResponse response) {
super(response);
}
@Override
public void sendError(int status) throws IOException {
sendError(status, null);
}
@Override
public void sendError(int status, String message) throws IOException {
this.status = status;
this.message = message;
this.hasErrorToSend = true;
}
@Override
public int getStatus() {
if (this.hasErrorToSend) {
return this.status;
} else {
return super.getStatus();
}
}
public String getMessage() {
return this.message;
}
public boolean hasErrorToSend() {
return this.hasErrorToSend;
}
}
}
参考文章
- 注解@ControllerAdvice的工作原理
- Spring Cloud微服务如何设计异常处理机制？