统一异常处理概述

spring mvc中如何做统一异常处理

先加载的@ControllerAdvice类里如果存在@ExceptionHandler(xxException.class)是需要捕获的异常或其父类，则将使用先加载的类中的异常处理方式。如果没有，则看后面的@ControllerAdvice类里是否有。
可以使用@Order来决定加载优先级，网上也有说法可以使用@Primary，暂未自测，个人觉得应该也是可行的。

如果有多个统一异常处理怎么办

  1. 使用basePackageClasses属性，将想要优先加载的包写在前面；
  2. 使用@Order注解来决定顺序
  3. 使用excludeFilters属性排除不想要加载的类，该属性使用方式多样，可自行搜索查看。（例：@ComponentScan(excludeFilters = @ComponentScan.Filter( type = FilterType.ASSIGNABLE_TYPE, classes = xx.class))）

项目中的统一异常处理

  1. package com.yonyoucloud.manufacturing.web;
  3. import com.yonyou.ucf.mdd.ext.util.ResultMessage;
  4. import org.imeta.biz.base.BizException;
  5. import org.springframework.http.HttpStatus;
  6. import org.springframework.http.MediaType;
  7. import org.springframework.http.ResponseEntity;
  8. import org.springframework.web.bind.annotation.*;
  9. import org.springframework.web.servlet.NoHandlerFoundException;
  11. import javax.servlet.http.HttpServletRequest;
  13. @ControllerAdvice
  14. public class ErrorHandler {
  16.     @ExceptionHandler(BizException.class)
  17.     @ResponseBody
  18.     ResponseEntity<?> handleBizException(HttpServletRequest request, Throwable ex) {
  19.         //HttpStatus status = getStatus(request);
  20.         return errResponse(ResultMessage.error(ex.getMessage()), HttpStatus.OK);
  21.     }
  23.     @ExceptionHandler(NoHandlerFoundException.class)
  24.     @ResponseBody
  25.     ResponseEntity<?> handleNotFoundException(HttpServletRequest request, Throwable ex) {
  26.         //HttpStatus status = getStatus(request);
  27.         return errResponse(ResultMessage.error(String.format("接口无效:%s", request.getRequestURI())), HttpStatus.OK);
  28.     }
  30.     @ExceptionHandler(Throwable.class)
  31.     @ResponseBody
  32.     ResponseEntity<?> handleCommonException(HttpServletRequest request, Throwable ex) {
  33.         HttpStatus status = getStatus(request);
  34.         return errResponse(ResultMessage.error(ex.getMessage()), status);
  35.     }
  37.     private HttpStatus getStatus(HttpServletRequest request) {
  38.         Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
  39.         if (statusCode == null) {
  40.             return HttpStatus.INTERNAL_SERVER_ERROR;
  41.         }
  42.         return HttpStatus.valueOf(statusCode);
  43.     }
  45.     private ResponseEntity<?> errResponse(String message, HttpStatus status) {
  46.         return ResponseEntity.status(status).contentType(MediaType.APPLICATION_JSON_UTF8)
  47.                 .body(message);
  48.     }
  49. }

平台的统一异常处理

mdd框架中也有类似的处理

  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  6. package com.yonyou.iuap.ucf.core.exception;
  8. import com.yonyou.iuap.ucf.common.exception.BusinessException;
  9. import com.yonyou.iuap.ucf.common.exception.CommonExceptionConstants;
  10. import com.yonyou.iuap.ucf.common.rest.CommonResponse;
  11. import org.apache.commons.lang3.exception.ExceptionUtils;
  12. import org.slf4j.Logger;
  13. import org.slf4j.LoggerFactory;
  14. import org.slf4j.MDC;
  15. import org.springframework.beans.factory.annotation.Value;
  16. import org.springframework.web.bind.annotation.ControllerAdvice;
  17. import org.springframework.web.bind.annotation.ExceptionHandler;
  18. import org.springframework.web.bind.annotation.ResponseBody;
  20. @ControllerAdvice
  21. public class CommonExceptionHandler {
  22.     private static final Logger log = LoggerFactory.getLogger(CommonExceptionHandler.class);
  23.     @Value("${ucf.enableExcepthonHandler:true}")
  24.     private String enableExcepthonHandler;
  26.     public CommonExceptionHandler() {
  27.     }
  29.     @ExceptionHandler({Throwable.class})
  30.     public CommonResponse handleThrowable(final Throwable e) throws Throwable {
  31.         if (this.enableExcepthonHandler != null && !"true".equals(this.enableExcepthonHandler)) {
  32.             throw e;
  33.         } else {
  34.             return this.handleBusinessException(new BusinessException(CommonExceptionConstants.UNKNOWN_EXCEPTION, e));
  35.         }
  36.     }
  38.     @ExceptionHandler({BusinessException.class})
  39.     @ResponseBody
  40.     public CommonResponse handleBusinessException(final BusinessException excetpion) {
  41.         try {
  42.             MDC.put("code", String.valueOf(excetpion.getErrorCode()));
  43.             if (excetpion.getCause() != null) {
  44.                 log.error("出现异常啦", excetpion);
  45.             } else {
  46.                 String[] stackFrames = ExceptionUtils.getStackFrames(excetpion);
  47.                 String latestUsableStack = "";
  48.                 if (stackFrames != null && stackFrames.length > 1) {
  49.                     latestUsableStack = stackFrames[1];
  50.                 }
  52.                 log.error("出现异常啦：" + excetpion.getMessage() + "，异常编码：" + excetpion.getErrorCode() + "，异常发生地：" + latestUsableStack);
  53.             }
  54.         } finally {
  55.             MDC.remove("code");
  56.         }
  58.         return CommonResponse.ofFail(excetpion);
  59.     }
  60. }

这样，咱们的项目运行起来就会有两个@ControllerAdvice的异常处理器，那到底会用哪个呢？

  1. 没有打@Order注解

  2. 因为没有打@Order注解，所以就取决于scan包的顺序了。在config项目的applicationContext中，看到了这样的配置

    1. <context:component-scan base-package="com.yonyoucloud,com.yonyou">
    2.      <context:exclude-filter type="assignable" expression="org.imeta.orm.base.BizObject"/>
    3.      <context:exclude-filter type="regex" expression="com.yonyou.ucf.mdd.ext.controller.FileUpload"/>
    4.      <context:exclude-filter type="regex"
    5.                              expression="com.yonyou.ucf.mdd.ext.portal.controller.PortalLayoutController"/>
    6.      <context:exclude-filter type="regex" expression="com.yonyoucloud.uretail.*"/>
    8.      <context:exclude-filter type="regex" expression="com.yonyou.ucf.mdd.core.file.oss.*"/>
    9.      <context:exclude-filter type="regex" expression="com.yonyou.ucf.mdd.poi.*"/>
    10.      <context:exclude-filter type="regex" expression="com.yonyou.ucf.mdd.conf.*" />
    11.      <context:exclude-filter type="regex" expression="com.yonyou.ucf.mdd.dao.*" />
    12.      <context:exclude-filter type="regex" expression="com.yonyou.ucf.mdd.rule.context.*" />
    13.      <context:exclude-filter type="regex" expression="com.yonyou.ucf.mdd.uimeta.context.*" />
    14.  </context:component-scan>

    咱们几个项目的表现不同，就是因为base-package的配置顺序不同导致的。导致会使用不同的全局异常处理器

参考文档

springboot多个@ControllerAdvice全局异常处理