【源码阅读】HandlerExceptionResolver的部分源码阅读

最新推荐文章于 2023-03-17 14:41:50 发布
最新推荐文章于 2023-03-17 14:41:50 发布
阅读量357 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lbh_paopao/article/details/109317668
版权

起因

Spring Rest调用的异常处理 的相关源码学习

源码阅读

  1. 由于 @ExceptionHandler 只能做用在 @Controller 上，所以 @ExceptionHandler 的处理逻辑应该和 @Controller 处理的时机一样，所以关注点应该在 DispatcherServlet 核心类的 doDispatch() 方法

  2. DispatcherServlet 的 doDispatch() 方法

    	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);

                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

                String method = request.getMethod();
                boolean isGet = "GET".equals(method);
                if (isGet || "HEAD".equals(method)) {
                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

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

                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) {
                dispatchException = new NestedServletException("Handler dispatch failed", err);
            }
            // dispatchException就是捕捉到的所有异常，所以这里是处理异常的逻辑
            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()) {
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

  3. DispatcherServlet 的 processDispatchResult() 方法

    	private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerExecutionChain mappedHandler, @Nullable  ModelAndView mv, @Nullable Exception exception) throws Exception {

        boolean errorView = false;

        // 判断是不是有异常
        if (exception != null) {
            // 处理 ModelAndViewDefiningException 类型异常
            if (exception instanceof ModelAndViewDefiningException) {
                logger.debug("ModelAndViewDefiningException encountered", exception);
                mv = ((ModelAndViewDefiningException) exception).getModelAndView();
            }
            else {
            // 处理其他类型的异常    
                Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
                mv = processHandlerException(request, response, handler, exception);
                errorView = (mv != null);
            }
        }

        if (mv != null && !mv.wasCleared()) {
            render(mv, request, response);
            if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
            }
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("No view rendering, null ModelAndView returned.");
            }
        }

        if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
            return;
        }

        if (mappedHandler != null) {
            mappedHandler.triggerAfterCompletion(request, response, null);
        }
    }

  4. DispatcherServlet 的 processDispatchResult() 方法

    	@Nullable
    protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) throws Exception {

        request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

        ModelAndView exMv = null;
        if (this.handlerExceptionResolvers != null) {
            // 这里看出，处理异常的Resolver是本类的一个属性里边遍历出来 那就搜一下这个属性在哪里set的值 
            for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
                // 这里调用的就是ExceptionHandlerExceptionResolver的resolveException()方法
                // 这里把异常转化成了 ModelAndView
                exMv = resolver.resolveException(request, response, handler, ex);
                if (exMv != null) {
                    break;
                }
            }
        }
        if (exMv != null) {
            if (exMv.isEmpty()) {
                request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
                return null;
            }
            if (!exMv.hasView()) {
                String defaultViewName = getDefaultViewName(request);
                if (defaultViewName != null) {
                    exMv.setViewName(defaultViewName);
                }
            }
            if (logger.isTraceEnabled()) {
                logger.trace("Using resolved error view: " + exMv, ex);
            }
            else if (logger.isDebugEnabled()) {
                logger.debug("Using resolved error view: " + exMv);
            }
            WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
            return exMv;
        }

        throw ex;
    }

  5. DispatcherServlet 的 initHandlerExceptionResolvers() 方法

        private void initHandlerExceptionResolvers(ApplicationContext context) {
        this.handlerExceptionResolvers = null;

        if (this.detectAllHandlerExceptionResolvers) {
            // Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
            // 这里官方注解也说了，从ApplicationContext中找到所有HandlerExceptionResolvers，HandlerExceptionResolvers作为接口，它的实现类就有ExceptionHandlerExceptionResolver，所以这里也是遍历出了所有的ExceptionHandlerExceptionResolver
            Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false;
            if (!matchingBeans.isEmpty()) {
                this.handlerExceptionResolvers = new ArrayList<>(matchingBeans.values());
                AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
            }
        }
        else {
            try {
                HandlerExceptionResolver her = context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
                this.handlerExceptionResolvers = Collections.singletonList(her);
            }
            catch (NoSuchBeanDefinitionException ex) {
            }
        }

        if (this.handlerExceptionResolvers == null) {
            this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerExceptionResolvers declared in servlet '" + getServletName() + "': using default strategies from DispatcherServlet.properties");
            }
        }        
    }

  6. AbstractHandlerExceptionResolver 的 resolveException() 方法。这里是使用了模板模式。父类接口 HandlerExceptionResolvers 定义了空的 resolveException() 方法。ExceptionHandlerExceptionResolver 继承了 AbstractHandlerMethodExceptionResolver，AbstractHandlerMethodExceptionResolver 又继承了 AbstractHandlerExceptionResolver。而AbstractHandlerExceptionResolver。而实现了 HandlerExceptionResolvers。真正的模板方法在 AbstractHandlerExceptionResolver 中。ExceptionHandlerExceptionResolver 通过继承的方法直接使用了父类的方法

    	@Override
    @Nullable
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {

        if (shouldApplyTo(request, handler)) {
            prepareResponse(ex, response);
            // 处理异常
            ModelAndView result = doResolveException(request, response, handler, ex);
            if (result != null) {
                // Print debug message when warn logger is not enabled.
                if (logger.isDebugEnabled() && (this.warnLogger == null || !this.warnLogger.isWarnEnabled())) {
                    logger.debug("Resolved [" + ex + "]" + (result.isEmpty() ? "" : " to " + result));
                }
                // Explicitly configured warn logger in logException method.
                logException(ex, request);
            }
            return result;
        }
        else {
            return null;
        }
    }

    // 这里还是个模板模式  AbstractHandlerExceptionResolver定义了处理异常的抽象方法doResolveException
    @Nullable
    protected abstract ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);

  7. AbstractHandlerMethodExceptionResolver 的 doResolveException() 方法

    	@Override
    @Nullable
    protected final ModelAndView doResolveException(
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {

        return doResolveHandlerMethodException(request, response, (HandlerMethod) handler, ex);
    }


    // 模板模式
    @Nullable
    protected abstract ModelAndView doResolveHandlerMethodException(
            HttpServletRequest request, HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception ex);

  8. ExceptionHandlerExceptionResolver 的 doResolveHandlerMethodException()

    	@Override
    @Nullable
    protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {

        ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
        if (exceptionHandlerMethod == null) {
            return null;
        }

        if (this.argumentResolvers != null) {
            exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
        }
        if (this.returnValueHandlers != null) {
            exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
        }

        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        ModelAndViewContainer mavContainer = new ModelAndViewContainer();

        try {
            if (logger.isDebugEnabled()) {
                logger.debug("Using @ExceptionHandler " + exceptionHandlerMethod);
            }
            Throwable cause = exception.getCause();
            if (cause != null) {
                // Expose cause as provided argument as well
                // 获取参数和原因
                exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, cause, handlerMethod);
            }
            else {
                // Otherwise, just the given exception as-is
                // 获取参数
                exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, exception, handlerMethod);
            }
        }
        catch (Throwable invocationEx) {
            // Any other than the original exception (or its cause) is unintended here,
            // probably an accident (e.g. failed assertion or the like).
            if (invocationEx != exception && invocationEx != exception.getCause() && logger.isWarnEnabled()) {
                logger.warn("Failure in @ExceptionHandler " + exceptionHandlerMethod, invocationEx);
            }
            // Continue with default processing of the original exception...
            return null;
        }

        if (mavContainer.isRequestHandled()) {
            return new ModelAndView();
        }
        else {
            ModelMap model = mavContainer.getModel();
            HttpStatus status = mavContainer.getStatus();
            ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, status);
            mav.setViewName(mavContainer.getViewName());
            if (!mavContainer.isViewReference()) {
                mav.setView((View) mavContainer.getView());
            }
            if (model instanceof RedirectAttributes) {
                Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
                RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
            }
            return mav;
        }
    }

  9. ServletInvocableHandlerMethod 的 invokeAndHandle()

        public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
        setResponseStatus(webRequest);

        if (returnValue == null) {
            if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
                disableContentCachingIfNecessary(webRequest);
                mavContainer.setRequestHandled(true);
                return;
            }
        }
        else if (StringUtils.hasText(getResponseStatusReason())) {
            mavContainer.setRequestHandled(true);
            return;
        }

        mavContainer.setRequestHandled(false);
        Assert.state(this.returnValueHandlers != null, "No return value handlers");
        try {
            this.returnValueHandlers.handleReturnValue(
                    returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        }
        catch (Exception ex) {
            if (logger.isTraceEnabled()) {
                logger.trace(formatErrorForReturnValue(returnValue), ex);
            }
            throw ex;
        }
    }

  10. InvocableHandlerMethod 的 invokeForRequest()

        @Nullable
    public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
        // 获取配置的参数
        Object[] args = this.getMethodArgumentValues(request, mavContainer, providedArgs);
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Arguments: " + Arrays.toString(args));
        }

        // 执行
        return this.doInvoke(args);
    }

  11. 再往下就是获取可以配置的参数了，其实 ExceptionHandlerExceptionResolver 实现了 InitializingBean。重写了 afterPropertiesSet() 方法，所以每次调用的时候都可以刷新参数

    	@Override
    public void afterPropertiesSet() {
        // Do this first, it may add ResponseBodyAdvice beans
        initExceptionHandlerAdviceCache();

        if (this.argumentResolvers == null) {
            List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
            this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
        }
        if (this.returnValueHandlers == null) {
            List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
            this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
        }
    }

    private void initExceptionHandlerAdviceCache() {
        if (getApplicationContext() == null) {
            return;
        }

        // 扫描 @ControllerAdvice 注解
        List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
        for (ControllerAdviceBean adviceBean : adviceBeans) {
            Class<?> beanType = adviceBean.getBeanType();
            if (beanType == null) {
                throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
            }
            // 查询所有 @ExceptionHandler 注解
            ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
            if (resolver.hasExceptionMappings()) {
                this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
            }
            if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
                this.responseBodyAdvice.add(adviceBean);
            }
        }

        if (logger.isDebugEnabled()) {
            int handlerSize = this.exceptionHandlerAdviceCache.size();
            int adviceSize = this.responseBodyAdvice.size();
            if (handlerSize == 0 && adviceSize == 0) {
                logger.debug("ControllerAdvice beans: none");
            }
            else {
                logger.debug("ControllerAdvice beans: " +
                        handlerSize + " @ExceptionHandler, " + adviceSize + " ResponseBodyAdvice");
            }
        }
    }
我永远吹着泡泡
关注
专栏目录
spring源码可导入eclipse版本 第五部分
06-28
Spring框架是Java开发中不可或缺的一部分，它以其模块化、易扩展和强大的依赖注入特性而闻名...通过阅读和分析源码，你将能够更深入地掌握依赖注入、AOP、MVC、数据访问和测试等方面的知识，从而提升你的Java开发技能。
spring mvc异常处理源码解读 ——HandlerExceptionResolver
lzf的博客
05-05 1万+
2.常见全局异常处理 在 Spring 中常见的全局异常处理，主要有三种： （1）注解 ExceptionHandler （2）继承 HandlerExceptionResolver 接口 （3）注解 ControllerAdvice 在后面的讲解中，主要以 HTTP 错误码：400（请求无效）和 500（内部服务器错误）为例，先看一下测试代码以及没有任何处理的返回结果，如下： 图 1：测试代码 图 2：没有异常的错误返回 2.1 注解 Exce.
ExceptionHandlerExceptionResolver源码分析
最新发布
峰
03-17 172
ExceptionHandlerExceptionResolver部分属性. . .自定义WebMvcConfigSupport，不推荐，需要配置整个Mvc通过提供扩展接口参数解析器、返回值解析器、消息转换器、contentNegotiationManager，可通过MvcConfigureresponseBodyAdvice，通过ControllerAdive注解上两者都支持通过WebMvcRegistrations配置。
SpringMVC源码---HandlerExceptionResolver
Visonws的博客
08-25 1711
HandlerExceptionResolver用于解析请求过程中所产生的异常，继承结构图： 简介：     HandlerExceptionResolver主要实现都继承与抽象类的AbstractHandlerExecutionResolver，它有五个子类，其中AnnotationMethodHandlerExceptionResolver已经被弃用。剩余的 AbstractHand...
Spring MVC 第三篇 - 关于处理器映射器 RequestMappingHandlerMapping
paralysed的博客
10-16 1114
目录 前言 RequestMappingHandlerMapping 什么时候被加载进容器？ Spring MVC 创建容器和实例化 bean 的流程 ​ 命名空间处理器NamespaceHandler RequestMappingHandlerMapping 什么时候保存的请求和处理器的映射关系？ 再谈请求达到服务端时如何找到对应的 HandlerMethod 前言 处理器映射器保存了请求和处理器的映射关系，在...
SpringMVC请求原理源码分析
asoklove的专栏
03-17 191
以下是基于SpringBoot2.2.6环境 直接从DispatcherServlet的核心方法说起： protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { // ... mappedHandler = getHandler(processedRequest); // ... HandlerAdapter ha = ge...
spring及springmvc源码
06-05
异常处理器（HandlerExceptionResolver）能够捕获和处理控制器抛出的异常，提供统一的错误页面。 在源码学习过程中，你可能会遇到以下关键类和接口：`RequestMappingHandlerMapping`, `...
spring源码
10-16
Spring MVC作为Spring框架的一部分，是用于构建Web应用程序的模块，它允许开发者通过分离关注点来构建可维护和可测试的Web应用。 Spring MVC采用了典型的三层架构，包括表现层、业务逻辑层和数据访问层。这种架构...
ExceptionHandlerExceptionResolver类源码解析
邱学喆的专栏
11-14 4363
一. ExceptionHandlerExceptionResolver异常处理过程 先从入口着手，如下图： 整体逻辑很明显：1. 判断是否匹配这个异常处理，如果不匹配则直接返回null;否则进行第二步；2. 预先处理响应(基本是添加响应头等处理，具体可以看方法体)，接着进入第三步；3. 这个就是核心的异常处理逻辑方法体； 现在先看shouldApplyTo方法体的实现，主要是判断是否匹...
基于Multisim的数字秒表设计
10-31
利用Multisim仿真软件研究并设计一个纯硬件构成的六位数字秒表。该秒表主要包括自行设计的时钟发生电路，以74LS160为基础的计数器，以及LED译码驱动电路，外围控制电路等，并简要说明了硬件结构。仿真结果表明，该设计思路合理，可行，运行可靠，易于实现。
SpringMVC源码剖析（七）- HandlerExceptionResolver异常解析器家族揭秘
热门推荐
pfnie的博客
09-02 2万+
在Spring MVC中，所有用于处理在请求处理过程中抛出的异常，都要实现HandlerExceptionResolver接口。HandlerExceptionResolver是Spring MVC提供的非常好的通用异常处理工具，不过需要注意的是，它只能处理请求过程中抛出的异常，异常处理本身所抛出的异常和视图解析过程中抛出的异常它是不能处理的。AbstractHandlerExceptionR
webpack4打包传统H5多页面
paopao_wu的专栏
08-01 2929
1. webpack核心概念 入口（entry） 输出（output） loader 插件（plugins） 官方文档： https://www.webpackjs.com/configuration/output/#output-filename 1.1 入口 指定 webpack 由哪个模块作为项目构建的开始.通过配置 entry 属性，指定一个或多个起点，默认值 ./src : 用法: entry: string|Array ,可以是一个字符串也可以是一个数组，还可以是一个对象。 modu
QT_QWebEngineView_自制浏览器_01
paopao_wu的专栏
08-14 2285
0 .需求 打开固定的站点网页，并能够正常浏览 能打开本地的单页面HTML5应用（Vue），能够跨域发送Ajax请求到API接口获取数据 拦截所有HTTP请求，请求发送之前添加自定义的请求头 JavaScript 与本地代码相互通信 比较简单的方案是 Electron， 使用 JavaScript, HTML 和 CSS 等 Web 技术创建原生程序的框架。它可以完美解决上面所有问题。但是用它打包出来的应用体积过大。 这里本着学习的态度，使用QT中的 QWebEngineView 来实现上面的需求。它与
8_混入_Mixin
paopao_wu的专栏
08-08 260
1. 什么是mixin ​ 假设定义了两个组件，这两个组件非常相似，他们的基本功能是一样的，但他们之间又存在着足够的差异性，此时的你就像是来到了一个分岔路口：我是把它拆分成两个不同的组件呢？还是保留为一个组件，然后通过props传值来创造差异性从而进行区分呢？ ​ 如果拆分成两个组件，如果公共的功能出现变动，就需要同时更改两个组件，这违背了 DRY 原则。反之，太多的props传值会很快变得混乱不堪，从而使得维护变得很麻烦。 ​ 使用Mixin，可以将一个组件的选项（data,props,compu
第十章 Spring5异常与跨域问题笔记
hankin的博客
01-17 2559
一、异常处理分析 1、Controller调用过程中的异常解析使用 示例代码如下：package com.chj.controllerAdvice; @ControllerAdvice("com.chj")public class ExceptionHandlerControllerAdvice { @ExceptionHandler({ArrayIndexOutOfBoundsEx...
【学习笔记】DataAccessException
lbh_paopao的博客
08-28 3973
介绍 官方解释：Root of the hierarchy of data access exceptions。可以理解为它是处理数据层面的顶级异常 往上看：DataAccessException 继承了 NestedRuntimeException，而 NestedRuntimeException 继承了 RuntimeException。所以它是个运行时异常 往下看：DataAccessException 类是其他异常封装出来的，具体的封装接口是 PersistenceExceptionTranslat
Eclipse IDE阅读Java源码的高效技巧
"分享Java源码跟踪阅读技巧，适用于Spring、Dubbo等框架源码阅读，基于Eclipse IDE" 在深入研究Java中间件如Spring、Dubbo等复杂框架的源码时，掌握有效的阅读技巧至关重要。这里我们将探讨三个关键的Eclipse IDE...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值