SpringMVC——DispatcherServlet

tomcat容器启动加载web.xml初始化springmvc相关策略组件

一、WebApplicationContext的层次结构

 本来是想研究一下springMVC组件的，结果解决了以前的一个疑问。WebApplicationContext的层次结构

下面是从官网copy的一份web.xml

ContextLoaderListener：初始化一个Root WebApplicationContext：SpringIOC初始化一些中间services+datasouces的Bean

DispatcherServlet：初始化一个Servlet WebApplicationContext：SpringIOC初始化前端controllers+view resovlers+HandleMapping的Bean

父子关系：Servlet WebApplicationContext.setParent(Root WebApplicationContext);子容器找不到就去父容器找。

<web-app>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/app-context.xml</param-value>
    </context-param>

    <servlet>
        <servlet-name>app</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value></param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>app</servlet-name>
        <url-pattern>/app/*</url-pattern>
    </servlet-mapping>

</web-app>

二、DispatcherServlet初始化（Servlet生命周期init()）

servlet.init()时初始化SpringIOC容器外，还有初始化了一部分SpringMVC组件

/* org.springframework.web.servlet.DispatcherServlet#initStrategies */
    protected void initStrategies(ApplicationContext context) {
        //多路解析器 文件上传 HttpServletRequest-->MultipartHttpServletRequest
        initMultipartResolver(context);
        //国际化
        initLocaleResolver(context);
        //主题
        initThemeResolver(context);
        //初始化HandleMapping容器
        initHandlerMappings(context);
        //初始化HandlerAdapters容器
        initHandlerAdapters(context);
        //初始化HandlerExceptionResolver容器
        initHandlerExceptionResolvers(context);
        //Request转viewName
        initRequestToViewNameTranslator(context);
        //初始化视图解析器
        initViewResolvers(context);
        //初始化FlashMapManager
        initFlashMapManager(context);
    }

重点看下HandlerMapping与HandlerAdapters

1、HandlerMapping:初始化mapping+拦截器interceptors

 initHandlerMappings(context)：初始化HandlerMapping，

/* org.springframework.web.servlet.DispatcherServlet#initHandlerMappings */
    private void initHandlerMappings(ApplicationContext context) {
        this.handlerMappings = null;

        if (this.detectAllHandlerMappings) {//从ioc容器中获取显式设置（xml或者注解）的HandlerMapping类型的Bean
            //根据类型到 Servlet applicationContex及Root applicationContext中去查找
            //一般情况下，在项目中是不会显式的配置HandlerMapping类型的Bean的
            //所以这里会返回null
            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.
            }
        }

        if (this.handlerMappings == null) {
            //由于没有显式的配置HandlerMapping的Bean
            //此时会默认初始化从DispatcherServlet.properties中设定的3个HandlerMapping的Bean
            //org/springframework/web/servlet/DispatcherServlet.properties
            // ① org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
            // ② springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
            // ③ org.springframework.web.servlet.function.support.RouterFunctionMapping
            this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
            if (logger.isTraceEnabled()) {
                logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
                        "': using default strategies from DispatcherServlet.properties");
            }
        }
    }

 DispatchServlet.properties 注意标红的Bean，很眼熟

/* org/springframework/web/servlet/DispatcherServlet.properties */
/* 没有显式设置组件时，DispatcherServlet会默认初始化下面类型的Bean到容器中
 * MultijpartResolve没有默认，需要显式设置
 */
//国际化
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
//主题
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
//HandlerMapping
org.springframework.web.servlet.HandlerMapping=
org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,   
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,
org.springframework.web.servlet.function.support.RouterFunctionMapping
//handlerAdapter
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.function.support.HandlerFunctionAdapter

//HandlerExceptionResolve
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

//RequestToViewNameTranslator
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
//ViewResolver
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
//FlashMapManager
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

 RequestHandlerRequestMapping：请求uri到controller方法的映射器

打断点发现RequestHandlerRequestMapping初始化后就已经存在映射关系，

 ① 然后跟踪createBean()最终发现Bean初始化最后阶段调用afterPropertiesSet()时注册映射关系，初始化mapping

/* org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping#afterPropertiesSet */
    public void afterPropertiesSet() {
        this.config = new RequestMappingInfo.BuilderConfiguration();
        this.config.setUrlPathHelper(getUrlPathHelper());
        this.config.setPathMatcher(getPathMatcher());
        this.config.setSuffixPatternMatch(useSuffixPatternMatch());
        this.config.setTrailingSlashMatch(useTrailingSlashMatch());
        this.config.setRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch());
        this.config.setContentNegotiationManager(getContentNegotiationManager());
        //注册RequestMapping
        super.afterPropertiesSet();
    }

/* org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#afterPropertiesSet */

    public void afterPropertiesSet() {
        initHandlerMethods();
    }

    protected void initHandlerMethods() {
        //getCandidateBeanNames()获取所有实例化的Bean，
        //注意：DispatcherServlet.initStrategies()是在IOC容器初始化完成后
        for (String beanName : getCandidateBeanNames()) {
            //过滤scopedTarget.开头的Bean
            if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
                //扫描@Controller或者@RequestMapping注解的类
                //扫描@RequestMapping注解的方法
                //注册到映射关系到对应容器中(url-RequestMappingInfo)
                processCandidateBean(beanName);
            }
        }
        //不可修改视图+打印日志
        handlerMethodsInitialized(getHandlerMethods());
    }

    protected void processCandidateBean(String beanName) {
        Class<?> beanType = null;
        try {
            //获取beanType
            beanType = obtainApplicationContext().getType(beanName);
        }
        catch (Throwable ex) {
            // An unresolvable bean type, probably from a lazy bean - let's ignore it.
            if (logger.isTraceEnabled()) {
                logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
            }
        }
        //检查beanType不为空
        //并且beanType被@Controller或者@RequestMapping注解
        if (beanType != null && isHandler(beanType)) {
            detectHandlerMethods(beanName);
        }
    }

    protected void detectHandlerMethods(Object handler) {
        //重新获取beanType == handlerType
        Class<?> handlerType = (handler instanceof String ?
                obtainApplicationContext().getType((String) handler) : handler.getClass());

        if (handlerType != null) {
            Class<?> userType = ClassUtils.getUserClass(handlerType);
            //获取映射关系<Method , RequestMappingInfo>
            Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
                    (MethodIntrospector.MetadataLookup<T>) method -> {
                        try {
                            //selectMethods中查找beanType的所有方法
                            //然后遍历method，getMappingForMethod获取@RequestMapping信息生成一个RequestMappingInfo实例
                            //重点RequestMappingInfo.path=Controller的@RequestMapping.value+Method的@RequestMaping.value
                            //然后生成映射关系<method,RequestMappingInfo>
                            return getMappingForMethod(method, userType);
                        }
                        catch (Throwable ex) {
                            throw new IllegalStateException("Invalid mapping on handler class [" +
                                    userType.getName() + "]: " + method, ex);
                        }
                    });
            if (logger.isTraceEnabled()) {
                logger.trace(formatMappings(userType, methods));
            }
            //注册映射关系
            methods.forEach((method, mapping) -> {
                Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
                //注册映射关系到RequestMapHandlerMapping.mappingRegistry的五个容器中
                //mappingRegistry的类型:org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.MappingRegistry
                //5个容器全部是Map类型
                //urlLookup.add(url, mapping);
                //mappingLookup.put(mapping, handlerMethod);
                //corsLookup.put(handlerMethod, corsConfig);
                //registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
                //nameLookup.put(name, newList);newList=List<handlerMethod>
                //handlerMethod就是beanName、beanType、beanFactory、method、parameters的封装
                //其实就是url -> mapping -> handlerMethod ->invoke
                registerHandlerMethod(handler, invocableMethod, mapping);
            });
        }
    }

② 初始化拦截器interceptors

其实初始化拦截器还要在初始化mapping之前，回忆一下bean初始化

/* org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#initializeBean(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition) */
    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        ...
        if (mbd == null || !mbd.isSynthetic()) {
            //调用所有BeanPostProcessor前置方法
            //这里初始化拦截器interceptors
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            //调用afterPropertiesSet() 这里 初始化mapping
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        ...
    }        

调用ApplicaitonContextAwareProcessor.postProcessorBeforeInitialization()，实现拦截器初始化，最终走到下面：

/* org.springframework.web.servlet.handler.AbstractHandlerMapping#initApplicationContext */
    protected void initApplicationContext() throws BeansException {
        extendInterceptors(this.interceptors);
        detectMappedInterceptors(this.adaptedInterceptors);
        initInterceptors();
    }

此时RequestHandlerRequestMapping初始化完成：

2、RequestMappingHandlerAdapter

 ① 同RequestHandlerRequestMapping一样，也是afterPropertiesSet()方法中完成注册,而且更加直接

    public void afterPropertiesSet() {
        // Do this first, it may add ResponseBody advice beans
        initControllerAdviceCache();
        //参数类型解析器（总共注册了20+个解析器）
        //重点关注：ServletModelAttributeMethodProcessor，后面会用到
        if (this.argumentResolvers == null) {
            List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
            this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
        }
        //参数类型赋值器（总共注册了10+个解析器）
        if (this.initBinderArgumentResolvers == null) {
            List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
            this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
        }
        //返回参数类型解析器（总共注册了10+个解析器）
        if (this.returnValueHandlers == null) {
            List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
            this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
        }
    }

三、DispatcherServlet服务（Servlet生命周期servlet.service(request,response)）

DispatcherServlet的流程：FrameworkServlet.service()-->httpServlet.service()-->FrameworkServlet.doGet()-->FrameworkServlet.processRequest-->DispatcherServlet.doService()-->DispatcherServlet.doDispatch()

直接从doDispatch()开始:springmvc执行流程。

/* org.springframework.web.servlet.DispatcherServlet#doDispatch */
    protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
        boolean multipartRequestParsed = false;

        //异步管理器
        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

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

            try {
                //检查是否是文件上传请求
                //是则转换为multipartRequest
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);

                // 确定当前请求的处理程序
                //① 根据request中url确定执行方法methodHandler
                //② 根据request中url确定拦截器interceptors
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // 确定当前请求的处理程序的适配器，通常是RequestMappingHandlerAdapter 
                // 默认的四个适配器分别匹配
                // HttpRequestHandlerAdapter: handler instanceof HttpRequestHandler
                // SimpleControllerHandlerAdapter：handler instanceof Controller
                // RequestMappingHandlerAdapter：handler instanceof HandlerMethod
                // HandlerFunctionAdapter：handler instanceof HandlerFunction
                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) {
                        return;
                    }
                }
                // 执行拦截器前置方法
                // interceptor.preHandle
                // interceptor.preHandle没通过调用interceptor.afterCompletion然后直接返回
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                // 实例调用程序，mappedHandler.getHandlder == MethodHandler即已经可以找到执行的controller和执行的method
                // Adapter发挥作用的地方request.parameter转化为method的参数类型
                // 然后执行方法
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }
                //viewNameTranslator
                applyDefaultViewName(processedRequest, mv);
                //拦截器后置方法
                //interceptor.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);
            }
            // handlerExceptionResolvers
            //异常会执行interceptor.afterCompletion
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            //异常会执行interceptor.afterCompletion
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Throwable err) {
            //异常会执行interceptor.afterCompletion
            triggerAfterCompletion(processedRequest, response, mappedHandler,
                    new NestedServletException("Handler processing failed", err));
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                // 异步处理时，用interceptor释放资源
                // AsyncHandlerInterceptor.afterConcurrentHandlingStarted
                if (mappedHandler != null) {
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                }
            }
            else {
                //清除multipartResolver使用的所有资源
                if (multipartRequestParsed) {
                    cleanupMultipart(processedRequest);
                }
            }
        }
    }

mv = ha.handle(processedRequest, response, mappedHandler.getHandler())：实际controller.method调用
AbstractHandlerMethodAdapter.handle()-->RequestMappingHandlerAdapter.handleInternal()-->RequestMappingHandlerAdapter.invokeHandlerMethod()-->
ServletInvocableHandlerMethod.invokeAndHandle()

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {
        //在RequestMappingHandlerAdapter.argumentResolvers的26个解析器中选择1个合适的解析器
        // resolver.supportsParameter(parameter)判断哪一个合适
        // 然后request.param --> method.param
        // 例如xxx(User user)时选择ServletModelAttributeMethodProcessor
        // 最后调用方法执行
        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
        setResponseStatus(webRequest);

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

        mavContainer.setRequestHandled(false);
        Assert.state(this.returnValueHandlers != null, "No return value handlers");
        try {
            //在RequestMappingHandlerAdapter.returnValueHandlers的15个解析器中选择1个合适的解析器
            // handler.supportsReturnType(returnType)判断哪一个合适
            // 然后method.result --> response.param，
            // 例如返回@ResponseBody返回json时选择RequestResponseBodyMethodProcessor
            // 最后返回
            this.returnValueHandlers.handleReturnValue(
                    returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        }
        catch (Exception ex) {
            if (logger.isTraceEnabled()) {
                logger.trace(formatErrorForReturnValue(returnValue), ex);
            }
            throw ex;
        }
    }

1