一、前言

版本：

springMVC 5.0.2RELEASE

JDK1.8

前端控制器的配置：

web.xml

    <!--配置前端控制器-->

    <servlet>

        <servlet-name>dispatcherServlet</servlet-name>

        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <init-param>

            <param-name>contextConfigLocation</param-name>

            <!--加载类路径下的配置文件-->

            <param-value>classpath:springmvc.xml</param-value>

        </init-param>

        <!--服务器启动时创建对象,值越小,优先级越高,越先创建对象-->

        <load-on-startup>1</load-on-startup>

    </servlet>

    <servlet-mapping>

        <servlet-name>dispatcherServlet</servlet-name>

        <!--注意不是/*,而是，因为/*还会拦截*.jsp等请求-->

        <url-pattern>/</url-pattern>

    </servlet-mapping>

springmvc.xml配置

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:mvc="http://www.springframework.org/schema/mvc"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xsi:schemaLocation="

        http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 开启注解扫描 -->

    <context:component-scan base-package="com.smday"/>

    <!-- 视图解析器对象 -->

    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">

        <property name="prefix" value="/WEB-INF/pages/"/>

        <property name="suffix" value=".jsp"/>

    </bean>

    <!-- 开启SpringMVC框架注解的支持 -->

    <mvc:annotation-driven/>

    <!--放行静态资源-->

    <mvc:default-servlet-handler/>

</beans>

二、初始化

DispatcherServlet的启动与Servlet的启动过程紧密联系，我们通过以上继承图就可以发现。

1. 容器初始化

Servlet中定义的init()方法就是其生命周期的初始化方法，接着往下走，GenericServlet并没有给出具体实现，在HttpServletBean中的init()方法给出了具体的实现：

HttpServletBean.init()方法（忽略日志）

	@Override

	public final void init() throws ServletException {

        //根据初始化参数设置bean属性(我们设置了contextConfigLocation，故可以获取)

		PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);

		if (!pvs.isEmpty()) {

			try {

                //包装DispatcherServlet

				BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);

                //获取资源加载器，用以加载springMVC的配置文件

				ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());

                //注册一个ResourceEditor

				bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));

                //该方法为空实现，可以重写，初始化BeanWrapper

				initBeanWrapper(bw);

                //最终将init-param读取的值spirng-mvc.xml存入contextConfigLocation中

				bw.setPropertyValues(pvs, true);

			}

		}

		// 让子类实现初始化

		initServletBean();

	}

那就来看看FrameworfServlet.initServletBean()干了啥（基本都是日志记录，还有计时，省略了这些部分）：

	/**

	 * Overridden method of {@link HttpServletBean}, invoked after any bean properties

	 * have been set. Creates this servlet's WebApplicationContext.

	 */

	@Override

	protected final void initServletBean() throws ServletException {

        //WebApplicationContext的初始化

        this.webApplicationContext = initWebApplicationContext();

        //也是空实现，允许子类自定义

        initFrameworkServlet();

	}

所以重头戏就在initWebApplicationContext方法上，我们可以先来看看执行后的效果：

可以看到springMVC九大组件被赋值，除此之外webApplicationContext也已被赋值。

我们再来看看源码，看看其内部具体实现：FrameworkServlet.initWebApplicationContext()

protected WebApplicationContext initWebApplicationContext() {

    //根容器查找

    WebApplicationContext rootContext =

        WebApplicationContextUtils.getWebApplicationContext(getServletContext());

    WebApplicationContext wac = null;

    if (this.webApplicationContext != null) {

        //在构建时注入了DispatcherServlet并且webApplicationContext已经存在->直接使用

        wac = this.webApplicationContext;

        if (wac instanceof ConfigurableWebApplicationContext) {

            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;

            if (!cwac.isActive()) {

                //如果context还没有refresh-->进行设置父级context以及application context的id等等操作

                if (cwac.getParent() == null) {

                    //在没有显式父级的情况下注入了context实例->将根应用程序上下文设置为父级

                    cwac.setParent(rootContext);

                }

                configureAndRefreshWebApplicationContext(cwac);

            }

        }

    }

    if (wac == null) {

		//在构造时未注入任何上下文实例-->从ServletContext中查询

        wac = findWebApplicationContext();

    }

    if (wac == null) {

        // ServletContext中没有-->就创建一个被本地的

        wac = createWebApplicationContext(rootContext);

    }

    if (!this.refreshEventReceived) {

        //如果context不支持refresh或者在初始化的时候已经refresh-->就手动触发onfresh

        onRefresh(wac);

    }

    //把当前建立的上下文存入ServletContext中，使用的属性名和当前Servlet名相关

    if (this.publishContext) {

        // 将上下文发布为servlet上下文属性

        String attrName = getServletContextAttributeName();

        getServletContext().setAttribute(attrName, wac);

    }

    return wac;

}

根容器查找的方法

WebApplicationContext rootContext =

    WebApplicationContextUtils.getWebApplicationContext(getServletContext());

WebApplicationContextUtils.getWebApplicationContext

//SpringMVC支持Spring容器与Web容易同时存在，并且Spring容器视作根容器，通常由ContextLoaderListener进行加载。

@Nullable

public static WebApplicationContext getWebApplicationContext(ServletContext sc) {

    //String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT"

    return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

}

@Nullable

public static WebApplicationContext getWebApplicationContext(ServletContext sc, String attrName) {

	//根据ServletName.ROOT为键查找值

    Object attr = sc.getAttribute(attrName);

    if (attr == null) {

        return null;

    return (WebApplicationContext) attr;

}

Spring容器和Web容器如果同时存在，需要使用ContextLoaderListener加载Spring的配置，且它会以key为

WebApplicationContext.class.getName() + ".ROOT存到ServletContext中。

容器创建的方法

构建的时候没有任何Context实例注入，且ServletContext中也没有找到WebApplicationContext，此时就会创建一个local Context，这个方法允许显式传入父级容器作为参数。

protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {

    //默认：DEFAULT_CONTEXT_CLASS = XmlWebApplicationContext.class;可以在初始化参数中指定contextClass

    Class<?> contextClass = getContextClass();

    if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {

        throw new ApplicationContextException(

            "Fatal initialization error in servlet with name '" + getServletName() +

            "': custom WebApplicationContext class [" + contextClass.getName() +

            "] is not of type ConfigurableWebApplicationContext");

    }

    //获取ConfigurableWebApplicationContext对象

    ConfigurableWebApplicationContext wac =

        (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

    wac.setEnvironment(getEnvironment());

    wac.setParent(parent);

    String configLocation = getContextConfigLocation();

    if (configLocation != null) {

        wac.setConfigLocation(configLocation);

    }

    configureAndRefreshWebApplicationContext(wac);

    return wac;

}

我们可以发现：在这个过程中，Web容器的IoC容器被建立，也就是XmlWebApplicationContext，，从而在web容器中建立起整个spring应用。

configureAndRefreshWebApplicationContext(wac);

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {

    //省略给ConfigurableWebApplicationContext对象设置一些值...

    //每次context refresh，都会调用initPropertySources

    ConfigurableEnvironment env = wac.getEnvironment();

    if (env instanceof ConfigurableWebEnvironment) {

        ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());

    }

    postProcessWebApplicationContext(wac);

    applyInitializers(wac);

    //初始化webApplication容器，重启

    wac.refresh();

}

加载配置文件信息

其实也就是refresh()这个关键方法，之前了解过spring容器的初始化的过程，对这一步应该相当熟悉，还是分为三步：

• BeanDefinition的Resource的定位，我们这定位到了classpath:springmvc.xml。

• beanDefinition的载入过程，springMVC做了一些改变，比如定义了针对mvc的命名空间解析MvcNamespaceHandler。

• 接着是beanDefinition在IoC中的注册，也就是把beanName：beanDefinition以键值对的形式存入beandefinitionMap中。

2. MVC的初始化

MVC的初始化在DispatcherServlet的initStratefies方法中执行，通过方法名，我们就可以得出结论，就是在这进行了对九大组件的初始化，其实基本上都是从IoC容器中获取对象：

	protected void initStrategies(ApplicationContext context) {

        //文件上传解析器

		initMultipartResolver(context);

        //区域信息解析器，与国际化相关

		initLocaleResolver(context);

        //主题解析器

		initThemeResolver(context);

        //handler映射信息解析

		initHandlerMappings(context);

        //handler的适配器

		initHandlerAdapters(context);

        //handler异常解析器

		initHandlerExceptionResolvers(context);

        //视图名转换器

		initRequestToViewNameTranslator(context);

        //视图解析器

		initViewResolvers(context);

        //flashMap管理器

		initFlashMapManager(context);

	}

文件上传解析器

private void initMultipartResolver(ApplicationContext context) {

    try {

        this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);

    }

    catch (NoSuchBeanDefinitionException ex) {

        // 默认是没有配置multipartResolver的.

        this.multipartResolver = null;

    }

}

配置文件上传解析器也很简单，只需要在容器中注册MultipartResolver即可开启文件上传功能。

区域信息解析器

private void initLocaleResolver(ApplicationContext context) {

    try {

        this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);

    }

    catch (NoSuchBeanDefinitionException ex) {

        // 使用默认策略,利用反射创建对象

        this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);

    }

}

org.springframework.web.servlet.DispatcherServlet同级目录下的DispatcherServlet.properties文件中规定了几大组件初始化的默认策略。

handler映射信息解析

handlerMappings存在的意义在于为HTTP请求找到对应的控制器Controller。

	private void initHandlerMappings(ApplicationContext context) {

		this.handlerMappings = null;

		//从所有的IoC容器中导入HandlerMappings，包括其双亲上下文

		if (this.detectAllHandlerMappings) {

			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.

			}

		}

        //保证至少有一个handlerMapping

		if (this.handlerMappings == null) {

			this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);

		}

	}

接下来几个操作都差不多，就不赘述了。

总的来说，MVC初始化的过程建立在IoC容器初始化之后，毕竟要从容器中取出这些组件对象。

3. HandlerMapping的实现原理

HandlerExecutionChain

HandlerMapping在SpringMVC扮演着相当重要的角色，我们说，它可以为HTTP请求找到 对应的Controller控制器，于是，我们来好好研究一下，这里面到底藏着什么玩意。

HandlerMapping是一个接口，其中包含一个getHandler方法，能够通过该方法获得与HTTP请求对应的handlerExecutionChain，而这个handlerExecutionChain对象中持有handler和interceptorList，以及和设置拦截器相关的方法。可以判断是同通过这些配置的拦截器对handler对象提供的功能进行了一波增强。

RequestMappingHandlerMapping

我们以其中一个HandlerMapping作为例子解析一下，我们关注一下：

protected void initHandlerMethods() {

	//获取所有上下文中的beanName

    String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?

                          BeanFactoryUtils.beanNamesForTypeIncludingAncestors(obtainApplicationContext(), Object.class) :

                          obtainApplicationContext().getBeanNamesForType(Object.class));

    for (String beanName : beanNames) {

        if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {

            Class<?> beanType = null;

            //得到对应beanName的Class

            beanType = obtainApplicationContext().getType(beanName);

            //判断是否为控制器类

            if (beanType != null && isHandler(beanType)) {

                //对控制器中的方法进行处理

                detectHandlerMethods(beanName);

            }

        }

    }

    handlerMethodsInitialized(getHandlerMethods());

}

isHandler方法：判断该类是否存在@Controller注解或者@RequestMapping注解

	@Override

	protected boolean isHandler(Class<?> beanType) {

		return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||

				AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));

	}

detectHandlerMethods方法：

protected void detectHandlerMethods(final Object handler) {

    //获取到控制器的类型

    Class<?> handlerType = (handler instanceof String ?

                            obtainApplicationContext().getType((String) handler) : handler.getClass());

    if (handlerType != null) {

        //对类型再次进行处理，主要是针对cglib

        final Class<?> userType = ClassUtils.getUserClass(handlerType);

        //遍历方法，对注解中的信息进行处理，得到RequestMappingInfo对象，得到methods数组

        Map<Method, T> methods = MethodIntrospector.selectMethods(userType,

                                                                  (MethodIntrospector.MetadataLookup<T>) method -> {

      return getMappingForMethod(method, userType);

         });

        //遍历methods[Method,{path}]

        for (Map.Entry<Method, T> entry : methods.entrySet()) {

            //对方法的可访问性进行校验，如private，static，SpringProxy

            Method invocableMethod = AopUtils.selectInvocableMethod(entry.getKey(), userType);

            //获取最终请求路径

            T mapping = entry.getValue();

            //注册

            registerHandlerMethod(handler, invocableMethod, mapping);

        }

    }

}

mapping对象的属性：

methods对象中存储的元素：

注册方法在AbstractHandlerMethodMapping中实现：

public void register(T mapping, Object handler, Method method) {

    this.readWriteLock.writeLock().lock();

    try {

        //处理方法的对象

        HandlerMethod handlerMethod = createHandlerMethod(handler, method);

        //判断映射的唯一性

        assertUniqueMethodMapping(handlerMethod, mapping);

		//将mapping信息和控制器方法对应

        this.mappingLookup.put(mapping, handlerMethod);

		//将path与处理器映射（一个方法可能可以处理多个url）

        List<String> directUrls = getDirectUrls(mapping);

        for (String url : directUrls) {

            this.urlLookup.add(url, mapping);

        }

		//控制器名的大写英文缩写#方法名

        String name = null;

        if (getNamingStrategy() != null) {

            name = getNamingStrategy().getName(handlerMethod, mapping);

            addMappingName(name, handlerMethod);

        }

		//跨域请求相关配置

        CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);

        if (corsConfig != null) {

            this.corsLookup.put(handlerMethod, corsConfig);

        }

		//将所有配置统一注册到registry中

        this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));

    }

    finally {

        this.readWriteLock.writeLock().unlock();

    }

}

至此，所有的Controller，以及其中标注了@RequestMapping注解的方法，都被一一解析，注册进HashMap中，于是，对应请求路径与处理方法就一一匹配，此时HandlerMapping也初始化完成。

三、请求响应处理

1. 请求分发

我们需要明确的一个点是，请求过来的时候，最先执行的地方在哪，是Servlet的service方法，我们只需要看看该方法在子类中的一个实现即可：

FrameworkServlet重写的service方法：

	@Override

	protected void service(HttpServletRequest request, HttpServletResponse response)

			throws ServletException, IOException {

		//获取请求方法

		HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());

        //拦截PATCH请求

		if (HttpMethod.PATCH == httpMethod || httpMethod == null) {

			processRequest(request, response);

		}

		else {

			super.service(request, response);

		}

	}

其实最后都是调用了processRequest方法，该方法中又调用了真正的doService()方法，其中细节先不探讨，我们直奔，看看DispatcherServlet的这个doService干了哪些事情（DispatcherServlet这个类确实是核心中的核心，既建立了IoC容器，又负责请求分发）：

	@Override

	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {

	//忽略一大串前期准备，使其能够处理view 对象

    //接着进入真正的分发

	doDispatch(request, response);

	}

doService：

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {

    HttpServletRequest processedRequest = request;

    HandlerExecutionChain mappedHandler = null;

    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {

        ModelAndView mv = null;

        Exception dispatchException = null;

        try {

            //如果是文件上传请求，对request进行包装，如果不是就原样返回

            processedRequest = checkMultipart(request);

            //文件上传请求标识符

            multipartRequestParsed = (processedRequest != request);

            //为当前的request请求寻找合适的handler

            mappedHandler = getHandler(processedRequest);

            //如果没有handler可以处理该请求，就跳转到错误页面

            if (mappedHandler == null) {

                noHandlerFound(processedRequest, response);

                return;

            }

            //为当前的request请求寻找合适的adapter

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

            String method = request.getMethod();

            boolean isGet = "GET".equals(method);

            if (isGet || "HEAD".equals(method)) {

                //判断是否支持getLastModified，如果不支持，返回-1

                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());

                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {

                    return;

                }

            }

            //执行注册拦截器的preHandle方法

            if (!mappedHandler.applyPreHandle(processedRequest, response)) {

                return;

            }

            // 真正处理请求的方法

            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            if (asyncManager.isConcurrentHandlingStarted()) {

                return;

            }

			//如果mv!=null&&mv对象没有View，则为mv对象设置一个默认的ViewName

            applyDefaultViewName(processedRequest, mv);

            //执行注册拦截器的applyPostHandle方法

            mappedHandler.applyPostHandle(processedRequest, response, mv);

        }

        //进行视图解析和渲染

        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

}

需要注意的是，mappedHandler和HandlerAdapter都是从对应的集合中遍历查找，一旦找到可以执行的目标，就会停止查找，我们也可以人为定义优先级，决定他们之间的次序。

2. 请求处理

RequestMappingHandlerAdapter的handleInternal方法，含有真正处理请求的逻辑。

@Override

protected ModelAndView handleInternal(HttpServletRequest request,

                                      HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

    //定义返回值变量

    ModelAndView mav;

    //对请求进行检查 supportedMethods和requireSession

    checkRequest(request);

    // 看看synchronizeOnSession是否开启，默认为false

    if (this.synchronizeOnSession) {

        HttpSession session = request.getSession(false);

        //Httpsession可用

        if (session != null) {

            Object mutex = WebUtils.getSessionMutex(session);

            //加锁，所有请求串行化

            synchronized (mutex) {

                mav = invokeHandlerMethod(request, response, handlerMethod);

            }

        }

        else {

            // 没有可用的Httpsession -> 没必要上锁

            mav = invokeHandlerMethod(request, response, handlerMethod);

        }

    }

    else {

        // 正常调用处理方法

        mav = invokeHandlerMethod(request, response, handlerMethod);

    }

    //检查响应头是否包含Cache-Control

    if (!response.containsHeader(HEADER_CACHE_CONTROL)) {

        if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {

            applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);

        }

        else {

            prepareResponse(response);

        }

    }

    return mav;

}

RequestMappingHandlerAdapter的invokeHandlerMethod方法，真正返回mv。

@Nullable

protected ModelAndView invokeHandlerMethod(HttpServletRequest request,

                                           HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

    //对HttpServletRequest进行包装，产生ServletWebRequest处理web的request对象

    ServletWebRequest webRequest = new ServletWebRequest(request, response);

    try {

        //创建WebDataBinder对象的工厂

        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);

        //创建Model对象的工厂

        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

		//将handlerMethod对象进行包装，创建ServletInvocableHandlerMethod对象

        //向invocableMethod设置相关属性（最后是由invocableMethod对象调用invokeAndHandle方法

        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对象，里面存放有向域中存入数据的map

        ModelAndViewContainer mavContainer = new ModelAndViewContainer();

        mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));

        modelFactory.initModel(webRequest, mavContainer, invocableMethod);

        mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

        AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);

        asyncWebRequest.setTimeout(this.asyncRequestTimeout);

        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		//省略异步处理

        //正常调用

        invocableMethod.invokeAndHandle(webRequest, mavContainer);

        if (asyncManager.isConcurrentHandlingStarted()) {

            return null;

        }

		//获取ModelAndView对象

        return getModelAndView(mavContainer, modelFactory, webRequest);

    }

    finally {

        webRequest.requestCompleted();

    }

}

ServletInvocableHandlerMethod的invokeAndHandle方法：反射调用方法，得到返回值。

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

	//获取参数，通过反射得到返回值

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

    //设置响应状态

    setResponseStatus(webRequest);

    if (returnValue == null) {

        if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {

            mavContainer.setRequestHandled(true);

            return;

        }

    }

    else if (StringUtils.hasText(getResponseStatusReason())) {

        mavContainer.setRequestHandled(true);

        return;

    }

    mavContainer.setRequestHandled(false);

    Assert.state(this.returnValueHandlers != null, "No return value handlers");

    try {

        //处理返回值

        this.returnValueHandlers.handleReturnValue(

            returnValue, getReturnValueType(returnValue), mavContainer, webRequest);

    }

    catch (Exception ex) {

        if (logger.isTraceEnabled()) {

            logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);

        }

        throw ex;

    }

}

参数解析过程

我们可以知道的是，传递参数时，可以传递Map，基本类型，POJO，ModelMap等参数，解析之后的结果又如何呢？我们以一个具体的例子举例比较容易分析：

    @RequestMapping("/handle03/{id}")

    public String handle03(@PathVariable("id") String sid,

                           Map<String,Object> map){

        System.out.println(sid);

        map.put("msg","你好!");

        return "success";

    }

/**

 * 获取当前请求的方法参数值。

 */

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

    //获取参数对象

    MethodParameter[] parameters = getMethodParameters();

    //创建一个同等大小的数组存储参数值

    Object[] args = new Object[parameters.length];

    for (int i = 0; i < parameters.length; i++) {

        MethodParameter parameter = parameters[i];

        parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);

        args[i] = resolveProvidedArgument(parameter, providedArgs);

        if (args[i] != null) {

            continue;

        }

        if (this.argumentResolvers.supportsParameter(parameter)) {

            //参数处理器处理参数（针对不同类型的参数有不同类型的处理参数的策略）

            args[i] = this.argumentResolvers.resolveArgument(

                parameter, mavContainer, request, this.dataBinderFactory);

            continue;

        }

        if (args[i] == null) {

            throw new IllegalStateException();

    	}

    return args;

}

resolveArgument方法：

@Override

@Nullable

public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

	//获取注解的信息

    NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);

    //包装parameter对象

    MethodParameter nestedParameter = parameter.nestedIfOptional();

	//获取@PathVariable指定的属性名

    Object resolvedName = resolveStringValue(namedValueInfo.name);

    //

    if (resolvedName == null) {

        throw new IllegalArgumentException(

            "Specified name must not resolve to null: [" + namedValueInfo.name + "]");

    }

	//根据name从url中寻找并获取参数值

    Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);

    //没有匹配

    if (arg == null) {

        //如果有default值，则根据该值查找

        if (namedValueInfo.defaultValue != null) {

            arg = resolveStringValue(namedValueInfo.defaultValue);

        }

        //如果required为false，则可以不指定name，但默认为true。

        else if (namedValueInfo.required && !nestedParameter.isOptional()) {

            handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);

        }

        arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());

    }

    //虽然匹配，路径中传入的参数如果是“ ”，且有默认的name，则按照默认处理

    else if ("".equals(arg) && namedValueInfo.defaultValue != null) {

        arg = resolveStringValue(namedValueInfo.defaultValue);

    }

    if (binderFactory != null) {

        WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);

            arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);

    }

    handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);

    return arg;

}

getNameValueInfo方法：

	private NamedValueInfo getNamedValueInfo(MethodParameter parameter) {

        //从缓存中获取

		NamedValueInfo namedValueInfo = this.namedValueInfoCache.get(parameter);

		if (namedValueInfo == null) {

            //创建一个namedValueInfo对象

			namedValueInfo = createNamedValueInfo(parameter);

            //如果没有在注解中指定属性名，默认为参数名

			namedValueInfo = updateNamedValueInfo(parameter, namedValueInfo);

            //更新缓存

			this.namedValueInfoCache.put(parameter, namedValueInfo);

		}

		return namedValueInfo;

	}

createNamedValueInfo：获取@PathVariable注解的信息，封装成NamedValueInfo对象

	@Override

	protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {

		PathVariable ann = parameter.getParameterAnnotation(PathVariable.class);

		Assert.state(ann != null, "No PathVariable annotation");

		return new PathVariableNamedValueInfo(ann);

	}

updateNamedValueInfo：

private NamedValueInfo updateNamedValueInfo(MethodParameter parameter, NamedValueInfo info) {

    String name = info.name;

    if (info.name.isEmpty()) {

        //如果注解中没有指定name，则为参数名

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

}

resolveName方法：

参数解析的过程：

• 根据方法对象，获取参数对象数组，并创建存储参数的数组。
• 遍历参数对象数组，并根据参数解析器argumentResolver解析。
• 如果没有参数解析器，报错。
• 参数解析时，先尝试获取注解的信息，以@PathVariable为例。
• 根据指定的name从url中获取参数值，如果没有指定，则默认为自己传入的参数名。

传递页面参数

我们可能会通过Map、Model、ModelMap等向域中存入键值对，这部分包含在请求处理中。

我们要关注的是ModelAndViewContainer这个类，它里面默认包含着BindingAwareModelMap。

在解析参数的时候，就已经通过MapMethodProcessor参数处理器初始化了一个BindingAwareModelMap。

当然其实这里重点还是参数解析，至于数据为什么封装进map，就很简单了，无非是反射执行方法的时候，通过put将数据存入，当然最后的数据也就存在于ModelAndViewContainer中。

返回值解析

省略寻找返回值解析器的过程，因为返回值为视图名，所以解析器为：ViewNameMethodReturnValueHandler。

@Override

public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

    if (returnValue instanceof CharSequence) {

        //获取视图名

        String viewName = returnValue.toString();

        //向mavContainer中设置

        mavContainer.setViewName(viewName);

        //是否是isRedirectViewName

        if (isRedirectViewName(viewName)) {

            mavContainer.setRedirectModelScenario(true);

        }

    }

    else if (returnValue != null){

        // should not happen

        throw new UnsupportedOperationException("Unexpected return type: " +

                                                returnType.getParameterType().getName() + " in method: " + returnType.getMethod());

    }

}

isRedirectViewName方法

	protected boolean isRedirectViewName(String viewName) {

        //是否符合自定义的redirectPatterns，或者满足redirect:开头的名字

		return (PatternMatchUtils.simpleMatch(this.redirectPatterns, viewName) || viewName.startsWith("redirect:"));

	}

最后通过getModelAndView获取mv对象，我们来详细解析一下：

@Nullable

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

	//Promote model attributes listed as @SessionAttributes to the session

    modelFactory.updateModel(webRequest, mavContainer);

    //如果请求已经处理完成

    if (mavContainer.isRequestHandled()) {

        return null;

    }

    //从mavContainer中获取我们存入的数据map

    ModelMap model = mavContainer.getModel();

    //通过视图名、modelmap、和status创建一个ModelAndView对象

    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;

}

最后返回的都是ModelAndView对象，包含了逻辑名和模型对象的视图。

返回值解析的过程相对比较简单：

• 根据返回的参数，获取对应的返回值解析器。

• 获取视图名，如果是需要redirect，则mavContainer.setRedirectModelScenario(true);

• 其他情况下，直接给mvcContainer中的ViewName视图名属性设置上即可。

• 最后将mvcContainer的model、status、viewName取出，创建mv对象返回。

【总结】

参数解析、返回值解析两个过程都包含大量的解决策略，其中寻找合适的解析器的过程都是先遍历初始化的解析器表，然后判断是否需要异步处理，判断是否可以处理返回值类型，如果可以的话，就使用该解析器进行解析，如果不行，就一直向下遍历，直到表中没有解析器为止。

3. 视图解析

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,

 @Nullable Exception exception) throws Exception {

    boolean errorView = false;

    // 保证渲染一次，cleared作为标记

    if (mv != null && !mv.wasCleared()) {

        //渲染过程！！！

        render(mv, request, response);

        if (errorView) {

            WebUtils.clearErrorRequestAttributes(request);

        }

    }

}

DispatcherServlet的render方法

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {

    // Determine locale for request and apply it to the response.

    Locale locale =

        (this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());

    response.setLocale(locale);

    View view;

    //获取视图名

    String viewName = mv.getViewName();

    if (viewName != null) {

        //通过视图解析器viewResolvers对视图名进行处理，创建view对象

        view = resolveViewName(viewName, mv.getModelInternal(), locale, request);

    }

    else {

        view = mv.getView();

    }

    if (mv.getStatus() != null) {

        response.setStatus(mv.getStatus().value());

    }

    view.render(mv.getModelInternal(), request, response);

}

获取视图解析器，解析视图名：

@Nullable

protected View resolveViewName(String viewName, @Nullable Map<String, Object> model,

Locale locale, HttpServletRequest request) throws Exception {

    //这里我们注册的是InternalResourceViewResolver

    if (this.viewResolvers != null) {

        for (ViewResolver viewResolver : this.viewResolvers) {

            View view = viewResolver.resolveViewName(viewName, locale);

            if (view != null) {

                return view;

            }

        }

    }

    return null;

}

UrlBasedViewResolver的createView方法：

	@Override

	protected View createView(String viewName, Locale locale) throws Exception {

		//如果解析器不能处理所给的view，就返回null，让下一个解析器看看能否执行

		if (!canHandle(viewName, locale)) {

			return null;

		}

		// Check for special "redirect:" prefix.

		if (viewName.startsWith(REDIRECT_URL_PREFIX)) {

			//判断是否需要重定向

		}

		// Check for special "forward:" prefix.

		if (viewName.startsWith(FORWARD_URL_PREFIX)) {

			//判断是否需要转发

		}

		//调用父类的loadView方法

		return super.createView(viewName, locale);

	}

最后返回的视图对象：

视图解析器 viewResolver --实例化 --> view（无状态的，不会有线程安全问题）

AbstractView的render方法

@Override

public void render(@Nullable Map<String, ?> model, HttpServletRequest request,

HttpServletResponse response) throws Exception {

    //获取合并后的map，有我们存入域中的map，还有PathVariable对应的键值等

    Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);

    prepareResponse(request, response);

    //根据给定的model渲染内部资源，如将model设置为request的属性

    renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);

}

InternalResourceView的renderMergedOutputModel

@Override

protected void renderMergedOutputModel(

    Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

    //将model中的值设置到request域中

    exposeModelAsRequestAttributes(model, request);

    // 如果有的话，给request设置helpers

    exposeHelpers(request);

    // 将目标地址设置到request中

    String dispatcherPath = prepareForRendering(request, response);

    // 获取目标资源（通常是JSP）的RequestDispatcher。

    RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);

    // 如果已经包含或响应已经提交，则执行包含，否则转发。

    if (useInclude(request, response)) {

        response.setContentType(getContentType());

        rd.include(request, response);

    }

    else {

        // Note: 转发的资源应该确定内容类型本身。

        rd.forward(request, response);

    }

}

exposeModelAsRequestAttributes

protected void exposeModelAsRequestAttributes(Map<String, Object> model,HttpServletRequest request) throws Exception {

	//遍历model

    model.forEach((modelName, modelValue) -> {

        if (modelValue != null) {

            //向request中设置值

            request.setAttribute(modelName, modelValue);

        }

        else {

            //value为null的话，移除该name

            request.removeAttribute(modelName);

        }

    });

}

视图解析器

视图解析器（实现ViewResolver接口）：将逻辑视图解析为具体的视图对象。

每个视图解析器都实现了Ordered接口，并开放order属性，order越小优先级越高。

按照视图解析器的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则抛出异常。

视图

视图（实现View接口）：渲染模型数据，将模型数据以某种形式展现给用户。

最终采取的视图对象对模型数据进行渲染render，处理器并不关心，处理器关心生产模型的数据，实现解耦。