Spring Boot全局异常处理

淡淡的烟草味﹌ 2021-11-04 16:32 460阅读 0赞

Spring Boot默认启动的时候会注入一个专门处理异常的自动配置类:

  1. @Configuration
  2. @ConditionalOnWebApplication(type = Type.SERVLET)
  3. @ConditionalOnClass({ Servlet.class, DispatcherServlet.class })
  4. // Load before the main WebMvcAutoConfiguration so that the error View is available
  5. @AutoConfigureBefore(WebMvcAutoConfiguration.class)
  6. @EnableConfigurationProperties({ ServerProperties.class, ResourceProperties.class })
  7. public class ErrorMvcAutoConfiguration {
  9.     private final ServerProperties serverProperties;
  11.     private final List<ErrorViewResolver> errorViewResolvers;
  13.     public ErrorMvcAutoConfiguration(ServerProperties serverProperties,
  14.             ObjectProvider<List<ErrorViewResolver>> errorViewResolversProvider) {
  15.         this.serverProperties = serverProperties;
  16.         this.errorViewResolvers = errorViewResolversProvider.getIfAvailable();
  17.     }
  19.     @Bean
  20.     @ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
  21.     public DefaultErrorAttributes errorAttributes() {
  22.         return new DefaultErrorAttributes(
  23.                 this.serverProperties.getError().isIncludeException());
  24.     }
  26.     @Bean
  27.     @ConditionalOnMissingBean(value = ErrorController.class, search = SearchStrategy.CURRENT)
  28.     public BasicErrorController basicErrorController(ErrorAttributes errorAttributes) {
  29.         return new BasicErrorController(errorAttributes, this.serverProperties.getError(),
  30.                 this.errorViewResolvers);
  31.     }
  33.     //.................
  35. }

查看源码发现其会注入一个默认的BasicErrorController来处理异常，所以主要看这个Controller：

  1. @Controller
  2. @RequestMapping("${server.error.path:${error.path:/error}}")
  3. public class BasicErrorController extends AbstractErrorController {
  5.     @RequestMapping(produces = "text/html")
  6.     public ModelAndView errorHtml(HttpServletRequest request,
  7.             HttpServletResponse response) {
  8.         HttpStatus status = getStatus(request);
  9.         Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
  10.                 request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
  11.         response.setStatus(status.value());
  12.         ModelAndView modelAndView = resolveErrorView(request, response, status, model);
  13.         return (modelAndView == null ? new ModelAndView("error", model) : modelAndView);
  14.     }
  16.     @RequestMapping
  17.     @ResponseBody
  18.     public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
  19.         Map<String, Object> body = getErrorAttributes(request,
  20.                 isIncludeStackTrace(request, MediaType.ALL));
  21.         HttpStatus status = getStatus(request);
  22.         return new ResponseEntity<>(body, status);
  23.     }
  26. }

这里根据返回类型不同分为了两个方法，errorHtml方法返回ModelAndView，error方法返回ResponseEntity，熟悉SpringMvc的同学应该对这两个类不陌生。其中errorHtml方法中的resolveErrorView方法由父类实现：

  1. public abstract class AbstractErrorController implements ErrorController {
  3.     private final ErrorAttributes errorAttributes;
  5.     private final List<ErrorViewResolver> errorViewResolvers;
  7.     protected ModelAndView resolveErrorView(HttpServletRequest request,
  8.             HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
  9.         for (ErrorViewResolver resolver : this.errorViewResolvers) {
  10.             ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
  11.             if (modelAndView != null) {
  12.                 return modelAndView;
  13.             }
  14.         }
  15.         return null;
  16.     }
  18. }

这里具体是由ErrorViewResolver去处理的，这里当SpringBoot启动的时候会自动装载一个默认的ErrorViewResolver进来，其还实现了Ordered接口，优先级最低，如下：

  1. public class DefaultErrorViewResolver implements ErrorViewResolver, Ordered {
  3.     private static final Map<Series, String> SERIES_VIEWS;
  5.     static {
  6.         Map<Series, String> views = new EnumMap<>(Series.class);
  7.         views.put(Series.CLIENT_ERROR, "4xx");
  8.         views.put(Series.SERVER_ERROR, "5xx");
  9.         SERIES_VIEWS = Collections.unmodifiableMap(views);
  10.     }
  12.     private ApplicationContext applicationContext;
  14.     private final ResourceProperties resourceProperties;
  16.     private final TemplateAvailabilityProviders templateAvailabilityProviders;
  18.     private int order = Ordered.LOWEST_PRECEDENCE;
  20.     @Override
  21.     public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
  22.             Map<String, Object> model) {
  23.         ModelAndView modelAndView = resolve(String.valueOf(status), model);
  24.         if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
  25.             modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
  26.         }
  27.         return modelAndView;
  28.     }
  30.     private ModelAndView resolve(String viewName, Map<String, Object> model) {
  31.         String errorViewName = "error/" + viewName;
  32.         TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
  33.                 .getProvider(errorViewName, this.applicationContext);
  34.         if (provider != null) {
  35.             return new ModelAndView(errorViewName, model);
  36.         }
  37.         return resolveResource(errorViewName, model);
  38.     }
  40.     private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
  41.         for (String location : this.resourceProperties.getStaticLocations()) {
  42.             try {
  43.                 Resource resource = this.applicationContext.getResource(location);
  44.                 resource = resource.createRelative(viewName + ".html");
  45.                 if (resource.exists()) {
  46.                     return new ModelAndView(new HtmlResourceView(resource), model);
  47.                 }
  48.             }
  49.             catch (Exception ex) {
  50.             }
  51.         }
  52.         return null;
  53.     }
  57. }

ResourceProperties中包含了默认的四个静态资源路径：

  1. @ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
  2. public class ResourceProperties {
  4.     private static final String[] CLASSPATH_RESOURCE_LOCATIONS = {
  5.             "classpath:/META-INF/resources/", "classpath:/resources/",
  6.             "classpath:/static/", "classpath:/public/" };
  8.     /**
  9.      * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
  10.      * /resources/, /static/, /public/].
  11.      */
  12.     private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
  14. }

所以分析源码可以发现，SpringBoot会依次从”classpath:/META-INF/resources/“, “classpath:/resources/“,”classpath:/static/“, “classpath:/public/“这四个目录下面寻找是否存在error目录，然后根据错误码errorCode去寻找具体的errorCode.html页面，如果找到则构造成ModelAndView对象返回，我们可以通过添加自定义ErrorViewResolver可以构造自己的异常目录：

  1. @Component
  2. public class CustomErrorViewResolver implements ErrorViewResolver,Ordered,ApplicationContextAware {
  4.     private final String CUSTOM_RESOURCE_LOCATION = "classpath:/static/custom_error/";
  6.     private ApplicationContext applicationContext;
  8.     @Override
  9.     public int getOrder() {
  10.         return 0;
  11.     }
  13.     /**
  14.      * 返回null的时候会由后续的ErrorViewResolver去解析
  15.      * @see org.springframework.boot.autoconfigure.web.servlet.error.AbstractErrorController#resolveErrorView(HttpServletRequest, HttpServletResponse, HttpStatus, Map)
  16.      * @param request
  17.      * @param status
  18.      * @param model
  19.      * @return
  20.      */
  21.     @Override
  22.     public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
  23.         if(status.equals(HttpStatus.INTERNAL_SERVER_ERROR)){
  24.             try {
  25.                 Resource resource = this.applicationContext.getResource(CUSTOM_RESOURCE_LOCATION);
  26.                 resource = resource.createRelative(String.valueOf(status) + ".html");
  27.                 if (resource.exists()) {
  28.                     return new ModelAndView(new HtmlResourceView(resource), model);
  29.                 }
  30.             } catch (IOException e) {
  31.                 e.printStackTrace();
  32.             }
  33.         }
  34.         return null;
  35.     }
  37.     @Override
  38.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  39.         this.applicationContext = applicationContext;
  40.     }
  42.     class HtmlResourceView implements View {
  44.         private Resource resource;
  46.         HtmlResourceView(Resource resource) {
  47.             this.resource = resource;
  48.         }
  50.         @Override
  51.         public String getContentType() {
  52.             return MediaType.TEXT_HTML_VALUE;
  53.         }
  55.         @Override
  56.         public void render(Map<String, ?> model, HttpServletRequest request,
  57.                            HttpServletResponse response) throws Exception {
  58.             response.setContentType(getContentType());
  59.             FileCopyUtils.copy(this.resource.getInputStream(),
  60.                     response.getOutputStream());
  61.         }
  63.     }
  64. }

还可以使用常规的Spring MVC特性，比如@ExceptionHandler方法和@ControllerAdvice解析需要处理的异常。其他未处理的异常由ErrorController来解析。

  1. @ControllerAdvice
  2. public class CustomControllerAdvice extends ResponseEntityExceptionHandler {
  4.     @ExceptionHandler(CustomException.class)
  5.     @ResponseBody
  6.     ResponseEntity<?> handleControllerException(HttpServletRequest request, Throwable ex) {
  7.         HttpStatus status = getStatus(request);
  8.         Map<String, Object> map = new HashMap<>();
  9.         map.put("status",status.value());
  10.         map.put("msg",ex.getMessage());
  11.         return new ResponseEntity<>(map, status);
  12.     }
  14.     private HttpStatus getStatus(HttpServletRequest request) {
  15.         Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
  16.         if (statusCode == null) {
  17.             return HttpStatus.INTERNAL_SERVER_ERROR;
  18.         }
  19.         return HttpStatus.valueOf(statusCode);
  20.     }
  21. }

官方文档：Spring Boot Error Handling

发表评论

表情：
评论列表 （有 0 条评论，460人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Spring Boot全局异常处理

    在开发Web应用程序时，异常处理是非常重要的。在Spring Boot中，我们可以使用全局异常处理器来捕获并处理应用程序中的异常。本文将介绍如何使用Spring Boot的全局

    女爷i女爷i/ 0 赞/ 189 阅读