微服务中如何处理全局异常

「爱情、让人受尽委屈。」 2023-07-11 06:19 5阅读 0赞

微服务中，全局异常处理是一个必须解决的客观课题，如果这些异常处理不好的话，就会给用户看到一些不友好的错误信息，比如客户看到了空指针异常，SQL执行错误等异常，客户肯定是看不懂的，从而大大降低用户体验。

##### 全局异常处理的常见解决方案 #####

*  定义一个处理异常的类，需要处理异常的Controller直接继承这个类，从而获取到异常处理的方法。虽然这种方式可以解决问题，但是极其不灵活，因为动用了继承机制就只为获取一个默认的方法，这显然是不好的。
 *  将这个基类变为接口，提供此方法的默认实现（也就是接口中的default方法，java8开始支持接口方法的默认实现），几乎所有的Controller都需要进行异常处理，所以Controller都需要去写implement XXXException，这个方法显然看起来不是很好。况且这种方式依赖java8才有的语法，这是一个很大的局限。
 *  使用`@controllerAdvice + @ExpectionHandler`，接下来就以这种方式来实现一些全局异常处理。`@ControllerAdvice`作为Spring中默认的注解，提供对所有（你的项目包扫描范围内）Controller的异常捕获功能。

##### 定义默认返回实体 #####

public class JsonEntity<T> 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<ExceptionResponse> 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的工作原理][ControllerAdvice]
 *  [Spring Cloud微服务如何设计异常处理机制？][Spring Cloud]

[ControllerAdvice]: https://blog.csdn.net/andy_zhang2007/article/details/100041219
[Spring Cloud]: https://www.cnblogs.com/wudimanong/p/10710923.html