Spring Web MVC工作原理

总结

在javax.servlet.http.HttpServlet的基础上添加额外功能，包括参数解析、请求拦截器、异常处理、视图渲染等。

核心组件：DispatcherServlet、【Handler、HandlerMapping、HandlerAdapter、HandlerExecutionChain、HandlerInterceptor、HandlerExceptionResolver】、ModelAndView、ViewResolver 等。

工作流程：

 

 

 

Handler

springframework中对http request的最细粒度的处理者，类似于javax中的Servlet。类型有：

org.springframework.web.HttpRequestHandler：接口，有很多实现类，如ResourceHttpRequestHandler专门用于处理静态资源请求。

org.springframework.web.servlet.mvc.Controller：接口，有很多实现类，如ServletWrappingController。

org.springframework.web.method.HandlerMethod：类，springframework的@Controller中带有@RequestMapping的方法默认为此类的handler。

 

HandlerExecutionChain

对Handler的进一步封装，将一个handler及与该handler相关的各interceptor封装在一起。

 

HandlerAdapter

具体执行handler方法者，DispatcherServlet会根据handler的类型交由相应的handler adapter执行。

默认的HandlerAdapter类型

默认会添加三个HandlerAdapter到application context：

class org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter，处理interface org.springframework.web.HttpRequestHandler类型的handler

class org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter，处理interface org.springframework.web.servlet.mvc.Controller类型的handler

class org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter，处理class org.springframework.web.method.HandlerMethod类型的handler，@Controller中的handler通过此adapter处理。

@ControllerAdvice + RequestBodyAdvice/ResponseBodyAdvice/@ModelAttribute/@InitBinder 的全局处理功能也是由RequestMappingHandlerAdapter来实现的。详情可参阅：https://blog.csdn.net/andy_zhang2007/article/details/100041219

handler方法的执行过程

（参阅：https://blog.csdn.net/andy_zhang2007/article/details/99689573）

Spring MVC中，一般来讲，控制器指的是开发人员使用了注解@Controller这样的类，而控制器方法，是控制器类中使用了注解@RequestMapping的那些方法。控制器方法能处理哪些请求，就是通过这些@RequestMapping注解信息来定义的，DispatcherServlet会把这些信息加载保存到一个RequestMappingHandlerMapping对象中，当相应的请求到达时，DispatcherServlet会通过该信息找到相应的控制器方法，然后通过调用RequestMappingHandlerAdapter执行控制器方法，完成对请求的处理。

handler方法的执行逻辑主要在RequestMappingHandlerAdapter中。

1 RequestMappingHandlerAdapter整体处理流程的相关源码：

// RequestMappingHandlerAdapter 代码片段
    // 返回值是一个 ModelAndView
    // 如果需要调用者后续解析和渲染视图，则该返回值 ModelAndView 不会为 null
    // 如果请求已经被该方法完全处理，不需要调用者后续解析和渲染视图，则返回值 ModelAndView 会是 null
    @Nullable
    protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
            HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

       // 将  HttpServletRequest/HttpServletResponse 对象包装成一个 ServletWebRequest 对象
        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        try {
          // 准备工作，设置调用控制器方法所需要的各种数据，或者工具组件
            WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
            ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

           // 将目标控制器方法 handlerMethod 包装成一个 ServletInvocableHandlerMethod，
           // 这里主要是针对 Servlet 环境的一些特殊处理和包装，参数传递
            ServletInvocableHandlerMethod invocableMethod =
                createInvocableHandlerMethod(handlerMethod);
            if (this.argumentResolvers != null) {
                invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
            }
            if (this.returnValueHandlers != null) {
                invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
            }
            invocableMethod.setDataBinderFactory(binderFactory);
            invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

          // ModelAndViewContainer 是一个调用目标控制器方法过程中，记录参数解析，返回值处理的一些
          // 决策信息的一个容器类型/持有器类型，这里准备出这样一个对象，供控制器方法调用过程中使用
            ModelAndViewContainer mavContainer = new ModelAndViewContainer();
          // 将请求中可能存在的 FlashMap 属性添加到 mavContainer
            mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
          // 1. 获取所有 @SessionAttributes 属性到   mavContainer
          // 2. 执行所有 @ModelAttribute 方法
          // 3. 找到所有使用了注解 @ModelAttribute 并且也属于 @SessionAttributes 列表的
          //    参数将其添加到 mavContainer
            modelFactory.initModel(webRequest, mavContainer, invocableMethod);
          // 设置重定向时如果 RedirectAttributes 属性未设置，是否要使用缺省 Model，
          // 缺省值为 false， 表示即使重定向时 RedirectAttributes 属性未设置，也不要使用缺省 Model
            mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

          // 对异步Web请求的处理的准备工作，本系列文章中只介绍同步请求处理，所以这里忽略对这一部分的介绍
            AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
            asyncWebRequest.setTimeout(this.asyncRequestTimeout);

            WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
            asyncManager.setTaskExecutor(this.taskExecutor);
            asyncManager.setAsyncWebRequest(asyncWebRequest);
            asyncManager.registerCallableInterceptors(this.callableInterceptors);
            asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

            if (asyncManager.hasConcurrentResult()) {
                Object result = asyncManager.getConcurrentResult();
                mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
                asyncManager.clearConcurrentResult();
                LogFormatUtils.traceDebug(logger, traceOn -> {
                    String formatted = LogFormatUtils.formatValue(result, !traceOn);
                    return "Resume with async result [" + formatted + "]";
                });
                invocableMethod = invocableMethod.wrapConcurrentResult(result);
            }


          // 万事俱备，现在执行目标控制器方法，从此入口进去，会看到具体执行过程的更多步骤逻辑，
          // 这里也是我们将要展开介绍的地方
            invocableMethod.invokeAndHandle(webRequest, mavContainer);
            if (asyncManager.isConcurrentHandlingStarted()) {
                return null;
            }

          // 目标控制器方法执行完结，请求处理已经完成，执行过程中的各种决定信息都记录在了
          // mavContainer 中，现在结合相关组件构造一个 ModelAndView 对象，后续调用者
          // 有可能还有基于这些信息解析和渲染视图
          // 如果控制器方法已经完全处理了该请求，无需后续处理，则 mavContainer 会包含
          // 这样的信息 : #isRequestHandled == true, 从而这里的 ModelAndView 返回值
          // 会是 null
            return getModelAndView(mavContainer, modelFactory, webRequest);
        }
        finally {
            webRequest.requestCompleted();
        }
    }

2 RequestMappingHandlerAdapter中会初始化参数解析、参数绑定、返回值解析相关的默认解析器。用户也可以在此添加自己的解析器。分别把它们封装成一个Composite，相关源码：

    // RequestMappingHandlerAdapter 代码片段
    // RequestMappingHandlerAdapter 的初始化方法
    @Override
    public void afterPropertiesSet() {
        // Do this first, it may add ResponseBody advice beans
        initControllerAdviceCache();

        if (this.argumentResolvers == null) {
            // 获取缺省的 HandlerMethodArgumentResolver， 多个
            List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
            // 构造 HandlerMethodArgumentResolverComposite 对象，
            // 包装缺省的多个 HandlerMethodArgumentResolver
            this.argumentResolvers = 
                new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
        }
        if (this.initBinderArgumentResolvers == null) {
            List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
            this.initBinderArgumentResolvers = 
                new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
        }
        if (this.returnValueHandlers == null) {
            List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
            this.returnValueHandlers = 
                new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
        }
    }

3 主要处理过程包括：

创建ModelAndViewContainer对象

该对象用于记录执行handler方法需要的各种决定信息，包括参数、返回值解析器等，这些执行决定信息最终用于生成调用者用于解析和渲染视图所需的ModelAndView对象。

请求实参值的获取

这里的参数可能是url参数、header参数、cookie参数、session参数、body参数等，既可以是简单数据也可以是json/矩阵等结构化数据。主要逻辑在：RequestMappingHandlerAdapter#invokeHandlerMethod==> ServletInvocableHandlerMethod#invokeAndHandle ==> InvocableHandlerMethod#invokeForRequest ==> getMethodArgumentValues，相关源码：

    protected Object[] getMethodArgumentValues(NativeWebRequest request, 
                                    @Nullable ModelAndViewContainer mavContainer,
                                    Object... providedArgs) throws Exception {

       // getMethodParameters 返回的是控制器方法的参数列表，
       // 如果该参数列表为空，直接返回 EMPTY_ARGS :  new Object[0]       
        if (ObjectUtils.isEmpty(getMethodParameters())) {
            return EMPTY_ARGS;
        }
        
       // 控制器方法参数列表不为空的情况 
        MethodParameter[] parameters = getMethodParameters();
        
       // 构建对象数组 args，让其元素个数跟控制器方法参数个数相同，因为这个对象数组
       // 是用来保存相应参数的参数值的
       // 这个对象数组 args 会被下面的代码逻辑填充，然后被作为实参调用目标控制器方法
        Object[] args = new Object[parameters.length];
        
       // 从左至右逐个遍历每个控制器方法参数，从请求上下文中获取相应的参数值放到args相应的位置 
        for (int i = 0; i < parameters.length; i++) {
          // 一次 for 循环完成一个控制器方法参数的参数值解析逻辑
          
          
          // 获取控制器方法第 i 个参数
            MethodParameter parameter = parameters[i];
          //  设置方法参数名称发现器，缺省会是 DefaultParameterNameDiscoverer，
          // 方法参数名称发现器用于发现该参数的名称，该名称用于从请求上下文中分析该参数的参数值
            parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
          //  首先尝试  从 providedArgs 中获取该参数的参数值，
          // Spring MVC 默认情况下 providedArgs 总是为空，所以这里关于应用 providedArgs 的
          // 逻辑默认总是空转，不产生实际效果
            args[i] = findProvidedArgument(parameter, providedArgs);
            if (args[i] != null) {
              // 如果通过 providedArgs 应用参数值成功则表示该参数参数值解析成功，跳过
              // 随后逻辑继续下一个参数的参数值解析逻辑
                continue;
            }
           
           // this.resolvers 是调用者 RequestMappingHandlerAdapter 设置给当前对象的
           // 多个参数解析器的组合对象 HandlerMethodArgumentResolverComposite,
           
           // 检测当前参数是否被 this.resolvers 支持，如果不支持则抛出异常
            if (!this.resolvers.supportsParameter(parameter)) {
                throw new IllegalStateException(formatArgumentError(parameter, 
                                                        "No suitable resolver"));
            }
            
           // 当前参数经过检测被 this.resolvers 支持，现在尝试使用 this.resolvers 从请求上下文中分析其值，
           // 注意，this.resolvers 检测某个参数是否被支持的逻辑通常仅仅考虑参数的某些特征 ： 比如数据类型
           // 等等，所以一个参数被支持，并不代表它的值能被正确解析，因为数据的内容或者格式有可能在解析时会
           // 遇到问题。
           // 下面的 try-catch 就是处理这种参数值解析过程中遇到的异常的。
            try {
                args[i] = this.resolvers.resolveArgument(parameter, mavContainer, 
                            request, this.dataBinderFactory);
            }
            catch (Exception ex) {
                // Leave stack trace for later, exception may actually be resolved and handled..
                if (logger.isDebugEnabled()) {
                    String error = ex.getMessage();
                    if (error != null 
                        && !error.contains(parameter.getExecutable().toGenericString())) {
                        logger.debug(formatArgumentError(parameter, error));
                    }
                }
                throw ex;
            }
        }
        
       // 现在针对每个控制器方法的参数值已经被解析到对象数组中 args 了， 返回该对象数组，
       // 下一步就是使用这些实参对象调用目标控制器方法了。
        return args;
    }

handler方法实参值的解析和绑定 HandlerMethodArgumentResolver

实际直接用的是HandlerMethodArgumentResolverComposite（这点原理上与HandleExceptionResolverComposite类似）：在RequestMappingHandlerAdapter初始化时，会构建一个HandlerMethodArgumentResolverComposite对象，该对象是多个HandlerMethodArgumentResolver的一个集合。使用时遍历这些集合以寻找第一个能处理参数的resolver来处理参数。相关逻辑源码见上面的初始化代码。

SpringMVC框架提供了很多MethodArgumentResolver的实现类来解析和绑定各种类型的请求参数：

通常我们可以在handler方法中直接声明HttpServletRequest、HttpSession、InputStream等参数，框架会在收到请求时自动解析参数传给我们的handler方法，其背后就是 ServletRequestMethodArgumentResolver 起的作用。Handler方法中支持的参数如上表所示，关于这些参数的具体含义或使用，可参阅：https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/web.html#mvc-ann-arguments

默认会添加若干HandlerMethodArgumentResolver，相关源码：

    /**
     * Return the list of argument resolvers to use including built-in resolvers
     * and custom resolvers provided via {@link #setCustomArgumentResolvers}.
     */
    private List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
        List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();

        // Annotation-based argument resolution
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
        resolvers.add(new RequestParamMapMethodArgumentResolver());
        resolvers.add(new PathVariableMethodArgumentResolver());
        resolvers.add(new PathVariableMapMethodArgumentResolver());
        resolvers.add(new MatrixVariableMethodArgumentResolver());
        resolvers.add(new MatrixVariableMapMethodArgumentResolver());
        resolvers.add(new ServletModelAttributeMethodProcessor(false));
        resolvers.add(new RequestResponseBodyMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
        resolvers.add(new RequestPartMethodArgumentResolver(getMessageConverters(), this.requestResponseBodyAdvice));
        resolvers.add(new RequestHeaderMethodArgumentResolver(getBeanFactory()));
        resolvers.add(new RequestHeaderMapMethodArgumentResolver());
        resolvers.add(new ServletCookieValueMethodArgumentResolver(getBeanFactory()));
        resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
        resolvers.add(new SessionAttributeMethodArgumentResolver());
        resolvers.add(new RequestAttributeMethodArgumentResolver());

        // Type-based argument resolution
        resolvers.add(new ServletRequestMethodArgumentResolver());
        resolvers.add(new ServletResponseMethodArgumentResolver());
        resolvers.add(new HttpEntityMethodProcessor(getMessageConverters(), this.requestResponseBodyAdvice));
        resolvers.add(new RedirectAttributesMethodArgumentResolver());
        resolvers.add(new ModelMethodProcessor());
        resolvers.add(new MapMethodProcessor());
        resolvers.add(new ErrorsMethodArgumentResolver());
        resolvers.add(new SessionStatusMethodArgumentResolver());
        resolvers.add(new UriComponentsBuilderMethodArgumentResolver());

        // Custom arguments
        if (getCustomArgumentResolvers() != null) {
            resolvers.addAll(getCustomArgumentResolvers());
        }

        // Catch-all
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));
        resolvers.add(new ServletModelAttributeMethodProcessor(true));

        return resolvers;
    }





    /**
     * Return the list of argument resolvers to use for {@code @InitBinder}
     * methods including built-in and custom resolvers.
     */
    private List<HandlerMethodArgumentResolver> getDefaultInitBinderArgumentResolvers() {
        List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();

        // Annotation-based argument resolution
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), false));
        resolvers.add(new RequestParamMapMethodArgumentResolver());
        resolvers.add(new PathVariableMethodArgumentResolver());
        resolvers.add(new PathVariableMapMethodArgumentResolver());
        resolvers.add(new MatrixVariableMethodArgumentResolver());
        resolvers.add(new MatrixVariableMapMethodArgumentResolver());
        resolvers.add(new ExpressionValueMethodArgumentResolver(getBeanFactory()));
        resolvers.add(new SessionAttributeMethodArgumentResolver());
        resolvers.add(new RequestAttributeMethodArgumentResolver());

        // Type-based argument resolution
        resolvers.add(new ServletRequestMethodArgumentResolver());
        resolvers.add(new ServletResponseMethodArgumentResolver());

        // Custom arguments
        if (getCustomArgumentResolvers() != null) {
            resolvers.addAll(getCustomArgumentResolvers());
        }

        // Catch-all
        resolvers.add(new RequestParamMethodArgumentResolver(getBeanFactory(), true));

        return resolvers;
    }

在为每个形参查找参数解析器时会按照添加顺序寻找第一个support解析该参数的resolver。

实参值解析和绑定的实现——以AbstractNamedValueMethodArgumentResolver为例，很多上述Resolver是此的子类。相关源码：

package org.springframework.web.method.annotation;

// 省略 import 行


public abstract class AbstractNamedValueMethodArgumentResolver 
                        implements HandlerMethodArgumentResolver {

    // 记录当前 Spring IoC 容器
    @Nullable
    private final ConfigurableBeanFactory configurableBeanFactory;

    // 使用bean定义进行表达式求值的上下文对象
    @Nullable
    private final BeanExpressionContext expressionContext;

    // 用于缓存找到的命名值信息
    private final Map<MethodParameter, NamedValueInfo> namedValueInfoCache 
            = new ConcurrentHashMap<>(256);


    public AbstractNamedValueMethodArgumentResolver() {
        this.configurableBeanFactory = null;
        this.expressionContext = null;
    }

    /**
     * Create a new {@link AbstractNamedValueMethodArgumentResolver} instance.
     * @param beanFactory a bean factory to use for resolving ${...} placeholder
     * and #{...} SpEL expressions in default values, or {@code null} if default
     * values are not expected to contain expressions
     */
    public AbstractNamedValueMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory) {
        this.configurableBeanFactory = beanFactory;
       // 初始化使用bean定义进行表达式求值的上下文对象
       // 仅在  this.configurableBeanFactory 被设置为非 null 时真正做初始化
        this.expressionContext =
                (beanFactory != null 
                            ? new BeanExpressionContext(beanFactory, new RequestScope()) 
                            : null);
    }


    // 接口 HandlerMethodArgumentResolver 所定义的方法，解析参数
    // 1. parameter 是要解析参数值的控制器方法参数
    // 2. mavContainer 是一个容器对象，用来保存控制器方法执行过程中各种决定信息，本方法并未使用它
    // 3. webRequest 包装了当前请求对象和响应对象，并且能返回 Servlet 规范定义的请求和响应对象
    // 4. binderFactory 是 数据绑定器工厂，用于生成数据绑定器，
    @Override
    @Nullable
    public final Object resolveArgument(MethodParameter parameter, 
                    @Nullable ModelAndViewContainer mavContainer,
                    NativeWebRequest webRequest, 
                    @Nullable WebDataBinderFactory binderFactory) throws Exception {

       // 获取指定控制器方法参数  parameter 命名值描述信息 namedValueInfo
        NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
        MethodParameter nestedParameter = parameter.nestedIfOptional();

       //  namedValueInfo.name 是参数的名称字符串，不过该字符串可能是个表达式，需要进一步解析为
       // 最终的参数名称，下面的 resolveStringValue 语句就是对该名字进行表达式求值，从而得到解析后的
       // 控制器方法参数名称，此名称是从请求上下文中获取相应参数值的关键信息 
        Object resolvedName = resolveStringValue(namedValueInfo.name);
        if (resolvedName == null) {
           // 异常处理
            throw new IllegalArgumentException(
                    "Specified name must not resolve to null: [" + namedValueInfo.name + "]");
        }

       // 根据控制器方法参数名称从请求上下文中尝试分析得到该参数的参数值 
        Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
        if (arg == null) {
          // 没能从请求上下文中分析得到参数值的分支 ，也就是 arg 为 null 的情况
            if (namedValueInfo.defaultValue != null) {
               // 对该参数指定了缺省值的情况 
              // 尝试应用缺省值,缺省值通过对 namedValueInfo.defaultValue 进行表达式求值得到
                arg = resolveStringValue(namedValueInfo.defaultValue);
            }
            else if (namedValueInfo.required && !nestedParameter.isOptional()) {             
             // 没能从请求上下文中分析得到参数值，并且没有指定缺省值， 并且被指定为必要参数的情况的处理
             // 也可以概括为必要参数的值缺失情况的处理
             // 参考注解 @RequestParam 的属性 required
             // AbstractNamedValueMethodArgumentResolver  这里的缺省实现是抛出异常 :
             // ServletRequestBindingException
                handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
            }
          
          // 对 null 参数值的处理 :
          // 1. 如果参数类型为 Boolean 或者 boolean, 则 null 被理解成 Boolean.FALSE ;
          // 2. 如果参数类型为其他 Java 基本数据类型，则抛出异常 IllegalStateException,
          //  因为一个除了 boolean 之外的其他基本数据类型，是无法接受一个 null 值的 ;
            arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
        }
        else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
          // arg 为0长度字符串并且有缺省值可以应用的情况的处理  
            arg = resolveStringValue(namedValueInfo.defaultValue);
        }

       // 现在， arg 变量值是经过各种解析将要应用到相应控制器方法参数的参数值,
       // 但是，从请求上下文中分析得到的 arg 通常是字符串类型，该类型跟目标控制器方法参数的类型
       // 通常都是不同的，所以现在需要尝试从值 arg 转换得到目标控制器方法参数类型的对象，
       // 例子 :
       // 1. arg 为字符串 "1" , 目标类型为 int, 则转换后的 arg 会是整数 1
       // 2. arg 为字符串 "test", 目标类型为 int, 则转换失败，抛出异常 TypeMismatchException       

        if (binderFactory != null) {
          // 使用 binderFactory 数据绑定工厂创建数据绑定器，用于数据类型的转换
            WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
          // 尝试转换并捕捉相应的异常  
            try {
                arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
            }
            catch (ConversionNotSupportedException ex) {
              // 源类型 和 目标类型之间没有合适的转换器
                throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(),
                        namedValueInfo.name, parameter, ex.getCause());
            }
            catch (TypeMismatchException ex) {
              // 源类型 和 目标类型之间有合适的转换器，但是转换动作执行失败，通常是源类型数据格式出了问题，
              // 或者数据提供方和数据接收方在该种格式数据接收格式的沟通上出了问题
                throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(),
                        namedValueInfo.name, parameter, ex.getCause());

            }
        }

       // 上面是从请求中分析得到的参数值向目标控制器方法参数进行类型转换的逻辑，如果木有出现异常，
       // 程序执行会走到这里，此时 arg 对象是类型为目标控制器方法参数类型的对象，该值可以应用到
       // 目标方法参数了。
      // 在将 arg 返回给调用者真正应用到目标方法参数之前，当前对象还可以通过 handleResolvedValue
      // 方法对 arg 做一番调整。不过在抽象类 AbstractNamedValueMethodArgumentResolver 中，
      // 此方法是一个空方法，也就是不做任何调整，但是具体实现子类可以覆盖实现该方法实现自己的逻辑。
        handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);

       // 从请求上下文中分析参数值，应用缺省值，处理 null 值，源类型到目标类型的类型转换都已经做完了,
       // 大功告成，将此分析得到的参数值 arg 返回给调用者让其继续接下来的后续逻辑
        return arg;
    }

    /**
     * Obtain the named value for the given method parameter.
     */
    private NamedValueInfo getNamedValueInfo(MethodParameter parameter) {
        NamedValueInfo namedValueInfo = this.namedValueInfoCache.get(parameter);
        if (namedValueInfo == null) {
            namedValueInfo = createNamedValueInfo(parameter);
            namedValueInfo = updateNamedValueInfo(parameter, namedValueInfo);
            this.namedValueInfoCache.put(parameter, namedValueInfo);
        }
        return namedValueInfo;
    }

    /**
     * Create the {@link NamedValueInfo} object for the given method parameter. 
     * Implementations typically retrieve the method annotation by means of 
     * {@link MethodParameter#getParameterAnnotation(Class)}.
     * @param parameter the method parameter
     * @return the named value information
     */
    protected abstract NamedValueInfo createNamedValueInfo(MethodParameter parameter);

    /**
     * Create a new NamedValueInfo based on the given NamedValueInfo with sanitized values.
     */
    private NamedValueInfo updateNamedValueInfo(MethodParameter parameter, NamedValueInfo info) {
        String name = info.name;
        if (info.name.isEmpty()) {
            name = parameter.getParameterName();
            if (name == null) {
                throw new IllegalArgumentException(
            "Name for argument type [" + parameter.getNestedParameterType().getName() +
            "] not available, and parameter name information not found in class file either.");
            }
        }
        String defaultValue = (ValueConstants.DEFAULT_NONE.equals(info.defaultValue) 
                    ? null 
                    : info.defaultValue);
        return new NamedValueInfo(name, info.required, defaultValue);
    }

    /**
     * Resolve the given annotation-specified value,
     * potentially containing placeholders and expressions.
     */
    @Nullable
    private Object resolveStringValue(String value) {
        if (this.configurableBeanFactory == null) {
            return value;
        }
        String placeholdersResolved = this.configurableBeanFactory.resolveEmbeddedValue(value);
        BeanExpressionResolver exprResolver = 
                this.configurableBeanFactory.getBeanExpressionResolver();
        if (exprResolver == null || this.expressionContext == null) {
            return value;
        }
        return exprResolver.evaluate(placeholdersResolved, this.expressionContext);
    }

    /**
     * Resolve the given parameter type and value name into an argument value.
     * @param name the name of the value being resolved
     * @param parameter the method parameter to resolve to an argument value
     * (pre-nested in case of a {@link java.util.Optional} declaration)
     * @param request the current request
     * @return the resolved argument (may be {@code null})
     * @throws Exception in case of errors
     */
    @Nullable
    protected abstract Object resolveName(String name, MethodParameter parameter, 
                                        NativeWebRequest request)
                                        throws Exception;

    /**
     * Invoked when a named value is required, but {@link #resolveName(String, MethodParameter, 
     * NativeWebRequest)}
     * returned {@code null} and there is no default value. Subclasses typically throw an exception
     *  in this case.
     * @param name the name for the value
     * @param parameter the method parameter
     * @param request the current request
     * @since 4.3
     */
    protected void handleMissingValue(String name, MethodParameter parameter, 
            NativeWebRequest request) throws Exception {

        handleMissingValue(name, parameter);
    }

    /**
     * Invoked when a named value is required, but {@link #resolveName(String, MethodParameter, 
     * NativeWebRequest)}
     * returned {@code null} and there is no default value. Subclasses typically throw an exception 
     * in this case.
     * @param name the name for the value
     * @param parameter the method parameter
     */
    protected void handleMissingValue(String name, MethodParameter parameter) 
            throws ServletException {
        throw new ServletRequestBindingException("Missing argument '" + name +
            "' for method parameter of type " + parameter.getNestedParameterType().getSimpleName());
    }

    /**
     * A {@code null} results in a {@code false} value for {@code boolean}s or an exception 
     * for other primitives.
     */
    @Nullable
    private Object handleNullValue(String name, @Nullable Object value, Class<?> paramType) {
        if (value == null) {
            if (Boolean.TYPE.equals(paramType)) {
                return Boolean.FALSE;
            }
            else if (paramType.isPrimitive()) {
    throw new IllegalStateException("Optional " + paramType.getSimpleName() 
    + " parameter '" + name +
    "' is present but cannot be translated into a null value due to being declared as a " +
    "primitive type. Consider declaring it as object wrapper for the corresponding primitive type.");
            }
        }
        return value;
    }

    /**
     * Invoked after a value is resolved.
     * @param arg the resolved argument value
     * @param name the argument name
     * @param parameter the argument parameter type
     * @param mavContainer the {@link ModelAndViewContainer} (may be {@code null})
     * @param webRequest the current request
     */
    protected void handleResolvedValue(@Nullable Object arg, String name, MethodParameter parameter,
            @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest) {
            // 对解析后的参数值进行处理
            // 当前实现是一个空方法，不过具体实现子类可以覆盖实现该方法以实现逻辑定制
    }


    /**
     * Represents the information about a named value, including name, whether it's required and
     *  a default value.
     * 一个关于命名值的元数据描述类,包含如下信息 ： 
     * 1. 原始命名字符串(可能是一个需要求值的表达式)
     * 2. 该参数是否必要
     * 3. 该参数的参数值缺失时要应用的缺省值字符串
     */
    protected static class NamedValueInfo {

        private final String name;

        private final boolean required;

        @Nullable
        private final String defaultValue;

        public NamedValueInfo(String name, boolean required, @Nullable String defaultValue) {
            this.name = name;
            this.required = required;
            this.defaultValue = defaultValue;
        }
    }

}

handler方法参数值的验证 MethodValidationInterceptor

RequestMappingHandlerAdapter#invokeHandlerMethod==> ServletInvocableHandlerMethod#invokeAndHandle ==> InvocableHandlerMethod#invokeForRequest==> InvocableHandlerMethod#doInvoke 方法里调用目标hanlder方法，相关源码：

    @Nullable
    protected Object doInvoke(Object... args) throws Exception {
       // 确保目标控制器方法是可以访问的 
        ReflectionUtils.makeAccessible(getBridgedMethod());
        try {
           // 调用目标控制器方法 
            return getBridgedMethod().invoke(getBean(), args);
        }
        catch (IllegalArgumentException ex) {
           // 抛出参数格式错误导致的异常 
            assertTargetBean(getBridgedMethod(), getBean(), args);
            String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
            throw new IllegalStateException(formatInvokeError(text, args), ex);
        }
        catch (InvocationTargetException ex) {
            // Unwrap for HandlerExceptionResolvers ...
          // 对 InvocationTargetException 异常的处理
            Throwable targetException = ex.getTargetException();
            if (targetException instanceof RuntimeException) {
                throw (RuntimeException) targetException;
            }
            else if (targetException instanceof Error) {
                throw (Error) targetException;
            }
            else if (targetException instanceof Exception) {
                throw (Exception) targetException;
            }
            else {
                throw new IllegalStateException(formatInvokeError("Invocation failure", args), targetException);
            }
        }
    }

若控制器类或handler方法使用了参数验证功能（@Validated、@Valid、@Min等），则getBean获取到的将是目标对象的代理对象（代理对象通过AOP产生，相关逻辑在MethodValidationPostProcessor），该代理对象是MethodValidationInterceptor的实例，会在调用目标handler前后进行参数、返回值的验证。相关源码：

    @Override
    @SuppressWarnings("unchecked")
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // Avoid Validator invocation on FactoryBean.getObjectType/isSingleton
        if (isFactoryBeanMetadataMethod(invocation.getMethod())) {
            return invocation.proceed();
        }

        Class<?>[] groups = determineValidationGroups(invocation);

        // Standard Bean Validation 1.1 API
        ExecutableValidator execVal = this.validator.forExecutables();
        Method methodToValidate = invocation.getMethod();
        Set<ConstraintViolation<Object>> result;

        try {
            result = execVal.validateParameters(
                    invocation.getThis(), methodToValidate, invocation.getArguments(), groups);
        }
        catch (IllegalArgumentException ex) {
            // Probably a generic type mismatch between interface and impl as reported in SPR-12237 / HV-1011
            // Let's try to find the bridged method on the implementation class...
            methodToValidate = BridgeMethodResolver.findBridgedMethod(
                    ClassUtils.getMostSpecificMethod(invocation.getMethod(), invocation.getThis().getClass()));
            result = execVal.validateParameters(
                    invocation.getThis(), methodToValidate, invocation.getArguments(), groups);
        }
        if (!result.isEmpty()) {
            throw new ConstraintViolationException(result);
        }

        Object returnValue = invocation.proceed();

        result = execVal.validateReturnValue(invocation.getThis(), methodToValidate, returnValue, groups);
        if (!result.isEmpty()) {
            throw new ConstraintViolationException(result);
        }

        return returnValue;
    }

调用handler方法本身

上述 InvocableHandlerMethod#doInvoke中，getBridgedMethod().invoke(getBean(), args) 调用会先触发层层方法拦截器，没有拦截逻辑异常或者其他分支的情况下，目标控制器方法会被最终调用。

handler方法返回值处理

与前面的参数解析绑定类似，由组合了多个HandlerMethodReturnValueHandler实现类对象的HandlerMethodReturnValueHandlerComposite对象完成返回值处理工作。相关源码：

  // ServletInvocableHandlerMethod 代码片段
    /**
     * Invoke the method and handle the return value through one of the
     * configured {@link HandlerMethodReturnValueHandler HandlerMethodReturnValueHandlers}.
     * @param webRequest the current request
     * @param mavContainer the ModelAndViewContainer for this request
     * @param providedArgs "given" arguments matched by type (not resolved)
     */
    public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

       // 调用目标控制器方法，这一过程主要做了以下两件事情 ：
       // 1. 从请求分析参数值并转换成可用于目标控制器方法的结构和类型
       // 2. 调用开发人员提供的目标控制器方法
        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
       // 现在 returnValue 是目标控制器方法执行的返回结果，之所以使用 Object 类型接收，
       // 是因为框架并不清楚开发人员会设计什么样的返回类型
       
       // 获取控制器方法上的注解 @ResponseStatus 信息，注解 @ResponseStatus 会有两个属性 :
       // status 和 reason，这里就是参考这两个属性对响应对象做处理 ：
       // 情况1 : status 不为 null, reason 有内容(不为null,也不为空字符串), response.setStatus(status)
       // 情况2 : status 不为 null, reason 无内容(为null，或者空字符串), response.sendError(status,reason)
       // 这两种情况下也会设置请求属性 : <RESPONSE_STATUS_ATTRIBUTE,status>, 重定向的话会使用该信息。
       // 该过程并没有基于 returnValue 的任何动作。
       // 如果 status 为 null ，可以认为这一步什么都没做
        setResponseStatus(webRequest);


       // 开始基于结合 @ResponseStatus 注解和返回值 returnValue 进行处理的逻辑       
        if (returnValue == null) {
           // 控制器方法的返回值是 null 
            if (isRequestNotModified(webRequest) 
                || getResponseStatus() != null 
                || mavContainer.isRequestHandled()) {
             // 针对如下三种情况组合标记请求已经被完全处理 并且 当前方法返回 :
             // 1. 目标控制器方法无返回值 + 请求资源没有改变
             // 2. 目标控制器方法无返回值 + 目标控制器方法注解  @ResponseStatus 属性 status 不为 null
             // 3. 目标控制器方法无返回值 + mavContainer 中请求处理完成标记已经被设置
                mavContainer.setRequestHandled(true);
                return;
            }
        }
        else if (StringUtils.hasText(getResponseStatusReason())) {
          // 目标控制器方法有返回值 +  目标控制器方法注解  @ResponseStatus 属性 reason 有内容
          // 这种情况下也将请求标记为已经处理完成，并且 当前方法返回
            mavContainer.setRequestHandled(true);
            return;
        }

       //  结合 @ResponseStatus 注解和返回值 returnValue  考虑之后，发现需要进一步处理返回值,
       // 此时先将请求标记为尚未处理完成，然后使用 this.returnValueHandlers 进行处理
       
       // 将请求处理完成标记设置为 false
        mavContainer.setRequestHandled(false);
       // 断言 this.returnValueHandlers 不能为空，因为接下来要处理返回值的动作需要使用到它们        
        Assert.state(this.returnValueHandlers != null, "No return value handlers");
        try {
          // this.returnValueHandlers 是一个 HandlerMethodReturnValueHandlerComposite 对象
            this.returnValueHandlers.handleReturnValue(
                    returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        }
        catch (Exception ex) {
            if (logger.isTraceEnabled()) {
                logger.trace(formatErrorForReturnValue(returnValue), ex);
            }
            throw ex;
        }
    }

同样地，SpringMVC框架提供了很多HandlerMethodReturnValueHandler的实现类来处理返回值：

包装返回结果 : 从ModelAndViewContainer对象构造ModelAndView对象

前面整体流程 RequestMappingHandlerAdapter#invodeHandlerMethod 中最后调用 RequestMappingHandlerAdapter#getModelAndView 方法，后者的相关源码：

    @Nullable
    private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,
            ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {

        modelFactory.updateModel(webRequest, mavContainer);
        if (mavContainer.isRequestHandled()) {
           // 如果  mavContainer.isRequestHandled() 为真，说明上一篇中介绍的逻辑已经将请求处理完了，
           // 所以这里返回 null，这里的返回 null 有两点意思需要指明 :
           // 1. 当前方法以下构造 ModelAndView 的主逻辑相当于不用执行了;
           // 2. 遇到 null ModelAndView，调用者会认为请求已经处理完成，不会再继续处理该请求;
            return null;
        }
        
        // 逻辑能走到这里的话，说明之前的处理逻辑并未将请求处理完成，所以现在需要根据之前的执行结果
        // 构造 ModelAndView 对象，这是留给调用者 DispatcherServlet 用于解析和渲染视图的数据载体。
        ModelMap model = mavContainer.getModel();
        ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
        if (!mavContainer.isViewReference()) {
            mav.setView((View) mavContainer.getView());
        }
        if (model instanceof RedirectAttributes) {
          // 针对重定向情况的调整  
            Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
            HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
            if (request != null) {
                RequestContextUtils.getOutputFlashMap(request).putAll(flashAttributes);
            }
        }
        return mav;
    }

ServletInvocableHandlerMethod#invokeAndHandle对hanlder返回值处理过程中，若基于上下文和组件认为请求处理已经完成，则会将mavContainer.requestHandled属性设置为true，否则设为false以将控制权交给调用者，继续请求处理过程。可见，当为false时，这里会创建ModelAndView对象，以供上层DispatcherServlet进行视图解析和渲染。

 

 

HandlerMapping

接口，用于定义request和handler间的对应关系，将依据此确定request由哪个handler处理。springframework默认有两种HandlerMapping的实现方式，当application context中没有HandlerMapping Bean时默认采用前者，但实际上通常会将后者注册为Bean。

BeanNameUrlHandlerMapping：map from URLs to beans with names that start with a slash ("/")，即将url映射到与url同名的Bean上

RequestMappingHandlerMapping：Creates RequestMappingInfo instances from type and method-level @RequestMapping annotations in @Controller classes，即建立url与handler间的对应关系。默认为此。

在程序启动时springframework会自动扫描并建立该对应关系。对应关系的建立过程分析可参阅：https://blog.csdn.net/andy_zhang2007/article/details/99414968

可以重写该类的方法来自定义关联规则，如当前项目引入其他项目的Feign Client时被引项目的handler也会被当前项目的HandlerMapping识别成当前项目的接口，可通过重写规避：

@Configuration
@ConditionalOnClass({ Feign.class })
public class FeignConfiguration {// 解决@FeignClient中的@RequestMapping也被当前项目识别成Handler的问题

    @Bean
    public WebMvcRegistrations feignWebRegistrations() {
        return new WebMvcRegistrations() {
            @Override
            public RequestMappingHandlerMapping getRequestMappingHandlerMapping() {
                return new FeignRequestMappingHandlerMapping();
            }
        };
    }

    private static class FeignRequestMappingHandlerMapping extends RequestMappingHandlerMapping {
        @Override
        protected boolean isHandler(Class<?> beanType) {
            return super.isHandler(beanType) && !AnnotatedElementUtils.hasAnnotation(beanType, FeignClient.class);
        }
    }
}

  

DispatcherServlet

（官方文档：https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/web.html#mvc-servlet-sequence）

继承HttpServlet，传统java Servlet项目中每个文件为一个Servlet，而这里一个DispatcherServlet类作为一个Servlet，起网关的作用，路由到与请求url相应的handler。

详细逻辑可参阅其doDispatch方法，相关源码：

    /**
     * Process the actual dispatching to the handler.
     * The handler will be obtained by applying the servlet's HandlerMappings in order.
     * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
     * to find the first that supports the handler class.
     * All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
     * themselves to decide which methods are acceptable.
     * @param request current HTTP request
     * @param response current HTTP response
     * @throws Exception in case of any kind of processing failure
     */
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) 
        throws Exception {
        HttpServletRequest processedRequest = request;
        // 用于记录针对该请求的请求处理器 handler 以及有关的 HandlerInteceptor , 封装成一个 
        // HandlerExecutionChain, 在随后的逻辑中会被使用
        HandlerExecutionChain mappedHandler = null;
        // 用于标记当前请求是否是一个文件上传请求
        boolean multipartRequestParsed = false;

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

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

            try {
                // 检查请求是否文件上传请求  
                processedRequest = checkMultipart(request);
                // 如果 processedRequest 和  request 不同，说明检测到了文件上传请求过程中
                // 才会出现的内容，现在把这个信息记录在 multipartRequestParsed
                multipartRequestParsed = (processedRequest != request);

                // Determine handler for the current request.
                // 这里根据请求自身，和 DispatcherServlet 的 handlerMappings 查找能够处理该请求的
                // handler, 记录在 mappedHandler , 具体返回的类型是 HandlerExecutionChain ，
                // 相当于 n 个 HandlerInterceptor + 1 个 handler 。
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null) {
                    // 如果没有找到可以处理该请求的 handler ， 这里直接交给 noHandlerFound 处理,
                    // 根据配置决定 抛出异常 或者返回 404
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // Determine handler adapter for the current request.
                // 根据所找到的 handler 和 DispatcherServlet 的 handlerAdapters 看看哪个 handlerAdapter
                // 可以执行这个 handler。
                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 (new ServletWebRequest(request, response).checkNotModified(lastModified) 
                        && isGet) {
                        // 如果是 GET/HEAD 模式，并且发现资源从上次访问到现在没被修改过，则直接返回
                        return;
                    }
                }

                // 执行 mappedHandler 所有 HandlerInteceptor 的 preHandle 方法，
                // 如果有执行失败，在这里直接返回不再继续处理该请求
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // Actually invoke the handler.
                // 现在才真正由所找到的 HandlerAdapter  执行 所对应的 handler,
                // 返回结果是一个 ModelAndView 对象 mv， 或者 null
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

                // 如果上面获取的 ModelAndView 对象 mv 不为 null， 并且没有含有 view，
                // 并且配置了缺省 view，这里应用缺省 view
                applyDefaultViewName(processedRequest, mv);
              
                // 执行 mappedHandler 所有 HandlerInteceptor 的 postHandle 方法，
                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);
            }
            // 处理 handler 结果 ModelAndView mv
            // 1. 根据 view 名称 或者 异常找到最终要使用的 view
            // 2. 渲染 view
            // 3. 执行 mappedHandler 所有 HandlerInteceptor 的 afterCompletion 方法
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            // 异常情况下执行 mappedHandler 所有 HandlerInteceptor 的 afterCompletion 方法
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) {
            // 异常情况下执行 mappedHandler 所有 HandlerInteceptor 的 afterCompletion 方法
            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);
                }
            }
        }
    }

doDispatch主逻辑详细描述（转）：

Spring MVC前置控制器DispatcherServlet对请求进行处理的主要逻辑位于其方法doDispatch,如下 :

1 找到可以处理该请求的 Handler
 找到的 Handler 以 HandlerExecutionChain 形式封装
 任务执行主要代码行 : #getHandler(processedRequest)
 如果没有能处理该请求的 Handler，则抛出异常或者返回404
  任务执行主要代码行 : noHandlerFound(processedRequest, response)

2 找到能执行该 Handler 的 HandlerAdapter 用于调用该Handler
 任务执行主要代码行 : HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler())
 如果没有找到合适的HandlerAdapter,则该方法抛出异常ServletException，带相应信息描述。

3 通过找到的HandlerAdapter 处理相应的请求
 对当前Handler的前置处理
  任务执行主要代码行 : mappedHandler.applyPreHandle(processedRequest, response)
  如果某个HandlerInterceptor#preHandle返回false,则doDispatch调用triggerAfterCompletion然后return
 通过HandlerAdapter真正处理当前Handler
  任务执行主要代码行 : mv = ha.handle(processedRequest, response, mappedHandler.getHandler())
 必要时应用缺省视图
  任务执行主要代码行 : applyDefaultViewName(processedRequest, mv)
 对当前Handler的后置处理
  任务执行主要代码行 : mappedHandler.applyPostHandle(processedRequest, response, mv)

以上流程涉及视图名称的获取和设置，但尚不涉及从视图名称到视图的解析逻辑。
 上面的执行要么成功返回一个ModelAndView mv,要么错误产生异常dispatchException。
 任务执行主要代码行 : processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException)
 如果该任务执行出现异常/错误，则doDispatch会携带相应异常/错误信息调用triggerAfterCompletion并return。

4 处理Handler执行结果
 如果是dispatchException的情况，则根据异常构建相应的一个ModelAndView对象记到mv然后继续。
  exception是ModelAndViewDefiningException的情况直接从其中获取ModelAndView到mv;
  要么调用processHandlerException(request, response, handler, exception)获取一个ModelAndView到mv;
   这里遍历所登记的HandlerExceptionResolver bean尝试从异常解析出相应的ModelAndView对象;
   也可能调用结果为null;
 渲染视图
  任务执行主要代码行 : render(mv, request, response)
  Locale应用设置到response;
  根据视图名称解析视图;
   如果解析不到视图，则抛出异常ServletException携带相应信息描述。
  真正的渲染视图;
   任务执行主要代码行 : view.render(mv.getModelInternal(), request, response)
   redirect/forward处理在这里完成。

https://docs.spring.io/spring-framework/docs/current/spring-framework-reference/web.html#mvc-servlet-sequence

The DispatcherServlet processes requests as follows:

• The WebApplicationContext is searched for and bound in the request as an attribute that the controller and other elements in the process can use. It is bound by default under the DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE key.

• The locale resolver is bound to the request to let elements in the process resolve the locale to use when processing the request (rendering the view, preparing data, and so on). If you do not need locale resolving, you do not need the locale resolver.

• The theme resolver is bound to the request to let elements such as views determine which theme to use. If you do not use themes, you can ignore it.

• If you specify a multipart file resolver, the request is inspected for multiparts. If multiparts are found, the request is wrapped in a MultipartHttpServletRequest for further processing by other elements in the process. See Multipart Resolver for further information about multipart handling.

• An appropriate handler is searched for. If a handler is found, the execution chain associated with the handler (preprocessors, postprocessors, and controllers) is run to prepare a model for rendering. Alternatively, for annotated controllers, the response can be rendered (within the HandlerAdapter) instead of returning a view.

• If a model is returned, the view is rendered. If no model is returned (maybe due to a preprocessor or postprocessor intercepting the request, perhaps for security reasons), no view is rendered, because the request could already have been fulfilled.

The HandlerExceptionResolver beans declared in the WebApplicationContext are used to resolve exceptions thrown during request processing. Those exception resolvers allow customizing the logic to address exceptions. See Exceptions for more details.

 

为request寻找并执行对应handler的主要过程：

根据HandlerMapping获取handler with interceptors，即HandlerExecutionChain实例。support该handler的HandlerMapping可能有多个，按顺序遍历，成功获取到HandlerExecutionChain实例即止（获取的过程HandlerExecutionChain实质上是调用AbstractUrlHandlerMapping.lookupHandler，即根据url找对应的hanlder）。

    @Nullable
    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        if (this.handlerMappings != null) {
            for (HandlerMapping mapping : this.handlerMappings) {
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
                    return handler;
                }
            }
        }
        return null;
    }

根据handler获取处理该handler的HandlerAdaptor实例，support该handler的HandlerAdaptor可能有多个，按顺序遍历HandlerAdaptor列表取第一个support者。

    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        if (this.handlerAdapters != null) {
            for (HandlerAdapter adapter : this.handlerAdapters) {
                if (adapter.supports(handler)) {
                    return adapter;
                }
            }
        }
        throw new ServletException("No adapter for handler [" + handler +
                "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
    }

根据HandlerExecutionChain实例执行所有Interceptor的preHandle方法

根据HandlerAdaptor实例执行目标handler方法

根据HandlerExecutionChain实例执行所有Interceptor的postHandle方法

对执行结果进行处理（processDispatchResult），包括：

1、处理异常（processHandlerException）或解析视图（render），二选一；

2、执行各Interceptor的afterCompletion方法

 

可见，DispatcherServlet通过调用HandlerMapping.getHandler方法获取处理当前请求的handler（HandlerMapping可能有多个，按优先级依次尝试通过HandlerMapping获取handler，成功即止），获取到的不是纯handler，而是HandlerExecutionChain，其封装了handler及针对hanlder的拦截器。DispatcherServlet会依次调用各拦截器方法再调用目标handler方法。

A handler will always be wrapped in a HandlerExecutionChain instance, optionally accompanied by some HandlerInterceptor instances. The DispatcherServlet will first call each HandlerInterceptor's preHandle method in the given order, finally invoking the handler itself if all preHandle methods have returned true.

默认情况下，对于request如果没有找到与url对应的controller方法，则会当做请求静态资源来处理（对应的Handler、HandlerAdapter分别为ResourceHttpRequestHandler、HttpRequestHandlerAdapter来处理），尝试从配置的各static resouce路径下获取该url对应的资源。

 

题外话：

spring-webmvc中有个核心Servlet，即DispatcherServle，通常Servlet都是运行在外部Servlet容器（如Tomcat）中的，但是Spring如果要编写单元测试，对这个DispatcherServle进行测试，或者其他组件，会不会启动Tomcat呢？答案是不会。或者说，不借助外部Servlet容器，有没有办法手动启用这个Servlet？可以的。

方案：既然外部Servlet容器运行时会调用Servlet的service方法，那我们手动调用即可，至于参数，可用Spring提供的Mock Request和Response。两个示例：

class WebMvcTest1 {
    @Controller
    static class UserController {
        @GetMapping("getUser")
        @ResponseBody
        public String getUser() {
            return "user";
        }
    }

    private static DispatcherServlet initServlet(final Class<?> controllerClass) throws ServletException {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.setServletContext(new MockServletContext());
        ctx.register(UserController.class);
        ctx.refresh();
        DispatcherServlet servlet = new DispatcherServlet(ctx);
        return servlet;
    }

    public static void main(String[] args) throws ServletException, IOException {
        MockHttpServletRequest mockHttpServletRequest = new MockHttpServletRequest("GET", "/getUser");
        MockHttpServletResponse mockHttpServletResponse = new MockHttpServletResponse();
        DispatcherServlet servlet = initServlet(UserController.class);
        servlet.init(new MockServletConfig());
        servlet.service(mockHttpServletRequest, mockHttpServletResponse);
    }
}

class WebMvcTest2 {
    @Target({ ElementType.TYPE })
    @Retention(RetentionPolicy.RUNTIME)
    static @interface LogMethod {
    }

    @LogMethod
    @Controller
    public static class UserController {
        @GetMapping("getUser")
        @ResponseBody
        public String getUser() {
            return "user";
        }
    }

    private static DispatcherServlet initServlet(final Class<?> controllerClass) throws ServletException {
        DispatcherServlet dispatcherServlet = new DispatcherServlet() {
            @Override
            protected WebApplicationContext createWebApplicationContext(@Nullable WebApplicationContext parent) {
                GenericWebApplicationContext wac = new GenericWebApplicationContext();
                wac.registerBeanDefinition("controller", new RootBeanDefinition(controllerClass));
                DefaultAdvisorAutoProxyCreator autoProxyCreator = new DefaultAdvisorAutoProxyCreator();
                autoProxyCreator.setProxyTargetClass(true);
                autoProxyCreator.setBeanFactory(wac.getBeanFactory());
                wac.getBeanFactory().addBeanPostProcessor(autoProxyCreator);
                Pointcut pointcut = new AnnotationMatchingPointcut(LogMethod.class);
                DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, new MethodBeforeAdvice() {
                    @Override
                    public void before(Method method, Object[] args, Object target) throws Throwable {
                        System.out.println("进入方法" + method);
                    }
                });
                wac.getBeanFactory().registerSingleton("advisor", advisor);
                wac.refresh();
                return wac;
            }
        };
        dispatcherServlet.init(new MockServletConfig());
        return dispatcherServlet;
    }

    public static void main(String[] args) throws ServletException, IOException {

        DispatcherServlet dispatcherServlet = initServlet(UserController.class);
        MockHttpServletRequest request = new MockHttpServletRequest("GET", "/getUser");
        MockHttpServletResponse response = new MockHttpServletResponse();
        dispatcherServlet.service(request, response);
        System.out.println(response.getContentAsString());
    }
}

可参阅 Spring Web模块是怎样进行单元测试的。

 

默认Resolvers

默认情况下，如果开发者没有自定义指定，则DispatcherServlet会自动初始化所用的MultipartResolver、ThemeResolver、HandlerMappings、HandlerAdapters、HandlerExceptionResolvers、ReqeustToViewNameTranslator、ViewResolvers等，具体见内部的对应init方法。相关源码：

    /**
     * This implementation calls {@link #initStrategies}.
     */
    @Override
    protected void onRefresh(ApplicationContext context) {
        initStrategies(context);
    }



    /**
     * Initialize the strategy objects that this servlet uses.
     * <p>May be overridden in subclasses in order to initialize further strategy objects.
     */
    protected void initStrategies(ApplicationContext context) {
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }
    /**
     * Initialize the HandlerMappings used by this class.
     * <p>If no HandlerMapping beans are defined in the BeanFactory for this namespace,
     * we default to BeanNameUrlHandlerMapping.
     */
    private void initHandlerMappings(ApplicationContext context) {
        this.handlerMappings = null;

        if (this.detectAllHandlerMappings) {
            // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerMapping> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerMappings = new ArrayList<>(matchingBeans.values());
                // We keep HandlerMappings in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerMappings);
            }
        }
        else {
            try {
                HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
                this.handlerMappings = Collections.singletonList(hm);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerMapping later.
            }
        }

        // Ensure we have at least one HandlerMapping, by registering
        // a default HandlerMapping if no other mappings are found.
        if (this.handlerMappings == null) {
            this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
                        "': using default strategies from DispatcherServlet.properties");
            }
        }
    }

    /**
     * Initialize the HandlerAdapters used by this class.
     * <p>If no HandlerAdapter beans are defined in the BeanFactory for this namespace,
     * we default to SimpleControllerHandlerAdapter.
     */
    private void initHandlerAdapters(ApplicationContext context) {
        this.handlerAdapters = null;

        if (this.detectAllHandlerAdapters) {
            // Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerAdapter> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
            if (!matchingBeans.isEmpty()) {
                this.handlerAdapters = new ArrayList<>(matchingBeans.values());
                // We keep HandlerAdapters in sorted order.
                AnnotationAwareOrderComparator.sort(this.handlerAdapters);
            }
        }
        else {
            try {
                HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
                this.handlerAdapters = Collections.singletonList(ha);
            }
            catch (NoSuchBeanDefinitionException ex) {
                // Ignore, we'll add a default HandlerAdapter later.
            }
        }

        // Ensure we have at least some HandlerAdapters, by registering
        // default HandlerAdapters if no other adapters are found.
        if (this.handlerAdapters == null) {
            this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerAdapters declared for servlet '" + getServletName() +
                        "': using default strategies from DispatcherServlet.properties");
            }
        }
    }

其原理是：先尝试从容器中找用户注册的Resolver、Handler、Converter等，若未找到，则根据默认stragies来注册各Resolver。这里的strategies是从弄个DispatcherServlet同目录下的一个DispatcherServlet.properties文件里读取内容，该文件指定了默认采用的各种Resolver。内容如下：

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
    org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
    org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
    org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
    org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
    org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

DispatcherServlet默认检测注册的Bean

special beans detected by the DispatcherServlet：

HandlerMapping

HandlerAdaptter

HandlerExceptionResolver

ViewResolver：解析视图

LocaleResolver/LocaleContextResolver，包括：

Time Zone

Header Resolver

Cookie Resolver

Session Resolver

Locale Interceptor

ThemeResolver

MultipartResolver

FlashMapManager

开发者自定义实现这些Bean，Spring 容器会以开发者提供的Bean来替换默认的Bean。

 

HandlerExceptionResolver

处理handler执行的异常，会依次调用各HandlerExceptionResolver的resolveException方法，若有一个返回非null则结束。

只需要实现HandlerExceptionResolver接口并重写resolveException方法即可实现自定义的异常处理。

 

SpringMVC框架默认实现了四个Resolver：

（参考资料：https://blog.csdn.net/andy_zhang2007/article/details/88594280）

四个Resolver的关系

 

四个Resolver

org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver：

仅仅针对Handler类型为HandlerMethod中发生异常的情况，也就是@Controller组件类中的@RequestMapping方法中的异常。当这类异常交给ExceptionHandlerExceptionResolver解析时，它会首先查看发生异常的handler方法所在的controller类中是否有合适的@ExceptionHanlder方法，然后看所有的@ControllerAdvice类中是否有合适的@ExceptionHanlder方法,如果有，ExceptionHandlerExceptionResolver就会使用相应的方法处理该异常。源码：

package org.springframework.web.servlet.mvc.method.annotation;

// 省略 import 行

/**
 * An {@link AbstractHandlerMethodExceptionResolver} that resolves exceptions
 * through {@code @ExceptionHandler} methods.
 *
 * <p>Support for custom argument and return value types can be added via
 * {@link #setCustomArgumentResolvers} and {@link #setCustomReturnValueHandlers}.
 * Or alternatively to re-configure all argument and return value types use
 * {@link #setArgumentResolvers} and {@link #setReturnValueHandlers(List)}.
 *
 * @author Rossen Stoyanchev
 * @author Juergen Hoeller
 * @since 3.1
 */
public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver
        implements ApplicationContextAware, InitializingBean {

    @Nullable
    private List<HandlerMethodArgumentResolver> customArgumentResolvers;

    @Nullable
    private HandlerMethodArgumentResolverComposite argumentResolvers;

    @Nullable
    private List<HandlerMethodReturnValueHandler> customReturnValueHandlers;

    @Nullable
    private HandlerMethodReturnValueHandlerComposite returnValueHandlers;

    // 一组 HttpMessageConverter
    // 供能够直接输出响应体的 HandlerMethodReturnValueHandler 使用
    private List<HttpMessageConverter<?>> messageConverters;

    private ContentNegotiationManager contentNegotiationManager = new ContentNegotiationManager();

    //  将异常处理控制器方法返回值转换成响应体时的Advice逻辑，可以做一些修饰，变形转换等等
    private final List<Object> responseBodyAdvice = new ArrayList<>();

    @Nullable
    private ApplicationContext applicationContext;

    // 保存发生异常的控制器方法所在的控制器组件中的@ExceptionHandler异常处理控制器方法
    private final Map<Class<?>, ExceptionHandlerMethodResolver> exceptionHandlerCache =
            new ConcurrentHashMap<>(64);

    // 缓存@ControllerAdvice bean组件中的@ExceptionHandler异常处理控制器方法
    private final Map<ControllerAdviceBean, ExceptionHandlerMethodResolver> 
            exceptionHandlerAdviceCache =    new LinkedHashMap<>();


    public ExceptionHandlerExceptionResolver() {
       // 此构造函数方法体主要是初始化属性 this.messageConverters, 注意其初始值 :
       // 1. ByteArrayHttpMessageConverter 二进制字节流
       // 2. StringHttpMessageConverter, ISO8859-1 ，字符串
       // 3. SourceHttpMessageConverter , DOMSource/SAXSource/StAXSource/StreamSource等
       // 4. AllEncompassingFormHttpMessageConverter ,UTF-8， 用于读写表单数据和写multipart数据，
       // 在FormHttpMessageConverter上扩展，增加了 XML/JSON转换能力
        StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter();
        stringHttpMessageConverter.setWriteAcceptCharset(false);  // see SPR-7316

        this.messageConverters = new ArrayList<>();
        this.messageConverters.add(new ByteArrayHttpMessageConverter());
        this.messageConverters.add(stringHttpMessageConverter);
        try {
            this.messageConverters.add(new SourceHttpMessageConverter<>());
        }
        catch (Error err) {
            // Ignore when no TransformerFactory implementation is available
        }
        this.messageConverters.add(new AllEncompassingFormHttpMessageConverter());
    }


    /**
     * Provide resolvers for custom argument types. Custom resolvers are ordered
     * after built-in ones. To override the built-in support for argument
     * resolution use {@link #setArgumentResolvers} instead.
     */
    public void setCustomArgumentResolvers(@Nullable List<HandlerMethodArgumentResolver> 
        argumentResolvers) {
        this.customArgumentResolvers= argumentResolvers;
    }

    /**
     * Return the custom argument resolvers, or {@code null}.
     */
    @Nullable
    public List<HandlerMethodArgumentResolver> getCustomArgumentResolvers() {
        return this.customArgumentResolvers;
    }

    /**
     * Configure the complete list of supported argument types thus overriding
     * the resolvers that would otherwise be configured by default.
     */
    public void setArgumentResolvers(
            @Nullable List<HandlerMethodArgumentResolver> argumentResolvers) {
        if (argumentResolvers == null) {
            this.argumentResolvers = null;
        }
        else {
            this.argumentResolvers = new HandlerMethodArgumentResolverComposite();
            this.argumentResolvers.addResolvers(argumentResolvers);
        }
    }

    /**
     * Return the configured argument resolvers, or possibly {@code null} if
     * not initialized yet via {@link #afterPropertiesSet()}.
     */
    @Nullable
    public HandlerMethodArgumentResolverComposite getArgumentResolvers() {
        return this.argumentResolvers;
    }

    /**
     * Provide handlers for custom return value types. Custom handlers are
     * ordered after built-in ones. To override the built-in support for
     * return value handling use {@link #setReturnValueHandlers}.
     */
    public void setCustomReturnValueHandlers(
        @Nullable List<HandlerMethodReturnValueHandler> returnValueHandlers) {
        this.customReturnValueHandlers = returnValueHandlers;
    }

    /**
     * Return the custom return value handlers, or {@code null}.
     */
    @Nullable
    public List<HandlerMethodReturnValueHandler> getCustomReturnValueHandlers() {
        return this.customReturnValueHandlers;
    }

    /**
     * Configure the complete list of supported return value types thus
     * overriding handlers that would otherwise be configured by default.
     */
    public void setReturnValueHandlers(
        @Nullable List<HandlerMethodReturnValueHandler> returnValueHandlers) {
        if (returnValueHandlers == null) {
            this.returnValueHandlers = null;
        }
        else {
            this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite();
            this.returnValueHandlers.addHandlers(returnValueHandlers);
        }
    }

    /**
     * Return the configured handlers, or possibly {@code null} if not
     * initialized yet via {@link #afterPropertiesSet()}.
     */
    @Nullable
    public HandlerMethodReturnValueHandlerComposite getReturnValueHandlers() {
        return this.returnValueHandlers;
    }

    /**
     * Set the message body converters to use.
     * <p>These converters are used to convert from and to HTTP requests and responses.
     */
    public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters) {
        this.messageConverters = messageConverters;
    }

    /**
     * Return the configured message body converters.
     */
    public List<HttpMessageConverter<?>> getMessageConverters() {
        return this.messageConverters;
    }

    /**
     * Set the {@link ContentNegotiationManager} to use to determine requested media types.
     * If not set, the default constructor is used.
     */
    public void setContentNegotiationManager(ContentNegotiationManager contentNegotiationManager) {
        this.contentNegotiationManager = contentNegotiationManager;
    }

    /**
     * Return the configured {@link ContentNegotiationManager}.
     */
    public ContentNegotiationManager getContentNegotiationManager() {
        return this.contentNegotiationManager;
    }

    /**
     * Add one or more components to be invoked after the execution of a controller
     * method annotated with {@code @ResponseBody} or returning {@code ResponseEntity}
     * but before the body is written to the response with the selected
     * {@code HttpMessageConverter}.
     */
    public void setResponseBodyAdvice(@Nullable List<ResponseBodyAdvice<?>> responseBodyAdvice) {
        this.responseBodyAdvice.clear();
        if (responseBodyAdvice != null) {
            this.responseBodyAdvice.addAll(responseBodyAdvice);
        }
    }

    @Override
    public void setApplicationContext(@Nullable ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @Nullable
    public ApplicationContext getApplicationContext() {
        return this.applicationContext;
    }


   // InitializingBean 接口定义的初始化方法
    @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 的 bean 组件并排序 
        List<ControllerAdviceBean> adviceBeans = 
            ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
        AnnotationAwareOrderComparator.sort(adviceBeans);

        
        for (ControllerAdviceBean adviceBean : adviceBeans) {
            Class<?> beanType = adviceBean.getBeanType();
            if (beanType == null) {
                throw new IllegalStateException(
                    "Unresolvable type for ControllerAdviceBean: " + adviceBean);
            }
           //  ExceptionHandlerMethodResolver 是一个工具类，它能够分析一个类，
           // 获取其中的注解 @ExceptionHandler 注解信息，建立 异常 和 异常处理控制器方法的 映射表
            ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
            if (resolver.hasExceptionMappings()) {
              //  resolver 分析完 beanType，发现其中存在使用@ExceptionHandler注解的方法，
              // 现在将其记录到 this.exceptionHandlerAdviceCache
                this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
            }
            
            if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
              // 当前 注解 @ControllerAdvice 的 bean 组件实现了接口 ResponseBodyAdvice ，
              // 现在将其记录到 this.responseBodyAdvice
                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");
            }
        }
    }

    /**
     * Return an unmodifiable Map with the {@link ControllerAdvice @ControllerAdvice}
     * beans discovered in the ApplicationContext. The returned map will be empty if
     * the method is invoked before the bean has been initialized via
     * {@link #afterPropertiesSet()}.
     */
    public Map<ControllerAdviceBean, ExceptionHandlerMethodResolver> 
        getExceptionHandlerAdviceCache() {
        return Collections.unmodifiableMap(this.exceptionHandlerAdviceCache);
    }

    /**
     * 这里返回一个 HandlerMethodArgumentResolver 列表，是缺省情况下使用的异常处理
     * 控制器方法参数解析器
     * Return the list of argument resolvers to use including built-in resolvers
     * and custom resolvers provided via {@link #setCustomArgumentResolvers}.
     */
    protected List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
        List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();

        // Annotation-based argument resolution
       // 内置，基于注解的控制器方法参数解析 
        resolvers.add(new SessionAttributeMethodArgumentResolver());
        resolvers.add(new RequestAttributeMethodArgumentResolver());

        // Type-based argument resolution
       // 内置，基于类型的控制器方法参数解析
        resolvers.add(new ServletRequestMethodArgumentResolver());
        resolvers.add(new ServletResponseMethodArgumentResolver());
        resolvers.add(new RedirectAttributesMethodArgumentResolver());
        resolvers.add(new ModelMethodProcessor());

        // Custom arguments
       // 扩展，可以由开发人员定制 
        if (getCustomArgumentResolvers() != null) {
            resolvers.addAll(getCustomArgumentResolvers());
        }

        return resolvers;
    }

    /**
     *  返回一个 HandlerMethodReturnValueHandler 列表
     * 用来处理异常处理控制器方法的返回值
     * Return the list of return value handlers to use including built-in and
     * custom handlers provided via {@link #setReturnValueHandlers}.
     */
    protected List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
        List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>();

        // Single-purpose return value types
        handlers.add(new ModelAndViewMethodReturnValueHandler());
        handlers.add(new ModelMethodProcessor());
        handlers.add(new ViewMethodReturnValueHandler());
        handlers.add(new HttpEntityMethodProcessor(
                getMessageConverters(), this.contentNegotiationManager, this.responseBodyAdvice));

        // Annotation-based return value types
        handlers.add(new ModelAttributeMethodProcessor(false));
        handlers.add(new RequestResponseBodyMethodProcessor(
                getMessageConverters(), this.contentNegotiationManager, this.responseBodyAdvice));

        // Multi-purpose return value types
        handlers.add(new ViewNameMethodReturnValueHandler());
        handlers.add(new MapMethodProcessor());

        // Custom return value types
        if (getCustomReturnValueHandlers() != null) {
            handlers.addAll(getCustomReturnValueHandlers());
        }

        // Catch-all
       // 兜底的返回值解析器 
        handlers.add(new ModelAttributeMethodProcessor(true));

        return handlers;
    }


    /**
     * Find an {@code @ExceptionHandler} method and invoke it to handle the raised exception.
     */
    @Override
    @Nullable
    protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
            HttpServletResponse response, @Nullable HandlerMethod handlerMethod, 
            Exception exception) {

       // 考虑发生异常 exception 的控制器方法的所在类，以及所有的 @ControllerAdvice 类中的
       // 所有 @ExceptionHandler 异常处理控制器方法，看看有没有能处理该异常的异常处理控制器方法，
       // 如果有则继续，如果没有，则返回 null，调用者会考虑其他方案
        ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(
                handlerMethod, exception);
        if (exceptionHandlerMethod == null) {
            return null;
        }

       // 现在已经找到能处理异常 exception 的异常处理控制器方法了，包装保存在 
       // exceptionHandlerMethod 中, 现在准备调用它 :
       // 1. 设置调用所需要的工具 : 参数解析器，返回值处理器
       // 2. 准备目标异常处理控制器方法执行过程中需要保存指定决定的容器对象 mavContainer
       // 3. 调用目标异常处理控制器方法
        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 is unintended here,
            // probably an accident (e.g. failed assertion or the like).
            if (invocationEx != exception && logger.isWarnEnabled()) {
                logger.warn("Failure in @ExceptionHandler " + exceptionHandlerMethod, invocationEx);
            }
            // Continue with default processing of the original exception...
          // 异常处理控制器方法执行遇到异常，这里返回null，让调用者继续使用缺省方式处理
          // 原来需要处理的异常，注意，指的是参数 exception，而不是这里抓到的异常
          // invocationEx
            return null;
        }

        
        if (mavContainer.isRequestHandled()) {
           // 异常处理控制器方法将请求处理完全了，这里返回空  ModelAndView() 对象，
           // 告诉调用者不需要继续解析和渲染视图了
            return new ModelAndView();
        }
        else {
          //  异常处理控制器方法正常执行结果，但没有将请求处理完全，现在构造 ModelAndView,
          // 调用者需要继续解析和渲染视图
            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;
        }
    }

    /**
     * Find an {@code @ExceptionHandler} method for the given exception. The default
     * implementation searches methods in the class hierarchy of the controller first
     * and if not found, it continues searching for additional {@code @ExceptionHandler}
     * methods assuming some {@linkplain ControllerAdvice @ControllerAdvice}
     * Spring-managed beans were detected.
     * @param handlerMethod the method where the exception was raised (may be {@code null})
     * @param exception the raised exception
     * @return a method to handle the exception, or {@code null} if none
     */
    @Nullable
    protected ServletInvocableHandlerMethod getExceptionHandlerMethod(
            @Nullable HandlerMethod handlerMethod, Exception exception) {

        Class<?> handlerType = null;

        if (handlerMethod != null) {
            // Local exception handler methods on the controller class itself.
            // To be invoked through the proxy, even in case of an interface-based proxy.
          // 首先尝试分析控制器方法所在类类自身是否有使用注解 @ExceptionHander,
          // 这一分析动作跟分析一个@ControllerAdvice组件类是一样的，也是使用
          // ExceptionHandlerMethodResolver
            handlerType = handlerMethod.getBeanType();
            ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
            if (resolver == null) {
                resolver = new ExceptionHandlerMethodResolver(handlerType);
                this.exceptionHandlerCache.put(handlerType, resolver);
            }
            
           // 现在看控制方法所在类是否有能处理指定异常 exception 的异常处理控制器方法，
           // 有的话使用该方法构建 ServletInvocableHandlerMethod， 用于处理该异常
            Method method = resolver.resolveMethod(exception);
            if (method != null) {
                return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
            }
            // For advice applicability check below (involving base packages, assignable types
            // and annotation presence), use target class instead of interface-based proxy.
            if (Proxy.isProxyClass(handlerType)) {
                handlerType = AopUtils.getTargetClass(handlerMethod.getBean());
            }
        }

       // 如果控制器方法所在类不存在能处理指定异常 exception 的异常处理控制器方法，
       // 现在查看所有的 @ControllerAdvice 类中是否有能处理指定异常 exception
       // 的异常处理控制器方法，找到的话相应地构造 ServletInvocableHandlerMethod 
       // 并返回，用于处理该异常
        for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry 
                : this.exceptionHandlerAdviceCache.entrySet()) {
            ControllerAdviceBean advice = entry.getKey();
            if (advice.isApplicableToBeanType(handlerType)) {
                ExceptionHandlerMethodResolver resolver = entry.getValue();
                Method method = resolver.resolveMethod(exception);
                if (method != null) {
                    return new ServletInvocableHandlerMethod(advice.resolveBean(), method);
                }
            }
        }

       // 从发生异常 exception 的控制器方法所在类和所有的  @ControllerAdvice 类中
       // 都找不到合适的异常处理控制器方法，现在返回 null，意思是告知调用者：我处理
       // 不了这一个异常，你再看看其他 HandlerExceptionResolver ？
        return null;
    }

}

org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver：

如果异常是ResponseStatusException或者使用了注解@ResponseStatus，则根据异常解析出status和reason、调用response.sendError方法、返回空ModelAndView；若所发生异常的cause也是一个异常，则递归执行上述流程。源码：

package org.springframework.web.servlet.mvc.annotation;

// 省略 import 行


public class ResponseStatusExceptionResolver extends AbstractHandlerExceptionResolver 
        implements MessageSourceAware {

    @Nullable
    private MessageSource messageSource;


    // MessageSourceAware 接口定义的方法，
    // 会在当前 bean 创建的合适时机被容器设置该属性
    @Override
    public void setMessageSource(MessageSource messageSource) {
        this.messageSource = messageSource;
    }


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

        try {
          //第1种情况处理 : 异常自身就是 ResponseStatusException 异常的情况 
            if (ex instanceof ResponseStatusException) {
                return resolveResponseStatusException((ResponseStatusException) ex, request, response, handler);
            }

          //第2种情况处理 : 尝试从异常上获取注解 @ResponseStatus 信息  
            ResponseStatus status = AnnotatedElementUtils.findMergedAnnotation(
                ex.getClass(), ResponseStatus.class);
            if (status != null) {
                return resolveResponseStatus(status, request, response, handler, ex);
            }

          //第3种情况处理 :  异常的 cause 还是异常，递归调用该方法进行处理
            if (ex.getCause() instanceof Exception) {
                return doResolveException(request, response, handler, (Exception) ex.getCause());
            }
        }
        catch (Exception resolveEx) {
            if (logger.isWarnEnabled()) {
                logger.warn("Failure while trying to resolve exception [" 
                    + ex.getClass().getName() + "]", resolveEx);
            }
        }
        
       // 通过null告诉调用方没能处理的了该异常
        return null;
    }

    /**
     * Template method that handles the {@link ResponseStatus @ResponseStatus} annotation.
     * <p>The default implementation delegates to {@link #applyStatusAndReason}
     * with the status code and reason from the annotation.
     * @param responseStatus the {@code @ResponseStatus} annotation
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler, or {@code null} if none chosen at the
     * time of the exception, e.g. if multipart resolution failed
     * @param ex the exception
     * @return an empty ModelAndView, i.e. exception resolved
     */
    protected ModelAndView resolveResponseStatus(ResponseStatus responseStatus, HttpServletRequest request,
            HttpServletResponse response, @Nullable Object handler, Exception ex) throws Exception {

        int statusCode = responseStatus.code().value();
        String reason = responseStatus.reason();
        return applyStatusAndReason(statusCode, reason, response);
    }

    /**
     * Template method that handles an {@link ResponseStatusException}.
     * <p>The default implementation delegates to {@link #applyStatusAndReason}
     * with the status code and reason from the exception.
     * @param ex the exception
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler, or {@code null} if none chosen at the
     * time of the exception, e.g. if multipart resolution failed
     * @return an empty ModelAndView, i.e. exception resolved
     * @since 5.0
     */
    protected ModelAndView resolveResponseStatusException(ResponseStatusException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws Exception {

        int statusCode = ex.getStatus().value();
        String reason = ex.getReason();
        return applyStatusAndReason(statusCode, reason, response);
    }

    /**
     * Apply the resolved status code and reason to the response.
     * <p>The default implementation sends a response error using
     * {@link HttpServletResponse#sendError(int)} or
     * {@link HttpServletResponse#sendError(int, String)} if there is a reason
     * and then returns an empty ModelAndView.
     * @param statusCode the HTTP status code
     * @param reason the associated reason (may be {@code null} or empty)
     * @param response current HTTP response
     * @since 5.0
     */
    protected ModelAndView applyStatusAndReason(int statusCode, @Nullable String reason, 
            HttpServletResponse response)
            throws IOException {

        if (!StringUtils.hasLength(reason)) {
            // reason 为空的情况 
            response.sendError(statusCode);
        }
        else {
            // reason 不为空的情况
             // 如果也设置了消息源 this.messageSource, 尝试从其中解析消息         
            String resolvedReason = (this.messageSource != null ?
                    this.messageSource.getMessage(reason, null, reason, LocaleContextHolder.getLocale()) :
                    reason);
            response.sendError(statusCode, resolvedReason);
        }
        
        // 返回一个空 ModelAndView 对象，告知调用方请求已经被处理完，使用缺省视图解析和渲染机制 
        return new ModelAndView();
    }

}

org.springframework.web.servlet.handler.SimpleMappingExceptionResolver：

记录异常与视图名间的映射关系，以及异常与http status的映射关系。处理时根据异常及此映射关系查找ModelAndView及http status来处理异常，若未找到则使用设置的缺省ModelAndView和http status，若缺省者也未设置则返回null（相当于不处理）。源码：

package org.springframework.web.servlet.handler;

// 省略 import 行


public class SimpleMappingExceptionResolver extends AbstractHandlerExceptionResolver {

    /** The default name of the exception attribute: "exception". */
    public static final String DEFAULT_EXCEPTION_ATTRIBUTE = "exception";


    // 保存异常类名称和异常处理视图名称的映射
    @Nullable
    private Properties exceptionMappings;

    @Nullable
    private Class<?>[] excludedExceptions;

    // 缺省用于异常处理的错误视图名称
    // 缺省值为 null
    // 如果设置该值，某个异常被当前 SimpleMappingExceptionResolver 解析时，
    // 会首先通过 exceptionMappings 查看对应的 异常处理视图，如果没找到，
    // 则会用该值渲染视图。所以如果设置了该值，可以理解为，SimpleMappingExceptionResolver
    // 接管了对所有异常的处理
    @Nullable
    private String defaultErrorView;

    // 缺省状态码
    @Nullable
    private Integer defaultStatusCode;

    // 保存错误视图名称/HTTP状态之间的映射
    private Map<String, Integer> statusCodes = new HashMap<>();

    @Nullable
    private String exceptionAttribute = DEFAULT_EXCEPTION_ATTRIBUTE;


    /**
     * Set the mappings between exception class names and error view names.
     * 设置异常类名称和错误视图名称之间的映射。
     * 这里异常类名称可以是完整类名称的一部分，而不必是全部。目前还不支持通配符。
     * The exception class name can be a substring, with no wildcard support at present.
     * A value of "ServletException" would match {@code javax.servlet.ServletException}
     * and subclasses, for example.
     * <p><b>NB:</b> Consider carefully how
     * specific the pattern is, and whether to include package information (which isn't mandatory).
     * For example, "Exception" will match nearly anything, and will probably hide other rules.
     * "java.lang.Exception" would be correct if "Exception" was meant to define a rule for all
     * checked exceptions. With more unusual exception names such as "BaseBusinessException"
     * there's no need to use a FQN.
     * @param mappings exception patterns (can also be fully qualified class names) as keys,
     * and error view names as values
     */
    public void setExceptionMappings(Properties mappings) {
        this.exceptionMappings = mappings;
    }

    /**
     * Set one or more exceptions to be excluded from the exception mappings.
     * Excluded exceptions are checked first and if one of them equals the actual
     * exception, the exception will remain unresolved.
     * @param excludedExceptions one or more excluded exception types
     */
    public void setExcludedExceptions(Class<?>... excludedExceptions) {
        this.excludedExceptions = excludedExceptions;
    }

    /**
     * Set the name of the default error view.
     * This view will be returned if no specific mapping was found.
     * <p>Default is none.
     */
    public void setDefaultErrorView(String defaultErrorView) {
        this.defaultErrorView = defaultErrorView;
    }

    /**
     * Set the HTTP status code that this exception resolver will apply for a given
     * resolved error view. Keys are view names; values are status codes.
     * <p>Note that this error code will only get applied in case of a top-level request.
     * It will not be set for an include request, since the HTTP status cannot be modified
     * from within an include.
     * <p>If not specified, the default status code will be applied.
     * @see #setDefaultStatusCode(int)
     */
    public void setStatusCodes(Properties statusCodes) {
        for (Enumeration<?> enumeration = statusCodes.propertyNames(); enumeration.hasMoreElements();) {
            String viewName = (String) enumeration.nextElement();
            Integer statusCode = Integer.valueOf(statusCodes.getProperty(viewName));
            this.statusCodes.put(viewName, statusCode);
        }
    }

    /**
     * An alternative to {@link #setStatusCodes(Properties)} for use with
     * Java-based configuration.
     */
    public void addStatusCode(String viewName, int statusCode) {
        this.statusCodes.put(viewName, statusCode);
    }

    /**
     * Returns the HTTP status codes provided via {@link #setStatusCodes(Properties)}.
     * Keys are view names; values are status codes.
     */
    public Map<String, Integer> getStatusCodesAsMap() {
        return Collections.unmodifiableMap(this.statusCodes);
    }

    /**
     * Set the default HTTP status code that this exception resolver will apply
     * if it resolves an error view and if there is no status code mapping defined.
     * <p>Note that this error code will only get applied in case of a top-level request.
     * It will not be set for an include request, since the HTTP status cannot be modified
     * from within an include.
     * <p>If not specified, no status code will be applied, either leaving this to the
     * controller or view, or keeping the servlet engine's default of 200 (OK).
     * @param defaultStatusCode the HTTP status code value, for example 500
     * ({@link HttpServletResponse#SC_INTERNAL_SERVER_ERROR}) or 404 ({@link HttpServletResponse#SC_NOT_FOUND})
     * @see #setStatusCodes(Properties)
     */
    public void setDefaultStatusCode(int defaultStatusCode) {
        this.defaultStatusCode = defaultStatusCode;
    }

    /**
     * Set the name of the model attribute as which the exception should be exposed.
     * Default is "exception".
     * <p>This can be either set to a different attribute name or to {@code null}
     * for not exposing an exception attribute at all.
     * @see #DEFAULT_EXCEPTION_ATTRIBUTE
     */
    public void setExceptionAttribute(@Nullable String exceptionAttribute) {
        this.exceptionAttribute = exceptionAttribute;
    }


    /**
     * Actually resolve the given exception that got thrown during on handler execution,
     * returning a ModelAndView that represents a specific error page if appropriate.
     * <p>May be overridden in subclasses, in order to apply specific exception checks.
     * Note that this template method will be invoked <i>after</i> checking whether this
     * resolved applies ("mappedHandlers" etc), so an implementation may simply proceed
     * with its actual exception handling.
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler, or {@code null} if none chosen at the time
     * of the exception (for example, if multipart resolution failed)
     * @param ex the exception that got thrown during handler execution
     * @return a corresponding {@code ModelAndView} to forward to,
     * or {@code null} for default processing in the resolution chain
     */
    @Override
    @Nullable
    protected ModelAndView doResolveException(
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {

        // Expose ModelAndView for chosen error view.
       // 尝试根据异常类型查找 exceptionMappings 是否存在对应的错误视图名称,有的话记录到 viewName 
        String viewName = determineViewName(ex, request);
        if (viewName != null) {
            // Apply HTTP status code for error views, if specified.
            // Only apply it if we're processing a top-level request.
          // 结合 错误视图名称/HTTP状态码映射表 和 缺省状态码属性 中查看是否存在对应 
          // viewName 的 HTTP状态码，有的话设置到响应对象上
            Integer statusCode = determineStatusCode(request, viewName);
            if (statusCode != null) {
                applyStatusCodeIfPossible(request, response, statusCode);
            }
          
          // 使用找到的视图名称构建相应的 ModelAndView 对象并返回给调用者
          // 用以渲染错误视图给请求者
            return getModelAndView(viewName, ex, request);
        }
        else {
          // 返回 null 给调用者表明自己没能处理该异常 
            return null;
        }
    }

    /**
     * Determine the view name for the given exception, first checking against the
     * {@link #setExcludedExceptions(Class[]) "excludedExecptions"}, then searching the
     * {@link #setExceptionMappings "exceptionMappings"}, and finally using the
     * {@link #setDefaultErrorView "defaultErrorView"} as a fallback.
     * @param ex the exception that got thrown during handler execution
     * @param request current HTTP request (useful for obtaining metadata)
     * @return the resolved view name, or {@code null} if excluded or none found
     */
    @Nullable
    protected String determineViewName(Exception ex, HttpServletRequest request) {
        String viewName = null;
        if (this.excludedExceptions != null) {
            for (Class<?> excludedEx : this.excludedExceptions) {
                if (excludedEx.equals(ex.getClass())) {
                    return null;
                }
            }
        }
        // Check for specific exception mappings.
        if (this.exceptionMappings != null) {
            viewName = findMatchingViewName(this.exceptionMappings, ex);
        }
        // Return default error view else, if defined.
        if (viewName == null && this.defaultErrorView != null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Resolving to default view '" + this.defaultErrorView + "'");
            }
            viewName = this.defaultErrorView;
        }
        return viewName;
    }

    /**
     * Find a matching view name in the given exception mappings.
     * @param exceptionMappings mappings between exception class names and error view names
     * @param ex the exception that got thrown during handler execution
     * @return the view name, or {@code null} if none found
     * @see #setExceptionMappings
     */
    @Nullable
    protected String findMatchingViewName(Properties exceptionMappings, Exception ex) {
        String viewName = null;
        String dominantMapping = null;
        int deepest = Integer.MAX_VALUE;
        for (Enumeration<?> names = exceptionMappings.propertyNames(); names.hasMoreElements();) {
            String exceptionMapping = (String) names.nextElement();
            int depth = getDepth(exceptionMapping, ex);
            if (depth >= 0 && (depth < deepest || (depth == deepest &&
                    dominantMapping != null && exceptionMapping.length() > dominantMapping.length()))) {
                deepest = depth;
                dominantMapping = exceptionMapping;
                viewName = exceptionMappings.getProperty(exceptionMapping);
            }
        }
        if (viewName != null && logger.isDebugEnabled()) {
            logger.debug("Resolving to view '" + viewName + "' based on mapping [" + dominantMapping + "]");
        }
        return viewName;
    }

    /**
     * Return the depth to the superclass matching.
     * <p>0 means ex matches exactly. Returns -1 if there's no match.
     * Otherwise, returns depth. Lowest depth wins.
     */
    protected int getDepth(String exceptionMapping, Exception ex) {
        return getDepth(exceptionMapping, ex.getClass(), 0);
    }

    private int getDepth(String exceptionMapping, Class<?> exceptionClass, int depth) {
        if (exceptionClass.getName().contains(exceptionMapping)) {
            // Found it!
            return depth;
        }
        // If we've gone as far as we can go and haven't found it...
        if (exceptionClass == Throwable.class) {
            return -1;
        }
        return getDepth(exceptionMapping, exceptionClass.getSuperclass(), depth + 1);
    }

    /**
     * Determine the HTTP status code to apply for the given error view.
     * <p>The default implementation returns the status code for the given view name (specified through the
     * {@link #setStatusCodes(Properties) statusCodes} property), or falls back to the
     * {@link #setDefaultStatusCode defaultStatusCode} if there is no match.
     * <p>Override this in a custom subclass to customize this behavior.
     * @param request current HTTP request
     * @param viewName the name of the error view
     * @return the HTTP status code to use, or {@code null} for the servlet container's default
     * (200 in case of a standard error view)
     * @see #setDefaultStatusCode
     * @see #applyStatusCodeIfPossible
     */
    @Nullable
    protected Integer determineStatusCode(HttpServletRequest request, String viewName) {
        if (this.statusCodes.containsKey(viewName)) {
            return this.statusCodes.get(viewName);
        }
        return this.defaultStatusCode;
    }

    /**
     * Apply the specified HTTP status code to the given response, if possible (that is,
     * if not executing within an include request).
     * @param request current HTTP request
     * @param response current HTTP response
     * @param statusCode the status code to apply
     * @see #determineStatusCode
     * @see #setDefaultStatusCode
     * @see HttpServletResponse#setStatus
     */
    protected void applyStatusCodeIfPossible(HttpServletRequest request, 
                        HttpServletResponse response, int statusCode) {
        if (!WebUtils.isIncludeRequest(request)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Applying HTTP status " + statusCode);
            }
            response.setStatus(statusCode);
            request.setAttribute(WebUtils.ERROR_STATUS_CODE_ATTRIBUTE, statusCode);
        }
    }

    /**
     * Return a ModelAndView for the given request, view name and exception.
     * <p>The default implementation delegates to {@link #getModelAndView(String, Exception)}.
     * @param viewName the name of the error view
     * @param ex the exception that got thrown during handler execution
     * @param request current HTTP request (useful for obtaining metadata)
     * @return the ModelAndView instance
     */
    protected ModelAndView getModelAndView(String viewName, Exception ex, HttpServletRequest request) {
        return getModelAndView(viewName, ex);
    }

    /**
     * Return a ModelAndView for the given view name and exception.
     * <p>The default implementation adds the specified exception attribute.
     * Can be overridden in subclasses.
     * @param viewName the name of the error view
     * @param ex the exception that got thrown during handler execution
     * @return the ModelAndView instance
     * @see #setExceptionAttribute
     */
    protected ModelAndView getModelAndView(String viewName, Exception ex) {
        ModelAndView mv = new ModelAndView(viewName);
        if (this.exceptionAttribute != null) {
            mv.addObject(this.exceptionAttribute, ex);
        }
        return mv;
    }

}

org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver：

Spring MVC默认的异常处理器，解析时将标准MVC异常翻译成HTTP状态码、调用响应对象的方法#sendError、返回一个空ModelAndView。源码：

package org.springframework.web.servlet.mvc.support;


public class DefaultHandlerExceptionResolver extends AbstractHandlerExceptionResolver {

    /**
     * Log category to use when no mapped handler is found for a request.
     * @see #pageNotFoundLogger
     */
    public static final String PAGE_NOT_FOUND_LOG_CATEGORY = 
        "org.springframework.web.servlet.PageNotFound";

    /**
     * Additional logger to use when no mapped handler is found for a request.
     * @see #PAGE_NOT_FOUND_LOG_CATEGORY
     */
    protected static final Log pageNotFoundLogger = LogFactory.getLog(PAGE_NOT_FOUND_LOG_CATEGORY);


    /**
     * Sets the #setOrder(int) order to  #LOWEST_PRECEDENCE.
     */
    public DefaultHandlerExceptionResolver() {
        // 注意该构造函数中将该异常解析器的优先级设置为最低
        setOrder(Ordered.LOWEST_PRECEDENCE);
        setWarnLogCategory(getClass().getName());
    }


    // 根据参数 ex 异常对象的类型解析参数，将其转换成一个 ModelAndView 对象返回，
    // 并且注意该过程中涉及到对 response 头部的设置，已经对其调用  sendError() .
    // 如果参数 ex 不能被当前异常处理器处理，返回 null
    // 该方法对基类定义的该方法提供了实现，该方法会被基类公开方法 resolveException() 使用，
    // resolveException() 是接口 HandlerExceptionResolver 所定义的方法
    @Override
    @Nullable
    protected ModelAndView doResolveException(
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, 
            Exception ex) {

        try {
            if (ex instanceof HttpRequestMethodNotSupportedException) {
                return handleHttpRequestMethodNotSupported(
                        (HttpRequestMethodNotSupportedException) ex, request, response, handler);
            }
            else if (ex instanceof HttpMediaTypeNotSupportedException) {
                return handleHttpMediaTypeNotSupported(
                        (HttpMediaTypeNotSupportedException) ex, request, response, handler);
            }
            else if (ex instanceof HttpMediaTypeNotAcceptableException) {
                return handleHttpMediaTypeNotAcceptable(
                        (HttpMediaTypeNotAcceptableException) ex, request, response, handler);
            }
            else if (ex instanceof MissingPathVariableException) {
                return handleMissingPathVariable(
                        (MissingPathVariableException) ex, request, response, handler);
            }
            else if (ex instanceof MissingServletRequestParameterException) {
                return handleMissingServletRequestParameter(
                        (MissingServletRequestParameterException) ex, request, response, handler);
            }
            else if (ex instanceof ServletRequestBindingException) {
                return handleServletRequestBindingException(
                        (ServletRequestBindingException) ex, request, response, handler);
            }
            else if (ex instanceof ConversionNotSupportedException) {
                return handleConversionNotSupported(
                        (ConversionNotSupportedException) ex, request, response, handler);
            }
            else if (ex instanceof TypeMismatchException) {
                return handleTypeMismatch(
                        (TypeMismatchException) ex, request, response, handler);
            }
            else if (ex instanceof HttpMessageNotReadableException) {
                return handleHttpMessageNotReadable(
                        (HttpMessageNotReadableException) ex, request, response, handler);
            }
            else if (ex instanceof HttpMessageNotWritableException) {
                return handleHttpMessageNotWritable(
                        (HttpMessageNotWritableException) ex, request, response, handler);
            }
            else if (ex instanceof MethodArgumentNotValidException) {
                return handleMethodArgumentNotValidException(
                        (MethodArgumentNotValidException) ex, request, response, handler);
            }
            else if (ex instanceof MissingServletRequestPartException) {
                return handleMissingServletRequestPartException(
                        (MissingServletRequestPartException) ex, request, response, handler);
            }
            else if (ex instanceof BindException) {
                return handleBindException((BindException) ex, request, response, handler);
            }
            else if (ex instanceof NoHandlerFoundException) {
                return handleNoHandlerFoundException(
                        (NoHandlerFoundException) ex, request, response, handler);
            }
            else if (ex instanceof AsyncRequestTimeoutException) {
                return handleAsyncRequestTimeoutException(
                        (AsyncRequestTimeoutException) ex, request, response, handler);
            }
        }
        catch (Exception handlerEx) {
            if (logger.isWarnEnabled()) {
                logger.warn("Failure while trying to resolve exception [" 
                + ex.getClass().getName() + "]", handlerEx);
            }
        }
        return null;
    }

    /**
     * Handle the case where no request handler method was found for the particular HTTP request 
     * method.
     * The default implementation logs a warning, sends an HTTP 405 error, sets the "Allow" header,
     * and returns an empty ModelAndView. Alternatively, a fallback view could be chosen,
     * or the HttpRequestMethodNotSupportedException could be rethrown as-is.
     * @param ex the HttpRequestMethodNotSupportedException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler, or null if none chosen
     * at the time of the exception (for example, if multipart resolution failed)
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleHttpRequestMethodNotSupported(
            HttpRequestMethodNotSupportedException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        String[] supportedMethods = ex.getSupportedMethods();
        if (supportedMethods != null) {
            response.setHeader("Allow", StringUtils.arrayToDelimitedString(supportedMethods, ", "));
        }
        response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, ex.getMessage());
        return new ModelAndView();
    }

    /**
     * Handle the case where no org.springframework.http.converter.HttpMessageConverter message 
     * converters were found for the PUT or POSTed content.
     * The default implementation sends an HTTP 415 error, sets the "Accept" header,
     * and returns an empty ModelAndView. Alternatively, a fallback view could
     * be chosen, or the HttpMediaTypeNotSupportedException could be rethrown as-is.
     * @param ex the HttpMediaTypeNotSupportedException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleHttpMediaTypeNotSupported(HttpMediaTypeNotSupportedException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_UNSUPPORTED_MEDIA_TYPE);
        List<MediaType> mediaTypes = ex.getSupportedMediaTypes();
        if (!CollectionUtils.isEmpty(mediaTypes)) {
            response.setHeader("Accept", MediaType.toString(mediaTypes));
        }
        return new ModelAndView();
    }

    /**
     * Handle the case where no org.springframework.http.converter.HttpMessageConverter message 
     * converters
     * were found that were acceptable for the client (expressed via the Accept header.
     * The default implementation sends an HTTP 406 error and returns an empty ModelAndView.
     * Alternatively, a fallback view could be chosen, or the HttpMediaTypeNotAcceptableException
     * could be rethrown as-is.
     * @param ex the HttpMediaTypeNotAcceptableException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleHttpMediaTypeNotAcceptable(HttpMediaTypeNotAcceptableException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_NOT_ACCEPTABLE);
        return new ModelAndView();
    }

    /**
     * Handle the case when a declared path variable does not match any extracted URI variable.
     * The default implementation sends an HTTP 500 error, and returns an empty ModelAndView.
     * Alternatively, a fallback view could be chosen, or the MissingPathVariableException
     * could be rethrown as-is.
     * @param ex the MissingPathVariableException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     * @since 4.2
     */
    protected ModelAndView handleMissingPathVariable(MissingPathVariableException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, ex.getMessage());
        return new ModelAndView();
    }

    /**
     * Handle the case when a required parameter is missing.
     * The default implementation sends an HTTP 400 error, and returns an empty ModelAndView.
     * Alternatively, a fallback view could be chosen, or the MissingServletRequestParameterException
     * could be rethrown as-is.
     * @param ex the MissingServletRequestParameterException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleMissingServletRequestParameter(
            MissingServletRequestParameterException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage());
        return new ModelAndView();
    }

    /**
     * Handle the case when an unrecoverable binding exception occurs - e.g. required header, 
     * required cookie.
     * The default implementation sends an HTTP 400 error, and returns an empty ModelAndView.
     * Alternatively, a fallback view could be chosen, or the exception could be rethrown as-is.
     * @param ex the exception to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleServletRequestBindingException(ServletRequestBindingException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage());
        return new ModelAndView();
    }

    /**
     * Handle the case when a org.springframework.web.bind.WebDataBinder conversion cannot occur.
     * The default implementation sends an HTTP 500 error, and returns an empty ModelAndView.
     * Alternatively, a fallback view could be chosen, or the ConversionNotSupportedException could be
     * rethrown as-is.
     * @param ex the ConversionNotSupportedException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleConversionNotSupported(ConversionNotSupportedException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        sendServerError(ex, request, response);
        return new ModelAndView();
    }

    /**
     * Handle the case when a org.springframework.web.bind.WebDataBinder conversion error occurs.
     * The default implementation sends an HTTP 400 error, and returns an empty ModelAndView.
     * Alternatively, a fallback view could be chosen, or the TypeMismatchException could be 
     * rethrown as-is.
     * @param ex the TypeMismatchException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleTypeMismatch(TypeMismatchException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return new ModelAndView();
    }

    /**
     * Handle the case where a org.springframework.http.converter.HttpMessageConverter message 
     * converter cannot read from a HTTP request.
     * The default implementation sends an HTTP 400 error, and returns an empty ModelAndView.
     * Alternatively, a fallback view could be chosen, or the HttpMessageNotReadableException could be
     * rethrown as-is.
     * @param ex the HttpMessageNotReadableException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleHttpMessageNotReadable(HttpMessageNotReadableException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return new ModelAndView();
    }

    /**
     * Handle the case where a
     * org.springframework.http.converter.HttpMessageConverter message converter
     * cannot write to a HTTP request.
     * The default implementation sends an HTTP 500 error, and returns an empty ModelAndView.
     * Alternatively, a fallback view could be chosen, or the HttpMessageNotWritableException could
     * be rethrown as-is.
     * @param ex the HttpMessageNotWritableException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleHttpMessageNotWritable(HttpMessageNotWritableException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        sendServerError(ex, request, response);
        return new ModelAndView();
    }

    /**
     * Handle the case where an argument annotated with @Valid such as
     * an RequestBody or RequestPart argument fails validation.
     * By default, an HTTP 400 error is sent back to the client.
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleMethodArgumentNotValidException(MethodArgumentNotValidException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return new ModelAndView();
    }

    /**
     * Handle the case where an RequestPart @RequestPart, a MultipartFile,
     * or a javax.servlet.http.Part argument is required but is missing.
     * By default, an HTTP 400 error is sent back to the client.
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleMissingServletRequestPartException(
            MissingServletRequestPartException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        response.sendError(HttpServletResponse.SC_BAD_REQUEST, ex.getMessage());
        return new ModelAndView();
    }

    /**
     * Handle the case where an ModelAttribute @ModelAttribute method
     * argument has binding or validation errors and is not followed by another
     * method argument of type BindingResult.
     * By default, an HTTP 400 error is sent back to the client.
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     */
    protected ModelAndView handleBindException(BindException ex, HttpServletRequest request,
            HttpServletResponse response, @Nullable Object handler) throws IOException {

        response.sendError(HttpServletResponse.SC_BAD_REQUEST);
        return new ModelAndView();
    }

    /**
     * Handle the case where no handler was found during the dispatch.
     * The default implementation sends an HTTP 404 error and returns an empty
     * ModelAndView. Alternatively, a fallback view could be chosen,
     * or the NoHandlerFoundException could be rethrown as-is.
     * @param ex the NoHandlerFoundException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler, or null if none chosen
     * at the time of the exception (for example, if multipart resolution failed)
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     * @since 4.0
     */
    protected ModelAndView handleNoHandlerFoundException(NoHandlerFoundException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        pageNotFoundLogger.warn(ex.getMessage());
        response.sendError(HttpServletResponse.SC_NOT_FOUND);
        return new ModelAndView();
    }

    /**
     * Handle the case where an async request timed out.
     * The default implementation sends an HTTP 503 error.
     * @param ex the AsyncRequestTimeoutException to be handled
     * @param request current HTTP request
     * @param response current HTTP response
     * @param handler the executed handler, or null if none chosen
     * at the time of the exception (for example, if multipart resolution failed)
     * @return an empty ModelAndView indicating the exception was handled
     * @throws IOException potentially thrown from HttpServletResponse#sendError
     * @since 4.2.8
     */
    protected ModelAndView handleAsyncRequestTimeoutException(AsyncRequestTimeoutException ex,
            HttpServletRequest request, HttpServletResponse response, @Nullable Object handler) 
            throws IOException {

        if (!response.isCommitted()) {
            response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE);
        }
        else {
            logger.warn("Async request timed out");
        }
        return new ModelAndView();
    }

    /**
     * Invoked to send a server error. Sets the status to 500 and also sets the
     * request attribute "javax.servlet.error.exception" to the Exception.
     */
    protected void sendServerError(Exception ex, HttpServletRequest request, 
            HttpServletResponse response) throws IOException {

        request.setAttribute("javax.servlet.error.exception", ex);
        response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
    }

}

是Spring MVC的前端控制器DispatcherServlet缺省启用的HandlerExceptionResolver之一，并且被设置为最低优先级；是Spring MVC配置机制WebMvcConfigurationSupport缺省定义的一个HandlerExceptionResolver。

异常与HTTP状态码的对应关系如下：

 异常间的关系

框架默认添加的ExceptionResolver

（参阅：https://blog.csdn.net/andy_zhang2007/article/details/88594332）

Spring MVC的缺省配置类WebMvcConfigurationSupport定义了一组HandlerExceptionResolver组件到容器，供Spring MVC运行时使用，具体来讲，是被DispatcherServlet使用。

在实现上，是将框架默认的或开发者自定义添加的HandlerExceptionResolver列表包装成HandlerExceptionResolverComposite并返回。见WebMvcConfigurationSupport.handlerExceptionResolver方法，其将框架默认的或用户自定义的Resolver加入其中。相关源码：

    public HandlerExceptionResolver handlerExceptionResolver() {
        List<HandlerExceptionResolver> exceptionResolvers = new ArrayList<>();
        configureHandlerExceptionResolvers(exceptionResolvers);// 让子类指定自己的HandlerExceptionResolver到exceptionResolvers
        if (exceptionResolvers.isEmpty()) {
    addDefaultHandlerExceptionResolvers(exceptionResolvers);// 若子类未自己指定则框架添加默认的HandlerExceptionResolver到exceptionResolvers
        }
        extendHandlerExceptionResolvers(exceptionResolvers);// 让子类指定更多自己的HandlerExceptionResolver到exceptionResolvers，或修改已由的exceptionResolver内容
        HandlerExceptionResolverComposite composite = new HandlerExceptionResolverComposite();
        composite.setOrder(0);
        composite.setExceptionResolvers(exceptionResolvers);
        return composite;
    }

默认情况下SpringMVC框架会添加第1、2、4个resolver，添加的逻辑在WebMvcConfigurationSupport.addDefaultHandlerExceptionResolvers方法中，相关源码：

    protected final void addDefaultHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
        ExceptionHandlerExceptionResolver exceptionHandlerResolver = createExceptionHandlerExceptionResolver();
        exceptionHandlerResolver.setContentNegotiationManager(mvcContentNegotiationManager());
        exceptionHandlerResolver.setMessageConverters(getMessageConverters());
        exceptionHandlerResolver.setCustomArgumentResolvers(getArgumentResolvers());
        exceptionHandlerResolver.setCustomReturnValueHandlers(getReturnValueHandlers());
        if (jackson2Present) {
            exceptionHandlerResolver.setResponseBodyAdvice(
                    Collections.singletonList(new JsonViewResponseBodyAdvice()));
        }
        if (this.applicationContext != null) {
            exceptionHandlerResolver.setApplicationContext(this.applicationContext);
        }
        exceptionHandlerResolver.afterPropertiesSet();
        exceptionResolvers.add(exceptionHandlerResolver);

        ResponseStatusExceptionResolver responseStatusResolver = new ResponseStatusExceptionResolver();
        responseStatusResolver.setMessageSource(this.applicationContext);
        exceptionResolvers.add(responseStatusResolver);

        exceptionResolvers.add(new DefaultHandlerExceptionResolver());
    }

  

SpringMVC中的全局异常处理

通常可通过实现HandlerExceptionResolver接口并声明为Bean即可实现“全局”异常拦截，但实际上这里的“全局”并非真的全局，其只能处理Controller中的handler方法（或其调用的方法）抛出的异常，对于其他非Controller handler方法调用产生的异常，如404、Servlet filter所抛的异常（如Spring Security authenticateFail时抛的异常）则无法处理。

那如何做到真正的全局？这就需要了解下SpringBoot中的异常处理机制。

关键类：

HandlerExceptionResolver：SpringMVC定义的处理handler异常的接口抽象。

DefaultErrorAttributes：SpringBoot定义的处理错误属性的默认类，ErrorAttributes接口的默认实现。默认的SpringBoot异常信息包含error、timestamp、status、message等属性即由此定义。

BasicErrorController：SpringBoot定义的用于处理异常的类。

1) 对于非Controller handler所抛的异常

web应用容器（如Tomcat）会在发生异常后将异常记录到request attribute（request.setAttribute）中，并将当前请求forward到错误页面（默认是"/error"）。记录到request的属性（相关定义在javax.servlet.RequestDispatcher接口中）包括：

javax.servlet.error.request_uri：String类型

javax.servlet.error.exception：Throwable类型

javax.servlet.error.message：String类型

javax.servlet.error.status_code：Integer类型

相关源码：

    private void exception(Request request, Response response,
                           Throwable exception) {
        request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, exception);
        response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        response.setError();
    }

而SpringBoot中有个BasicErrorController，专门用来处理对错误页面的请求。其主要逻辑是从DefaultErrorAttributes获取记录到request的attribute信息（DefaultErrorAttributes.getErrorAttributes）并包装成自定义的格式返回，该格式包括timestamp、status、error、message、path等字段。当项目出现异常且我们未做任何异常处理时，我们会发现返回了json格式的数据，就是这里起的作用。相关源码：

//BasicErrorController


    @RequestMapping(produces = MediaType.TEXT_HTML_VALUE)
    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
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.ALL));
        HttpStatus status = getStatus(request);
        return new ResponseEntity<>(body, status);
    }

2) 对于Conotroller handler所抛异常

由注册到Spring容器的各HandlerExceptionResolver Bean来处理的。

值得注意的是，默认情况下，DefaultErrorAttributes也会被注册为一个HandlerExceptionResolver Bean（因为其也实现了HandlerExceptionResolver接口）且该Bean优先级最高！DefaultErrorAttributes的resolveException逻辑是将当前异常绑定到request以供后面的HandlerExceptionResolver处理。相关源码：

//DefaultErrorAttributes

    @Override
    public ModelAndView resolveException(HttpServletRequest request,
            HttpServletResponse response, Object handler, Exception ex) {
        storeErrorAttributes(request, ex);
        return null;
    }

    private void storeErrorAttributes(HttpServletRequest request, Exception ex) {
        request.setAttribute(ERROR_ATTRIBUTE, ex);
    }

综上可知，为了做到真正的异常全局拦截处理，可以实现自定义的ErrorAttributes以替换DefaultErrorAttributes，并重写其resolveException、getErrorAttributes方法来完成，两个方法分别对应Controller handler和非Controller handler异常的处理。

参考资料：https://blog.csdn.net/andy_zhang2007/article/details/89048854 

 

 

HttpMessageConverter

SpringMVC默认使用的HttpMessageConverter：

 

相关配置代码在 WebMvcConfigurationSupport#addDefaultHttpMessageConverters ：

static {
        ClassLoader classLoader = WebMvcConfigurationSupport.class.getClassLoader();
        
        romePresent = ClassUtils.isPresent("com.rometools.rome.feed.WireFeed", classLoader);
        
        jaxb2Present = ClassUtils.isPresent("javax.xml.bind.Binder", classLoader);
        
        jackson2Present = ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper", 
                classLoader) &&    ClassUtils.isPresent(
                "com.fasterxml.jackson.core.JsonGenerator", 
                classLoader);
        
        jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", 
            classLoader);
        
        jackson2SmilePresent = ClassUtils.isPresent(
            "com.fasterxml.jackson.dataformat.smile.SmileFactory", 
            classLoader);
        
        jackson2CborPresent = ClassUtils.isPresent(
            "com.fasterxml.jackson.dataformat.cbor.CBORFactory", 
            classLoader);
        
        gsonPresent = ClassUtils.isPresent("com.google.gson.Gson", classLoader);
        
        jsonbPresent = ClassUtils.isPresent("javax.json.bind.Jsonb", classLoader);
    }




/**
     * Adds a set of default HttpMessageConverter instances to the given list.
     * Subclasses can call this method from #configureMessageConverters.
     * @param messageConverters the list to add the default message converters to
     */
    protected final void addDefaultHttpMessageConverters(
        List<HttpMessageConverter<?>> messageConverters) {
        StringHttpMessageConverter stringHttpMessageConverter = new StringHttpMessageConverter();
        stringHttpMessageConverter.setWriteAcceptCharset(false);  // see SPR-7316

        messageConverters.add(new ByteArrayHttpMessageConverter());
        messageConverters.add(stringHttpMessageConverter);
        messageConverters.add(new ResourceHttpMessageConverter());
        messageConverters.add(new ResourceRegionHttpMessageConverter());
        try {
            messageConverters.add(new SourceHttpMessageConverter<>());
        }
        catch (Throwable ex) {
            // Ignore when no TransformerFactory implementation is available...
        }
        messageConverters.add(new AllEncompassingFormHttpMessageConverter());

        if (romePresent) {
            messageConverters.add(new AtomFeedHttpMessageConverter());
            messageConverters.add(new RssChannelHttpMessageConverter());
        }

        if (jackson2XmlPresent) {
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.xml();
            if (this.applicationContext != null) {
                builder.applicationContext(this.applicationContext);
            }
            messageConverters.add(new MappingJackson2XmlHttpMessageConverter(builder.build()));
        }
        else if (jaxb2Present) {
            messageConverters.add(new Jaxb2RootElementHttpMessageConverter());
        }

        if (jackson2Present) {
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.json();
            if (this.applicationContext != null) {
                builder.applicationContext(this.applicationContext);
            }
            messageConverters.add(new MappingJackson2HttpMessageConverter(builder.build()));
        }
        else if (gsonPresent) {
            messageConverters.add(new GsonHttpMessageConverter());
        }
        else if (jsonbPresent) {
            messageConverters.add(new JsonbHttpMessageConverter());
        }

        if (jackson2SmilePresent) {
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.smile();
            if (this.applicationContext != null) {
                builder.applicationContext(this.applicationContext);
            }
            messageConverters.add(new MappingJackson2SmileHttpMessageConverter(builder.build()));
        }
        if (jackson2CborPresent) {
            Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.cbor();
            if (this.applicationContext != null) {
                builder.applicationContext(this.applicationContext);
            }
            messageConverters.add(new MappingJackson2CborHttpMessageConverter(builder.build()));
        }
    }

 

 

 

 

转自：https://www.cnblogs.com/xiaoxi/p/6164383.html，以下为正文。

 

SpringMVC的工作原理图：

SpringMVC流程

1、  用户发送请求至前端控制器DispatcherServlet。

2、  DispatcherServlet收到请求调用HandlerMapping处理器映射器。

3、  处理器映射器找到具体的处理器(可以根据xml配置、注解进行查找)，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet。

4、  DispatcherServlet调用HandlerAdapter处理器适配器。

5、  HandlerAdapter经过适配调用具体的处理器(Controller，也叫后端控制器)。

6、  Controller执行完成返回ModelAndView。

7、  HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet。

8、  DispatcherServlet将ModelAndView传给ViewReslover视图解析器。

9、  ViewReslover解析后返回具体View。

10、DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。

11、 DispatcherServlet响应用户。

组件说明：

以下组件通常使用框架提供实现：

DispatcherServlet：作为前端控制器，整个流程控制的中心，控制其它组件执行，统一调度，降低组件之间的耦合性，提高每个组件的扩展性。

HandlerMapping：通过扩展处理器映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。 

HandlAdapter：通过扩展处理器适配器，支持更多类型的处理器。

ViewResolver：通过扩展视图解析器，支持更多类型的视图解析，例如：jsp、freemarker、pdf、excel等。

组件：
1、前端控制器DispatcherServlet（不需要工程师开发）,由框架提供
作用：接收请求，响应结果，相当于转发器，中央处理器。有了dispatcherServlet减少了其它组件之间的耦合度。
用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

2、处理器映射器HandlerMapping(不需要工程师开发),由框架提供
作用：根据请求的url查找Handler
HandlerMapping负责根据用户请求找到Handler即处理器，springmvc提供了不同的映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

3、处理器适配器HandlerAdapter
作用：按照特定规则（HandlerAdapter要求的规则）去执行Handler
通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

4、处理器Handler(需要工程师开发)
注意：编写Handler时按照HandlerAdapter的要求去做，这样适配器才可以去正确执行Handler
Handler 是继DispatcherServlet前端控制器的后端控制器，在DispatcherServlet的控制下Handler对具体的用户请求进行处理。
由于Handler涉及到具体的用户业务请求，所以一般情况需要工程师根据业务需求开发Handler。

5、视图解析器View resolver(不需要工程师开发),由框架提供
作用：进行视图解析，根据逻辑视图名解析成真正的视图（view）
View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。 springmvc框架提供了很多的View视图类型，包括：jstlView、freemarkerView、pdfView等。
一般情况下需要通过页面标签或页面模版技术将模型数据通过页面展示给用户，需要由工程师根据业务需求开发具体的页面。

6、视图View(需要工程师开发jsp...)
View是一个接口，实现类支持不同的View类型（jsp、freemarker、pdf...）

核心架构的具体流程步骤如下：
1、首先用户发送请求——>DispatcherServlet，前端控制器收到请求后自己不进行处理，而是委托给其他的解析器进行处理，作为统一访问点，进行全局的流程控制；
2、DispatcherServlet——>HandlerMapping， HandlerMapping 将会把请求映射为HandlerExecutionChain 对象（包含一个Handler 处理器（页面控制器）对象、多个HandlerInterceptor 拦截器）对象，通过这种策略模式，很容易添加新的映射策略；
3、DispatcherServlet——>HandlerAdapter，HandlerAdapter 将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；
4、HandlerAdapter——>处理器功能处理方法的调用，HandlerAdapter 将会根据适配的结果调用真正的处理器的功能处理方法，完成功能处理；并返回一个ModelAndView 对象（包含模型数据、逻辑视图名）；
5、ModelAndView的逻辑视图名——> ViewResolver， ViewResolver 将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；
6、View——>渲染，View会根据传进来的Model模型数据进行渲染，此处的Model实际是一个Map数据结构，因此很容易支持其他视图技术；
7、返回控制权给DispatcherServlet，由DispatcherServlet返回响应给用户，到此一个流程结束。

下边两个组件通常情况下需要开发：

Handler：处理器，即后端控制器用controller表示。

View：视图，即展示给用户的界面，视图中通常需要标签语言展示模型数据。

 

在将SpringMVC之前我们先来看一下什么是MVC模式

MVC：MVC是一种设计模式

MVC的原理图：

分析：

M-Model 模型（完成业务逻辑：有javaBean构成，service+dao+entity）

V-View 视图（做界面的展示  jsp，html……）

C-Controller 控制器（接收请求—>调用模型—>根据结果派发页面）

 

springMVC是什么： 

　　springMVC是一个MVC的开源框架，springMVC=struts2+spring，springMVC就相当于是Struts2加上sring的整合，但是这里有一个疑惑就是，springMVC和spring是什么样的关系呢？这个在百度百科上有一个很好的解释：意思是说，springMVC是spring的一个后续产品，其实就是spring在原有基础上，又提供了web应用的MVC模块，可以简单的把springMVC理解为是spring的一个模块（类似AOP，IOC这样的模块），网络上经常会说springMVC和spring无缝集成，其实springMVC就是spring的一个子模块，所以根本不需要同spring进行整合。

SpringMVC的原理图：

看到这个图大家可能会有很多的疑惑，现在我们来看一下这个图的步骤：（可以对比MVC的原理图进行理解）

第一步:用户发起请求到前端控制器（DispatcherServlet）

第二步：前端控制器请求处理器映射器（HandlerMappering）去查找处理器（Handle）：通过xml配置或者注解进行查找

第三步：找到以后处理器映射器（HandlerMappering）像前端控制器返回执行链（HandlerExecutionChain）

第四步：前端控制器（DispatcherServlet）调用处理器适配器（HandlerAdapter）去执行处理器（Handler）

第五步：处理器适配器去执行Handler

第六步：Handler执行完给处理器适配器返回ModelAndView

第七步：处理器适配器向前端控制器返回ModelAndView

第八步：前端控制器请求视图解析器（ViewResolver）去进行视图解析

第九步：视图解析器像前端控制器返回View

第十步：前端控制器对视图进行渲染

第十一步：前端控制器向用户响应结果

看到这些步骤我相信大家很感觉非常的乱，这是正常的，但是这里主要是要大家理解springMVC中的几个组件：

前端控制器（DispatcherServlet）：接收请求，响应结果，相当于电脑的CPU。

处理器映射器（HandlerMapping）：根据URL去查找处理器

处理器（Handler）：（需要程序员去写代码处理逻辑的）

处理器适配器（HandlerAdapter）：会把处理器包装成适配器，这样就可以支持多种类型的处理器，类比笔记本的适配器（适配器模式的应用）

视图解析器（ViewResovler）：进行视图解析，多返回的字符串，进行处理，可以解析成对应的页面