SpringMVC源码-处理json请求过程

Myth丶恋晨 2022-01-27 02:34 211阅读 0赞

springmvc版本

4.3.3.RELEASE

SpringMvc原理图

*  ![Image 1][]
    
    图片来自http://www.cnblogs.com/selene/p/4658554.html

源码分析 ,主要根据原理流程图开始debug源码

1.  要使用springmvc需要在web.xml中配置一个servlet,配置`<url-pattern>/</url-pattern>`以便springmvc的`DispatcherServlet`可以处理所有请求.并配置注解控制器`<mvc:annotation-driven/>`

<servlet>
            <servlet-name>springServlet</servlet-name>
            <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
            <init-param>
                <param-name>throwExceptionIfNoHandlerFound</param-name>
                <param-value>true</param-value>
            </init-param>
            <init-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>classpath*:spring/spring-mvc.xml</param-value>
            </init-param>
    
            <load-on-startup>1</load-on-startup>
        </servlet>
        <servlet-mapping>
            <servlet-name>springServlet</servlet-name>
            <url-pattern>/</url-pattern>
        </servlet-mapping>

1.  request请求url  
    程序入口在入口在`DispatcherServlet`中的`doService`方法

@Override
        protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
            //保存request中的属性
            Map<String, Object> attributesSnapshot = null;
            if (WebUtils.isIncludeRequest(request)) {
                attributesSnapshot = new HashMap<>();
                Enumeration<?> attrNames = request.getAttributeNames();
                while (attrNames.hasMoreElements()) {
                    String attrName = (String) attrNames.nextElement();
                    if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
                        attributesSnapshot.put(attrName, request.getAttribute(attrName));
                    }
                }
            }
            // Make framework objects available to handlers and view objects.
            //设置后面需要用到的一些属性
            //设置web环境上下文
            request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
            //国际化
            request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
            //主题
            request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
            //主题资源
            request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
            //快照功能
            FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
            if (inputFlashMap != null) {
                request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
            }
            request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
            request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
    
            try {
                //处理请求
                doDispatch(request, response);
            } finally {
                if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
                    // Restore the original attribute snapshot, in case of an include.
                    if (attributesSnapshot != null) {
                        restoreAttributesAfterInclude(request, attributesSnapshot);
                    }
                }
            }
        }

3.最终进入到`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 {
                 //检测是否是文件上传请求,检测请求头是否以 multipart/ 开头
                 //如果是的话使用multipartResolver文件解析器对请求进行相应处理
                 processedRequest = checkMultipart(request);
                 multipartRequestParsed = (processedRequest != request);
                 //获取请求对应的处理器和拦截器链
                 mappedHandler = getHandler(processedRequest);
                 if (mappedHandler == null || mappedHandler.getHandler() == null) {
                     noHandlerFound(processedRequest, response);
                     return;
                 }
                 // Determine handler adapter for the current request.
                 //遍历系统中存在的处理适配器,一旦匹配到直接就返回了
                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
                 // Process last-modified header, if supported by the handler.
                 String method = request.getMethod();
                 boolean isGet = "GET".equals(method);
                 if (isGet || "HEAD".equals(method)) {
                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                     if (logger.isDebugEnabled()) {
                         logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                     }
                     if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                         return;
                     }
                 }
                 //前置拦截器
                 if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                     return;
                 }
    
                 // 执行接口方法,返回视图对象
                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
                 if (asyncManager.isConcurrentHandlingStarted()) {
                     return;
                 }
                 //根据请求类型获取视图处理器
                 applyDefaultViewName(processedRequest, mv);
                 //后置拦截器
                 mappedHandler.applyPostHandle(processedRequest, response, mv);
             } catch (Exception ex) {
                 dispatchException = ex;
             } catch (Throwable err) {
                 // As of 4.3, we're processing Errors thrown from handler methods as well,
                 // making them available for @ExceptionHandler methods and other scenarios.
                 dispatchException = new NestedServletException("Handler dispatch failed", err);
             }
             processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
         } catch (Exception ex) {
             triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
         } catch (Throwable err) {
             triggerAfterCompletion(processedRequest, response, mappedHandler,
                     new NestedServletException("Handler processing failed", err));
         } finally {
             if (asyncManager.isConcurrentHandlingStarted()) {
                 // Instead of postHandle and afterCompletion
                 if (mappedHandler != null) {
                     mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                 }
             } else {
                 // Clean up any resources used by a multipart request.
                 if (multipartRequestParsed) {
                     cleanupMultipart(processedRequest);
                 }
             }
         }
     }

4 . 查询handler  
这里进入`mappedHandler = getHandler(processedRequest);` 主要作用是返回处理器链对象,包括该请求的处理器和拦截器链,看下获取处理器实现过程:

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
                    //遍历handlerMappings
            for (HandlerMapping hm : this.handlerMappings) {
                if (logger.isTraceEnabled()) {
                    logger.trace(
                            "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
                }
                HandlerExecutionChain handler = hm.getHandler(request);
                            //一旦匹配上直接返回
                if (handler != null) {
                    return handler;
                }
            }
            return null;
        }

handlerMappings对象主要作用是维护请求和处理器之间的关系.比如我们使用@RequestMapping来定义请求路由.系统就会注册`RequestMappingHandlerMapping`到handlerMappings中, 对象中保存了url的很多信息,比如属于哪个类,哪个方法,参数,这些信息是在IOC的springmvc容器初始化时根据注解和配置提取好的.

![Image 1][]

handlerMappings结构图

5 . 接下来是获取处理器适配器,后续的请求处理委托给该对象.系统在初始化的时候会自动注入实现了`HandlerAdapter`接口的bean,不同的路由策略对应不同的适配器.比如`requestMapping`对应`RequestMappingHandlerAdapter`

6 . 获取数据视图对象,进入关键方法`mv = ha.handle(processedRequest, response, mappedHandler.getHandler());` 最终来到

protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
             HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
         ServletWebRequest webRequest = new ServletWebRequest(request, response);
         try {
             //数据绑定处理过程
             WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
             ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
             ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
             invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
             invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
             invocableMethod.setDataBinderFactory(binderFactory);
             invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
             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);
             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();
                 if (logger.isDebugEnabled()) {
                     logger.debug("Found concurrent result value [" + result + "]");
                 }
                 invocableMethod = invocableMethod.wrapConcurrentResult(result);
             }
             //继续进入此方法,执行我们的业务代码
             invocableMethod.invokeAndHandle(webRequest, mavContainer);
             if (asyncManager.isConcurrentHandlingStarted()) {
                 return null;
             }
             return getModelAndView(mavContainer, modelFactory, webRequest);
         }
         finally {
             webRequest.requestCompleted();
         }
     }

7 . 进入`invocableMethod.invokeAndHandle(webRequest, mavContainer);`

public void invokeAndHandle(ServletWebRequest webRequest,
                ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
            //从request中提取参数,然后利用反射该请求对应的方法,得到返回值
            Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
            setResponseStatus(webRequest);
            if (returnValue == null) {
                if (isRequestNotModified(webRequest) || hasResponseStatus() || mavContainer.isRequestHandled()) {
                    mavContainer.setRequestHandled(true);
                    return;
                }
            }
            else if (StringUtils.hasText(this.responseReason)) {
                mavContainer.setRequestHandled(true);
                return;
            }
            mavContainer.setRequestHandled(false);
            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;
            }
        }

8 . 我们使用了@ResponseBody注解,所以最终进入`RequestResponseBodyMethodProcessor`中的`handleReturnValue()`:

@Override
        public void handleReturnValue(Object returnValue, MethodParameter returnType,
                ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
                throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    
            mavContainer.setRequestHandled(true);
            ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
            ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);
    
            // Try even with null return value. ResponseBodyAdvice could get involved.
            writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
        }

9 . 继续跟进`writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);`  
这里还有一个消息转换器的概念,在springmvc容器初始化的时候系统会注册一系列的消息转换器以处理不同的响应类型,如:json,xml ,  
spring会对消息转换器进行遍历 ,一旦获取符合要求的转换器就开始执行相应操作. 比如`json`会直接利用`Jackson`转换返回值然后直接写入response进行输出

![Image 1][]

@SuppressWarnings("unchecked")
        protected <T> void writeWithMessageConverters(T value, MethodParameter returnType,
                ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
                throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    
            Object outputValue;
            Class<?> valueType;
            Type declaredType;
    
            if (value instanceof CharSequence) {
                outputValue = value.toString();
                valueType = String.class;
                declaredType = String.class;
            }
            else {
                outputValue = value;
                valueType = getReturnValueType(outputValue, returnType);
                declaredType = getGenericType(returnType);
            }
    
            HttpServletRequest request = inputMessage.getServletRequest();
            List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(request);
            List<MediaType> producibleMediaTypes = getProducibleMediaTypes(request, valueType, declaredType);
            if (outputValue != null && producibleMediaTypes.isEmpty()) {
                throw new IllegalArgumentException("No converter found for return value of type: " + valueType);
            }
            Set<MediaType> compatibleMediaTypes = new LinkedHashSet<>();
            for (MediaType requestedType : requestedMediaTypes) {
                for (MediaType producibleType : producibleMediaTypes) {
                    if (requestedType.isCompatibleWith(producibleType)) {
                        compatibleMediaTypes.add(getMostSpecificMediaType(requestedType, producibleType));
                    }
                }
            }
            if (compatibleMediaTypes.isEmpty()) {
                if (outputValue != null) {
                    throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
                }
                return;
            }
            List<MediaType> mediaTypes = new ArrayList<>(compatibleMediaTypes);
            MediaType.sortBySpecificityAndQuality(mediaTypes);
            MediaType selectedMediaType = null;
            for (MediaType mediaType : mediaTypes) {
                if (mediaType.isConcrete()) {
                    selectedMediaType = mediaType;
                    break;
                }
                else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {
                    selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
                    break;
                }
            }
            //遍历消息转换器
            if (selectedMediaType != null) {
                selectedMediaType = selectedMediaType.removeQualityValue();
                for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
                    if (messageConverter instanceof GenericHttpMessageConverter) {
                        if (((GenericHttpMessageConverter) messageConverter).canWrite(
                                declaredType, valueType, selectedMediaType)) {
                            outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
                                    (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
                                    inputMessage, outputMessage);
                            if (outputValue != null) {
                                addContentDispositionHeader(inputMessage, outputMessage);
                                ((GenericHttpMessageConverter) messageConverter).write(
                                        outputValue, declaredType, selectedMediaType, outputMessage);
                                if (logger.isDebugEnabled()) {
                                    logger.debug("Written [" + outputValue + "] as \"" + selectedMediaType +
                                            "\" using [" + messageConverter + "]");
                                }
                            }
                            return;
                        }
                    }
                    else if (messageConverter.canWrite(valueType, selectedMediaType)) {
                        outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
                                (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
                                inputMessage, outputMessage);
                        if (outputValue != null) {
                            addContentDispositionHeader(inputMessage, outputMessage);
                            ((HttpMessageConverter) messageConverter).write(outputValue, selectedMediaType, outputMessage);
                            if (logger.isDebugEnabled()) {
                                logger.debug("Written [" + outputValue + "] as \"" + selectedMediaType +
                                        "\" using [" + messageConverter + "]");
                            }
                        }
                        return;
                    }
                }
            }
            if (outputValue != null) {
                throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
            }
        }

10 . 最后进入`processDispatchResult()`进行页面渲染.

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
                HandlerExecutionChain mappedHandler, ModelAndView mv, Exception exception) throws Exception {
    
            boolean errorView = false;
    
            if (exception != null) {
                if (exception instanceof ModelAndViewDefiningException) {
                    logger.debug("ModelAndViewDefiningException encountered", exception);
                    mv = ((ModelAndViewDefiningException) exception).getModelAndView();
                }
                else {
                    Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
                    mv = processHandlerException(request, response, handler, exception);
                    errorView = (mv != null);
                }
            }
    
            // Did the handler return a view to render?
            if (mv != null && !mv.wasCleared()) {
                render(mv, request, response);
                if (errorView) {
                    WebUtils.clearErrorRequestAttributes(request);
                }
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
                            "': assuming HandlerAdapter completed request handling");
                }
            }
    
            if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
                // Concurrent handling started during a forward
                return;
            }
    
            if (mappedHandler != null) {
                mappedHandler.triggerAfterCompletion(request, response, null);
            }
        }

[Image 1]: