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=1/0;//设置异常
        
        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
    }