SpringBoot exception异常处理机制源码解析

一、Spring Boot默认的异常处理机制

　　1：浏览器默认返回效果

　　

　　2：原理解析

　　为了便于源码跟踪解析，在·Controller中手动设置异常。

@RequestMapping(value="/emps",method=RequestMethod.GET)
    public String emps(Map<String,Object> map){

        System.out.println("emp list .......");
        Collection<Employee> emps=employeeDao.getAll();
        map.put("emps", emps);
        int i=/;//设置异常

        return "list";
    }

　　

　　浏览器访问该请求 http://localhost:8080/crud/emps，后台进入DispatcherServlet。

 protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
         HttpServletRequest processedRequest = request;
         HandlerExecutionChain mappedHandler = null;
         boolean multipartRequestParsed = false;

         WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

         try {
             ModelAndView mv = null;
             Exception dispatchException = null;

             try {
                 processedRequest = checkMultipart(request);
                 multipartRequestParsed = (processedRequest != request);

                 // Determine handler for the current request.
                 mappedHandler = getHandler(processedRequest);
                 if (mappedHandler == null || mappedHandler.getHandler() == null) {
                     noHandlerFound(processedRequest, response);
                     return;
                 }

                 // Determine handler adapter for the current request.
                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                 // Process last-modified header, if supported by the handler.
                 String method = request.getMethod();
                 boolean isGet = "GET".equals(method);
                 if (isGet || "HEAD".equals(method)) {
                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                     if (logger.isDebugEnabled()) {
                         logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                     }
                     if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                         return;
                     }
                 }

                 if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                     return;
                 }

                 // Actually invoke the handler.
                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                 if (asyncManager.isConcurrentHandlingStarted()) {
                     return;
                 }

                 applyDefaultViewName(processedRequest, mv);
                 mappedHandler.applyPostHandle(processedRequest, response, mv);
             }
             catch (Exception ex) {
                 dispatchException = ex;
             }
             catch (Throwable err) {
                 // As of 4.3, we're processing Errors thrown from handler methods as well,
                 // making them available for @ExceptionHandler methods and other scenarios.
                 dispatchException = new NestedServletException("Handler dispatch failed", err);
             }
             processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
         }
         catch (Exception ex) {
             triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
         }
         catch (Throwable err) {
             triggerAfterCompletion(processedRequest, response, mappedHandler,
                     new NestedServletException("Handler processing failed", err));
         }
         finally {
             if (asyncManager.isConcurrentHandlingStarted()) {
                 // Instead of postHandle and afterCompletion
                 if (mappedHandler != null) {
                     mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                 }
             }
             else {
                 // Clean up any resources used by a multipart request.
                 if (multipartRequestParsed) {
                     cleanupMultipart(processedRequest);
                 }
             }
         }
     }

　　

　　第17行获取HandlerExecutionChain，根据url：/emps 从RequestMappingHandlerMapping获取HandlerExecutionChain

　　第24行根据Handler获取相应的RequestMappingHandlerAdapter

　　第44行RequestMappingHandlerAdapter调用handle(),其中完成Cnotroller.emps()调用

　　　　1）argumentResolvers根据HandlerMethod.parameters 完成emps方法入参的准备

　　　　2）执行InvocableHandlerMethod.doInvoke;

　　　　3）returnValueHandlers.handleReturnValue对Cnotroller.emps() 返回参数的对应处理

　　

　　由于在emps()手动设置了异常，上述第2步调用InvocableHandlerMethod.doInvoke时会抛出 java.lang.ArithmeticException: / by zero

　　程序执行进入54行，然后执行61行：processDispatchResult。

　　

　　1222行由HandlerExceptionResolver对异常进行处理.其中DefaultErrorAttributes的exception处理：

　　最后1244 行抛出异常，然后一层一层往外抛出此异常，直到最外层StandardWrapperValve.invoke()对此异常进行了处理

　　

　　

　　然后程序执行到StandardHostValve的173行，判断是否需要进行response的异常处理

　　StandardHostValve中status()中，229行会从容器中配置的ErrorPage：转发后默认处理的ErrorController

　　

　　StandardHostValve.custom()中 根据errorPage.location进行转发。

　　SpringBoot中BasicErrorController：处理默认异常转发的/error请求

 @Controller
 @RequestMapping("${server.error.path:${error.path:/error}}")
 public class BasicErrorController extends AbstractErrorController {
 　　@RequestMapping(produces = "text/html") //产生html类型的数据；浏览器发送的请求来到这个方法处理
     public ModelAndView errorHtml(HttpServletRequest request,
             HttpServletResponse response) {
         HttpStatus status = getStatus(request);
         Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
                 request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
         response.setStatus(status.value());
         ModelAndView modelAndView = resolveErrorView(request, response, status, model);//去哪个页面作为错误页面；包含页面地址和页面内容
         return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
     }

     @RequestMapping
     @ResponseBody
     public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {//产生json数据，其他客户端来到这个方法处理；
         Map<String, Object> body = getErrorAttributes(request,
                 isIncludeStackTrace(request, MediaType.ALL));
         HttpStatus status = getStatus(request);
         return new ResponseEntity<Map<String, Object>>(body, status);
     }

　　DefaultErrorAttributes中设置页面的共享信息

@Override
    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
            boolean includeStackTrace) {
        Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
        errorAttributes.put("timestamp", new Date());
        addStatus(errorAttributes, requestAttributes);
        addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
        addPath(errorAttributes, requestAttributes);
        return errorAttributes;
    }

　　DefaultErrorViewResolver

@Override
    public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
            Map<String, Object> model) {
        ModelAndView modelAndView = resolve(String.valueOf(status), model);
        if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
            modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
        }
        return modelAndView;
    }

    private ModelAndView resolve(String viewName, Map<String, Object> model) {
        String errorViewName = "error/" + viewName;//默认SpringBoot可以去找到一个页面？ error/500
        TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
                .getProvider(errorViewName, this.applicationContext);//模板引擎可以解析这个页面地址就用模板引擎解析
        if (provider != null) {
            return new ModelAndView(errorViewName, model);//模板引擎可用的情况下返回到errorViewName指定的视图地址
        }
        return resolveResource(errorViewName, model);//模板引擎不可用，就在静态资源文件夹下找errorViewName对应的页面 error/500.html
    }