【SpringBoot3】SpringBoot中实现全局统一异常处理

Dear 丶 2024-03-30 17:59 78阅读 0赞

**在服务器端出现异常，或者客户端请求出错时，直接返回异常信息对用户来说是非常不友好的，我们需要对异常信息进行统一处理**

#### 1、使用 @ControllerAdvice 注解 ####

使用 @ControllerAdvice 注解的控制层的全局统一[异常处理][Link 1]

@ControllerAdvice
    public class GlobalExceptionHandler {
    
        @ExceptionHandler(Exception.class)
        public ModelAndView customException(Exception e) {
            ModelAndView mav = new ModelAndView();
            // 跳转到错误页面
            mav.setViewName("error");
            return mav;
        }
    }

@ControllerAdvice 表示这是一个控制器增强类，当控制器发生异常且符合类中定义的拦截异常类，将会被拦截

@ExceptionHandler 则是定义拦截的异常类，可以是自定义异常类，例如：

@ExceptionHandler(value = MyException.class)
    @ResponseBody
    public JSONObject myErrorHandler(MyException exception) {
        JSONObject res = new JSONObject();
        res.put("code", exception.getCode());
        res.put("msg", exception.getMsg());
        return res;
    }

当然，我们可以不返回页面，只返回异常信息

**使用 @ControllerAdvice 只能捕获 Controller 层的异常，前提是 Controller 层没有对异常做 catch 处理**

#### 2、实现 ErrorController 接口 ####

以下是网上一位博主给出的示例代码，博客地址为：https://blog.csdn.net/king\_is\_everyone/article/details/53080851

@Controller
    @RequestMapping(value = "error")
    @EnableConfigurationProperties({ServerProperties.class})
    public class ExceptionController implements ErrorController {
    
        private ErrorAttributes errorAttributes;
    
        @Autowired
        private ServerProperties serverProperties;
    
    
        /**
         * 初始化ExceptionController
         *
         * @param errorAttributes
         */
        @Autowired
        public ExceptionController(ErrorAttributes errorAttributes) {
            Assert.notNull(errorAttributes, "ErrorAttributes must not be null");
            this.errorAttributes = errorAttributes;
        }
    
    
        /**
         * 定义404的ModelAndView
         *
         * @param request
         * @param response
         * @return
         */
        @RequestMapping(produces = "text/html", value = "404")
        public ModelAndView errorHtml404(HttpServletRequest request, HttpServletResponse response) {
            response.setStatus(getStatus(request).value());
            Map<String, Object> model = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.TEXT_HTML));
            return new ModelAndView("error/404", model);
        }
    
        /**
         * 定义404的JSON数据
         *
         * @param request
         * @return
         */
        @RequestMapping(value = "404")
        @ResponseBody
        public ResponseEntity<Map<String, Object>> error404(HttpServletRequest request) {
            Map<String, Object> body = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.TEXT_HTML));
            HttpStatus status = getStatus(request);
            return new ResponseEntity<Map<String, Object>>(body, status);
        }
    
        /**
         * 定义500的ModelAndView
         *
         * @param request
         * @param response
         * @return
         */
        @RequestMapping(produces = "text/html", value = "500")
        public ModelAndView errorHtml500(HttpServletRequest request, HttpServletResponse response) {
            response.setStatus(getStatus(request).value());
            Map<String, Object> model = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.TEXT_HTML));
            return new ModelAndView("error/500", model);
        }
    
    
        /**
         * 定义500的错误JSON信息
         *
         * @param request
         * @return
         */
        @RequestMapping(value = "500")
        @ResponseBody
        public ResponseEntity<Map<String, Object>> error500(HttpServletRequest request) {
            Map<String, Object> body = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.TEXT_HTML));
            HttpStatus status = getStatus(request);
            return new ResponseEntity<Map<String, Object>>(body, status);
        }
    
    
        /**
         * 确定是否应包含stacktrace属性
         *
         * @param request  the source request
         * @param produces the media type produced (or {@code MediaType.ALL})
         * @return if the stacktrace attribute should be included
         */
        protected boolean isIncludeStackTrace(HttpServletRequest request, MediaType produces) {
            ErrorProperties.IncludeStacktrace include = this.serverProperties.getError().getIncludeStacktrace();
            if (include == ErrorProperties.IncludeStacktrace.ALWAYS) {
                return true;
            }
            if (include == ErrorProperties.IncludeStacktrace.ON_TRACE_PARAM) {
                return getTraceParameter(request);
            }
            return false;
        }
    
    
        /**
         * 获取错误的信息
         *
         * @param request
         * @param includeStackTrace
         * @return
         */
        private Map<String, Object> getErrorAttributes(HttpServletRequest request, boolean includeStackTrace) {
            RequestAttributes requestAttributes = new ServletRequestAttributes(request);
            return this.errorAttributes.getErrorAttributes((WebRequest) requestAttributes, includeStackTrace);
        }
    
        /**
         * 是否包含trace
         *
         * @param request
         * @return
         */
        private boolean getTraceParameter(HttpServletRequest request) {
            String parameter = request.getParameter("trace");
            if (parameter == null) {
                return false;
            }
            return !"false".equals(parameter.toLowerCase());
        }
    
        /**
         * 获取错误编码
         *
         * @param request
         * @return
         */
        private HttpStatus getStatus(HttpServletRequest request) {
            Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
            if (statusCode == null) {
                return HttpStatus.INTERNAL_SERVER_ERROR;
            }
            try {
                return HttpStatus.valueOf(statusCode);
            } catch (Exception ex) {
                return HttpStatus.INTERNAL_SERVER_ERROR;
            }
        }
    
        /**
         * 实现错误路径
         *
         * @return
         */
        @Override
        public String getErrorPath() {
            return "";
        }
    
    }

总结  
1、@ControllerAdvice 定义多个拦截方法，拦截不同的异常类，并且可以获取抛出的异常信息  
2、@ControllerAdvice 只能捕获进入 Controller 层的异常，比如404,401等错误无法捕获  
3、ErrorController，该方式几乎可以处理所有的异常，包括未进入控制器的错误，比如404,401等错误

当然，前提是没有对异常做 catch 处理才能捕获到

[Link 1]: https://so.csdn.net/so/search?q=%E5%BC%82%E5%B8%B8%E5%A4%84%E7%90%86&spm=1001.2101.3001.7020