SpringMVC-RequestMappingHandlerAdapter

前言

在SpringMVC-RequestMappingHandlerMapping中对web请求到来时如何获取处理该请求的handler进行了分析，那么获取到web请求对应的handler之后，SpringMVC框架还会根据handler获取其对应的HandlerAdapter，handler的实际执行就是由HandlerAdapter完成，并且HandlerAdapter一共会做三件事情：入参解析，执行处理逻辑，返回值处理。通俗的说就是执行方法前要把方法需要的参数准备好，然后执行方法，最后方法执行后要对方法返回值进行处理。如果handler是由RequestMappingHandlerMapping获得，那么执行该handler的HandlerAdapter应该为RequestMappingHandlerAdapter，该篇文章将对RequestMappingHandlerAdapter的入参解析，执行处理逻辑，返回值处理三部分进行学习。

SpringBoot版本：2.4.1

正文

一. RequestMappingHandlerAdapter初始化

首先通过类图认识一下RequestMappingHandlerAdapter。

由类图可知RequestMappingHandlerAdapter实现了InitializingBean接口，因此在容器加载RequestMappingHandlerAdapter时会执行其实现的afterPropertiesSet()方法。该方法如下所示。

public void afterPropertiesSet() {
    initControllerAdviceCache();

    if (this.argumentResolvers == null) {
        List resolvers = getDefaultArgumentResolvers();
        this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
    }
    if (this.initBinderArgumentResolvers == null) {
        List resolvers = getDefaultInitBinderArgumentResolvers();
        this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
    }
    if (this.returnValueHandlers == null) {
        List handlers = getDefaultReturnValueHandlers();
        this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
    }
}

afterPropertiesSet()方法依次为RequestMappingHandlerAdapter加载ControllerAdviceBean相关内容，加载参数解析器，加载返回结果处理器。其中参数解析器和返回结果处理器默认情况下会将SpringMVC框架提供的和用户自定义的一并进行加载，而加载ControllerAdviceBean相关内容实际就是先获取容器中所有由@ControllerAdvice注解修饰的bean，然后将这些bean的由@ModelAttribute注解和@InitBinder注解修饰的方法加载到RequestMappingHandlerAdapter中，最后再判断由@ControllerAdvice注解修饰的bean是否实现了RequestBodyAdvice或ResponseBodyAdvice接口，如果是，则将该bean也加载到RequestMappingHandlerAdapter中。initControllerAdviceCache()方法如下所示。

由@ControllerAdvice注解修饰的bean是功能增强型Controller，通常搭配@ModelAttribute注解和@InitBinder注解使用，可以实现：全局数据绑定；全局数据预处理；全局异常处理。

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

    // 将容器中所有带@ControllerAdvice注解的bean获取出来并包装成ControllerAdviceBean对象
    List adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());

    List requestResponseBodyAdviceBeans = new ArrayList<>();

    // 遍历ControllerAdviceBean对象集合
    for (ControllerAdviceBean adviceBean : adviceBeans) {
        Class beanType = adviceBean.getBeanType();
        if (beanType == null) {
            throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
        }
        // 获取ControllerAdviceBean对象（包括父对象）和其实现的接口的不由@RequestMapping注解修饰且由@ModelAttribute注解修饰的方法集合
        Set attrMethods = MethodIntrospector.selectMethods(beanType, MODEL_ATTRIBUTE_METHODS);
        if (!attrMethods.isEmpty()) {
            this.modelAttributeAdviceCache.put(adviceBean, attrMethods);
        }
        // 获取ControllerAdviceBean对象（包括父对象）和其实现的接口的由@InitBinder注解修饰的方法集合
        Set binderMethods = MethodIntrospector.selectMethods(beanType, INIT_BINDER_METHODS);
        if (!binderMethods.isEmpty()) {
            this.initBinderAdviceCache.put(adviceBean, binderMethods);
        }
        // 判断ControllerAdviceBean对象是否实现了RequestBodyAdvice或ResponseBodyAdvice接口
        if (RequestBodyAdvice.class.isAssignableFrom(beanType) || ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
            requestResponseBodyAdviceBeans.add(adviceBean);
        }
    }

    if (!requestResponseBodyAdviceBeans.isEmpty()) {
        this.requestResponseBodyAdvice.addAll(0, requestResponseBodyAdviceBeans);
    }

    if (logger.isDebugEnabled()) {
        int modelSize = this.modelAttributeAdviceCache.size();
        int binderSize = this.initBinderAdviceCache.size();
        int reqCount = getBodyAdviceCount(RequestBodyAdvice.class);
        int resCount = getBodyAdviceCount(ResponseBodyAdvice.class);
        if (modelSize == 0 && binderSize == 0 && reqCount == 0 && resCount == 0) {
            logger.debug("ControllerAdvice beans: none");
        }
        else {
            logger.debug("ControllerAdvice beans: " + modelSize + " @ModelAttribute, " + binderSize +
                    " @InitBinder, " + reqCount + " RequestBodyAdvice, " + resCount + " ResponseBodyAdvice");
        }
    }
} 
 
小节：RequestMappingHandlerAdapter初始化时会将解析参数，参数预处理，执行结果处理等步骤需要用到的bean进行加载。
 
 
二. RequestMappingHandlerAdapter参数解析
 
 
先通过DispatcherServlet中的doDispatch()方法观察handler执行的入口。
 
 
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

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

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

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

            // 根据handler获取HandlerAdapter
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            // 如果是GET或者HEAD请求，则获取LastModified时间戳并判断请求的资源是否改变
            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;
                }
            }

            // 执行拦截器的preHandler方法
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            // 执行handler
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

            applyDefaultViewName(processedRequest, mv);
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            ......
        }
        catch (Throwable err) {
            ......
        }
        ......
    }
    catch (Exception ex) {
        ......
    }
    catch (Throwable err) {
        ......
    }
    finally {
        ......
    }
}

 
 
handler的执行发生在HandlerAdapter接口声明的handle()方法中，由前面类图可知，RequestMappingHandlerAdapter继承于抽象类AbstractHandlerMethodAdapter，该抽象类实现了HandlerAdapter接口，并在其实现的handle()方法中调用了其声明的抽象方法handleInternal()，因此handler的执行入口是RequestMappingHandlerAdapter的handleInternal()方法，该方法如下所示。
 
 
protected ModelAndView handleInternal(HttpServletRequest request,
        HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

    ModelAndView mav;
    // 如果对支持的HTTP请求方法和会话进行了设置，则校验request是否符合设置，校验失败抛出异常
    checkRequest(request);

    // 如果synchronizeOnSession为true且能从request获取会话对象，则以同步方式执行handler
    if (this.synchronizeOnSession) {
        HttpSession session = request.getSession(false);
        if (session != null) {
            Object mutex = WebUtils.getSessionMutex(session);
            synchronized (mutex) {
                mav = invokeHandlerMethod(request, response, handlerMethod);
            }
        }
        else {
            mav = invokeHandlerMethod(request, response, handlerMethod);
        }
    }
    else {
        // 以不同步方式执行handler
        mav = invokeHandlerMethod(request, response, handlerMethod);
    }

    // response如果没有包含Cache-Control响应头，则在这里为response添加Cache-Control响应头
    if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
        // handler如果由@SessionAttributes注解修饰且声明了会话属性，则将response响应头的Cache-Control设置为no-store
        if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
            applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
        }
        else {
            // 否则根据WebContentGenerator的设置来丰富response
            prepareResponse(response);
        }
    }

    return mav;
}
 
 
继续看invokeHandlerMethod()的实现。
 
 
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
        HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

    ServletWebRequest webRequest = new ServletWebRequest(request, response);
    try {
        // 获取WebDataBinderFactory，顾名思义，该工厂对象用于获取WebDataBinder，以完成request参数与JavaBean的绑定
        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
        // 获取ModelFactory，用于在handler执行前协助初始化Model，并在执行后更新Model
        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

        // InvocableHandlerMethod继承于HandlerMethod并对其进行了扩展，能够使用参数解析器从request中获取参数并将获取到的参数作为入参调用handler方法
        // ServletInvocableHandlerMethod继承于InvocableHandlerMethod并对其进行了扩展，能够使用返回值处理器处理handler方法的返回值以及基于@ResponseStatus注解设置响应状态
        ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
        // 为invocableMethod设置参数解析器
        if (this.argumentResolvers != null) {
            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
        }
        // 为invocableMethod设置返回值处理器
        if (this.returnValueHandlers != null) {
            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
        }
        // 为invocableMethod设置WebDataBinderFactory和ModelFactory
        invocableMethod.setDataBinderFactory(binderFactory);
        invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

        // 创建ModelAndViewContainer对象
        ModelAndViewContainer mavContainer = new ModelAndViewContainer();
        // 从request中获取Input Flash Attributes并将其加载到ModelAndViewContainer使用的模型Model中
        mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
        // 初始化模型Model
        modelFactory.initModel(webRequest, mavContainer, invocableMethod);
        // 设置是否在重定向时不使用默认模型defaultModel，默认值为false，即重定向时也要使用defaultModel
        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();
            LogFormatUtils.traceDebug(logger, traceOn -> {
                String formatted = LogFormatUtils.formatValue(result, !traceOn);
                return "Resume with async result [" + formatted + "]";
            });
            invocableMethod = invocableMethod.wrapConcurrentResult(result);
        }

        // 执行handler
        invocableMethod.invokeAndHandle(webRequest, mavContainer);
        if (asyncManager.isConcurrentHandlingStarted()) {
            return null;
        }

        // 更新模型Model，然后创建ModelAndView对象并返回
        return getModelAndView(mavContainer, modelFactory, webRequest);
    }
    finally {
        webRequest.requestCompleted();
    }
}
 
 
invokeHandlerMethod()方法有点长，所做的事情可以概括为首先为执行handler准备各种必要条件（参数解析器，返回值处理器等），然后执行handler，最后更新模型Model并生成ModelAndView对象。这里特别说明一下上面源码中的ModelAndViewContainer对象，该对象的源码的注释翻译如下。
 
 

   记录与模型Model和视图View相关的由HandlerMethodArgumentResolvers和HandlerMethodReturnValueHandlers在handler方法执行中做出的相关决策。 
 
 
 
要理解上面的话，先看一下ModelAndViewContainer的成员变量。
 
 
public class ModelAndViewContainer {

    // 重定向时不使用defaultModel标志位，默认为false（表示重定向时也要使用defaultModel）
    private boolean ignoreDefaultModelOnRedirect = false;

    // 视图
    @Nullable
    private Object view;

    // 默认模型
    private final ModelMap defaultModel = new BindingAwareModelMap();

    // 重定向模型，重定向场景时可以使用该模型
    @Nullable
    private ModelMap redirectModel;

    // 重定向场景的标志位，表示handler是否返回重定向指令
    private boolean redirectModelScenario = false;

    // http状态码
    @Nullable
    private HttpStatus status;

    // 不应该进行数据绑定的模型属性集合
    private final Set noBinding = new HashSet<>(4);
    private final Set bindingDisabled = new HashSet<>(4);

    // 标识会话处理是否完成
    private final SessionStatus sessionStatus = new SimpleSessionStatus();

    // 标识handler是否执行完成
    private boolean requestHandled = false;
    
}
 
 
即ModelAndViewContainer主要功能如下。
 
 
     
  
  • 维护模型Model：非重定向场景下使用defaultModel，重定向场景下且ignoreDefaultModelOnRedirect为true时使用redirectModel；
    •  
  
  • 维护视图View：如果是字符串类型则是逻辑视图；
    •  
  
  • 维护是否是重定向场景：通过redirectModelScenario属性字段进行标识；
    •  
  
  • 维护handler是否执行完：通过requestHandled属性字段进行标识。
    •  
 
 
 
因为在后面参数解析和返回结果处理的过程中会将ModelAndViewContainer对象传递来传递去，其实这个对象做的事情大部分是存储数据和记录状态以方便最后获取ModelAndView对象，所以在这里先对其进行简要说明。
 
 
回到invokeHandlerMethod()方法，handler的实际执行是发生在ServletInvocableHandlerMethod对象的invokeAndHandle()方法中，继续看这个方法的实现。
 
 
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
        Object... providedArgs) throws Exception {

    // 参数解析，执行handler
    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    setResponseStatus(webRequest);

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

    mavContainer.setRequestHandled(false);
    Assert.state(this.returnValueHandlers != null, "No return value handlers");
    try {
        // 返回值处理
        this.returnValueHandlers.handleReturnValue(
                returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    }
    catch (Exception ex) {
        if (logger.isTraceEnabled()) {
            logger.trace(formatErrorForReturnValue(returnValue), ex);
        }
        throw ex;
    }
}
 
 
invokeAndHandle()方法中，调用了ServletInvocableHandlerMethod的父类InvocableHandlerMethod的invokeForRequest()来完成参数解析和执行handler。其实现如下。
 
 
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
        Object... providedArgs) throws Exception {

    // 参数解析
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    if (logger.isTraceEnabled()) {
        logger.trace("Arguments: " + Arrays.toString(args));
    }
    // 执行handler
    return doInvoke(args);
}
 
 
到这里，终于看到了参数解析和执行handler的方法。本小节主要学习参数解析过程，本小节正文开始。
 
 
getMethodArgumentValues()方法是InvocableHandlerMethod提供的方法，该方法完成两个事情：
 
 
     
  
  • 获取需要执行的handler方法的参数信息，包括：参数名，参数类型，参数注解（如果有的话）等，得到的是一个MethodParameter[]数组，每一个handler方法的参数信息都会封装成一个MethodParameter对象并加入到MethodParameter[]数组中；
    •  
  
  • 将handler方法的参数信息与request送入参数解析器，通过参数解析器将需要的参数从request中获取出来。
    •  
 
 
 
getMethodArgumentValues()的实现如下所示。
 
 
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
        Object... providedArgs) throws Exception {

    // 获取需要执行的handler方法的参数信息
    MethodParameter[] parameters = getMethodParameters();
    if (ObjectUtils.isEmpty(parameters)) {
        return EMPTY_ARGS;
    }

    Object[] args = new Object[parameters.length];
    // 遍历所有handler方法的参数信息
    for (int i = 0; i < parameters.length; i++) {
        MethodParameter parameter = parameters[i];
        parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
        args[i] = findProvidedArgument(parameter, providedArgs);
        if (args[i] != null) {
            continue;
        }
        // 遍历所有参数解析器，寻找能够解析当前handler方法参数的参数解析器，并将其缓存
        if (!this.resolvers.supportsParameter(parameter)) {
            throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
        }
        try {
            // 将当前handler方法参数信息与request送入参数解析器，通过参数解析器将需要的参数从request中获取出来
            args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
        }
        catch (Exception ex) {
            if (logger.isDebugEnabled()) {
                String exMsg = ex.getMessage();
                if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
                    logger.debug(formatArgumentError(parameter, exMsg));
                }
            }
            throw ex;
        }
    }
    return args;
}
 
 
InvocableHandlerMethod的resolvers成员变量是一个HandlerMethodArgumentResolverComposite对象，该对象和其它参数解析器一样实现了HandlerMethodArgumentResolver接口，下面看一下其实现的resolveArgument()方法。
 
 
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    // 获取handler方法参数对应的参数解析器（一般这里不用遍历全部参数解析器，可以直接从缓存中获取）
    HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
    if (resolver == null) {
        throw new IllegalArgumentException("Unsupported parameter type [" +
                parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
    }
    // 调用参数解析器从request中获取参数
    return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}
 
 
在上面resolveArgument()方法中调用了参数解析器的resolveArgument()方法，而不同参数解析器的resolveArgument()方法实现存在一定差别。
 
 
在日常的web开发中，使用@RequestParam，@PathVariable，@RequestBody注解较多，不同注解修饰的参数对应的参数解析器不尽相同，首先看一下这三种注解对应的参数解析器的类图。
 
 
 
 
 
 
 
 
由类图可以知道，@RequestParam注解和@PathVariable注解对应的参数解析器继承于AbstractNamedValueMethodArgumentResolver抽象类，该抽象类实现了HandlerMethodArgumentResolver接口，因此这两个注解对应的参数解析器调用resolveArgument()方法实际是调用其父类实现的resolveArgument()方法。而@RequestBody注解对应的参数解析器RequestResponseBodyMethodProcessor对其父类实现的resolveArgument()方法进行了重写，故该注解对应的参数解析器调用resolveArgument()方法时实际是调用其本身重写的方法。
 
 
先看一下AbstractNamedValueMethodArgumentResolver对resolveArgument()方法的实现。
 
 
public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    // 根据handler方法的参数信息创建NamedValueInfo对象
    // 例如@RequestParam(name = "password", required = true, defaultValue = "admin") String pw
    // 创建的NamedValueInfo对象为NamedValueInfo(name=password, required=true, defaultValue=admin)
    NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
    MethodParameter nestedParameter = parameter.nestedIfOptional();

    Object resolvedName = resolveEmbeddedValuesAndExpressions(namedValueInfo.name);
    if (resolvedName == null) {
        throw new IllegalArgumentException(
                "Specified name must not resolve to null: [" + namedValueInfo.name + "]");
    }

    // 从request中解析获取参数arg
    Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
    if (arg == null) {
        if (namedValueInfo.defaultValue != null) {
            arg = resolveEmbeddedValuesAndExpressions(namedValueInfo.defaultValue);
        }
        else if (namedValueInfo.required && !nestedParameter.isOptional()) {
            handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
        }
        arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
    }
    else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
        arg = resolveEmbeddedValuesAndExpressions(namedValueInfo.defaultValue);
    }

    if (binderFactory != null) {
        // 创建WebDataBinder，并执行由@InitBinder注解修饰的方法来初始化WebDataBinder
        WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
        try {
            // 使用WebDataBinder完成arg参数的类型转换和绑定
            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());
        }
        if (arg == null && namedValueInfo.defaultValue == null &&
                namedValueInfo.required && !nestedParameter.isOptional()) {
            handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
        }
    }

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

    return arg;
}
 
 
上面源码中的resolveName()方法是AbstractNamedValueMethodArgumentResolver声明的一个抽象方法，@RequestParam注解和@PathVariable注解对应的参数解析器均对其进行了实现，具体的实现逻辑比较简单，这里不再赘述，总之该方法可以从request中获取指定名称的参数。参数获取到之后，还会通过WebDataBinderFactory创建WebDataBinder对象，在创建WebDataBinder对象的同时还会调用所有由@InitBinder注解修饰的方法来初始化WebDataBinder对象，最后使用WebDataBinder来对刚刚从request中获取到的参数进行类型转换和绑定（即先将arg参数按照我们的预期进行类型转换，然后再将arg指向转换后的值）。关于WebDataBinder如何完成类型转换和绑定，将会在后面的一篇文章中专门进行学习，这里不再进行深入。
 
 
下面再看一下RequestResponseBodyMethodProcessor对resolveArgument()方法的实现。
 
 
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    parameter = parameter.nestedIfOptional();
    // 从request中获取参数并调用消息转换器将参数转换为期望的类型
    Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());
    String name = Conventions.getVariableNameForParameter(parameter);

    if (binderFactory != null) {
        // 创建WebDataBinder，并执行由@InitBinder注解修饰的方法来初始化WebDataBinder
        WebDataBinder binder = binderFactory.createBinder(webRequest, arg, name);
        if (arg != null) {
            // 如果handler方法的参数由@Valid或@Validated注解修饰，则对刚刚获取到的参数进行参数校验
            validateIfApplicable(binder, parameter);
            // 如果校验不通过则抛出全局异常
            if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
                throw new MethodArgumentNotValidException(parameter, binder.getBindingResult());
            }
        }
        if (mavContainer != null) {
            mavContainer.addAttribute(BindingResult.MODEL_KEY_PREFIX + name, binder.getBindingResult());
        }
    }

    return adaptArgumentIfNecessary(arg, parameter);
}
 
 
readWithMessageConverters()方法实际就是调用SpringMVC框架提供的（或用户实现的）消息转换器来完成请求体到参数对象的绑定，并且如果使用了@Valid或@Validated注解来进行参数校验，则会在readWithMessageConverters()方法获取到参数对象后创建WebDataBinder来完成参数校验，如果校验不通过则会抛出MethodArgumentNotValidException全局异常，通过处理该异常可以对参数校验不过的情况进行统一处理。下面再看一下readWithMessageConverters()的实现。
 
 
protected  Object readWithMessageConverters(NativeWebRequest webRequest, MethodParameter parameter,
        Type paramType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {

    HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
    Assert.state(servletRequest != null, "No HttpServletRequest");
    ServletServerHttpRequest inputMessage = new ServletServerHttpRequest(servletRequest);
    
    // 调用父类的readWithMessageConverters()方法
    Object arg = readWithMessageConverters(inputMessage, parameter, paramType);
    if (arg == null && checkRequired(parameter)) {
        throw new HttpMessageNotReadableException("Required request body is missing: " +
                parameter.getExecutable().toGenericString(), inputMessage);
    }
    return arg;
}
 
 
在RequestResponseBodyMethodProcessor的readWithMessageConverters()方法中调用了其父类AbstractMessageConverterMethodArgumentResolver的readWithMessageConverters()方法，其实现如下所示。
 
 
protected  Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
        Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {

    MediaType contentType;
    boolean noContentType = false;
    try {
        // 获取媒体类型，例如application/json;charset=UTF-8
        contentType = inputMessage.getHeaders().getContentType();
    }
    catch (InvalidMediaTypeException ex) {
        throw new HttpMediaTypeNotSupportedException(ex.getMessage());
    }
    if (contentType == null) {
        noContentType = true;
        contentType = MediaType.APPLICATION_OCTET_STREAM;
    }

    // 获取handler的Class对象
    Class contextClass = parameter.getContainingClass();
    // targetClass表示handler方法参数类型的Class对象
    Class targetClass = (targetType instanceof Class ? (Class) targetType : null);
    if (targetClass == null) {
        ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
        targetClass = (Class) resolvableType.resolve();
    }

    // 获取http请求方法，例如POST
    HttpMethod httpMethod = (inputMessage instanceof HttpRequest ? ((HttpRequest) inputMessage).getMethod() : null);
    Object body = NO_VALUE;

    // EmptyBodyCheckingHttpInputMessage实现了HttpInputMessage接口，增强提供了一个hasBody()方法用于判断request是否有请求体
    EmptyBodyCheckingHttpInputMessage message;
    try {
        message = new EmptyBodyCheckingHttpInputMessage(inputMessage);

        // 循环遍历消息转换器
        for (HttpMessageConverter converter : this.messageConverters) {
            Class> converterType = (Class>) converter.getClass();
            GenericHttpMessageConverter genericConverter =
                    (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter) converter : null);
            // 判断消息转换器是否可以处理当前请求
            if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType) :
                    (targetClass != null && converter.canRead(targetClass, contentType))) {
                if (message.hasBody()) {
                    // 在消息转换器读取请求体前调用所有RequestBodyAdvice接口的beforeBodyRead()方法，以完成一些定制操作
                    HttpInputMessage msgToUse =
                            getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
                    // 消息转换器读取请求体并将其转换为参数对象
                    body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
                            ((HttpMessageConverter) converter).read(targetClass, msgToUse));
                    // 在消息转换器完成转换后调用所有RequestBodyAdvice接口的afterBodyRead()方法，以完成一些定制操作
                    body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
                }
                else {
                    body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
                }
                break;
            }
        }
    }
    catch (IOException ex) {
        throw new HttpMessageNotReadableException("I/O error while reading input message", ex, inputMessage);
    }

    if (body == NO_VALUE) {
        if (httpMethod == null || !SUPPORTED_METHODS.contains(httpMethod) ||
                (noContentType && !message.hasBody())) {
            return null;
        }
        throw new HttpMediaTypeNotSupportedException(contentType, this.allSupportedMediaTypes);
    }

    MediaType selectedContentType = contentType;
    Object theBody = body;
    LogFormatUtils.traceDebug(logger, traceOn -> {
        String formatted = LogFormatUtils.formatValue(theBody, !traceOn);
        return "Read \"" + selectedContentType + "\" to [" + formatted + "]";
    });

    return body;
}
 
 
在AbstractMessageConverterMethodArgumentResolver的readWithMessageConverters()方法中，会循环遍历所有消息转换器并判断其是否可以处理当前请求，同一个请求只会有一个消息转换器可以处理。消息转换器读取请求体前，会先获取所有适配当前handler的RequestBodyAdvice接口，然后循环遍历这些接口并执行其beforeBodyRead()方法，以完成一些定制处理，同理在消息转换器完成转换后还会循环遍历这些接口并执行其afterBodyRead()方法，这里使用了Spring的AOP：如果是由@ControllerAdvice注解修饰的RequestBodyAdvice接口（切面），那么会根据@ControllerAdvice注解的配置信息来判断该切片是否适配当前handler，如果是不由@ControllerAdvice注解修饰的RequestBodyAdvice接口（切面），则直接判断该切片适配当前handler。
 
 
至此，从request中解析@RequestParam，@PathVariable和@RequestBody注解修饰的参数的流程基本分析完毕。
 
 
小节：RequestMappingHandlerAdapter在解析参数前会根据需要执行的handler方法生成一个ServletInvocableHandlerMethod对象，然后为该对象加载参数解析器，在进行参数解析时，会遍历所有加载的参数解析器并判断遍历到的参数解析器能否解析当前参数，如果能，则使用该参数解析器完成参数解析。
 
 
三. RequestMappingHandlerAdapter执行handler方法
 
 
在上一小节中已经知道，handler方法的参数获取和执行发生在InvocableHandlerMethod的invokeForRequest()方法中，再给出该方法的源码如下所示。
 
 
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
        Object... providedArgs) throws Exception {

    // 解析参数
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    if (logger.isTraceEnabled()) {
        logger.trace("Arguments: " + Arrays.toString(args));
    }
    // 执行handler
    return doInvoke(args);
}
 
 
上一小节主要是学习getMethodArgumentValues()方法做了什么事情，本小节开始学习doInvoke()方法如何执行handler。doInvoke()方法实现如下所示。
 
 
protected Object doInvoke(Object... args) throws Exception {
    // 如果handler方法是桥接方法则获取其桥接方法，否则获取其本身
    Method method = getBridgedMethod();
    ReflectionUtils.makeAccessible(method);
    try {
        if (KotlinDetector.isSuspendingFunction(method)) {
            return CoroutinesUtils.invokeSuspendingFunction(method, getBean(), args);
        }
        // 反射方式调用handler方法，getBean()获取handler对象，args是解析得到的参数
        return method.invoke(getBean(), args);
    }
    catch (IllegalArgumentException ex) {
        assertTargetBean(method, getBean(), args);
        String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
        throw new IllegalStateException(formatInvokeError(text, args), ex);
    }
    catch (InvocationTargetException ex) {
        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方法的执行是通过反射的方式实现的。
 
 
四. RequestMappingHandlerAdapter处理返回结果
 
 
在第二小节中已经知道，返回值处理是发生在ServletInvocableHandlerMethod对象的invokeAndHandle()方法中，再给出其实现如下所示。
 
 
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
        Object... providedArgs) throws Exception {

    // 参数解析，执行handler
    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    setResponseStatus(webRequest);

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

    mavContainer.setRequestHandled(false);
    Assert.state(this.returnValueHandlers != null, "No return value handlers");
    try {
        // 返回值处理
        this.returnValueHandlers.handleReturnValue(
                returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    }
    catch (Exception ex) {
        if (logger.isTraceEnabled()) {
            logger.trace(formatErrorForReturnValue(returnValue), ex);
        }
        throw ex;
    }
}
 
 
ServletInvocableHandlerMethod对象的成员变量returnValueHandlers是一个HandlerMethodReturnValueHandlerComposite对象，下面看一下该对象的handleReturnValue()方法。
 
 
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
        ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {
    
    // 根据返回值类型匹配返回值处理器
    HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
    if (handler == null) {
        throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
    }
    // 返回值处理器对返回值进行处理
    handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}
 
 
在handleReturnValue()方法中先是根据返回值类型匹配对应的返回值处理器，然后用匹配到的返回值处理器对返回值进行处理。基于SpringMVC框架进行web开发时，比较标准的返回值类型应该为ResponseEntity，该类是由Spring提供的一个继承于HttpEntity的响应实体类，ResponseEntity相较于HttpEntity增加了响应状态码的成员变量，SpringMVC框架专门提供了一个ResponseEntity对应的返回值处理器HttpEntityMethodProcessor。同时，如果返回值类型是一般类型或者自定义类型，但是handler方法或者handler由@ResponseBody注解修饰，那么这种情况对应的返回值处理器是第二小节中出现过的RequestResponseBodyMethodProcessor。那么现在以HttpEntityMethodProcessor和RequestResponseBodyMethodProcessor这两个返回值处理器为例，对返回值处理器如何处理返回值进行学习。
 
 
首先看一下这两个返回值处理器的类图。
 
 
 
 
 
 
HttpEntityMethodProcessor和RequestResponseBodyMethodProcessor均实现了HandlerMethodReturnValueHandler接口，该接口声明了一个用于判断返回值处理器是否可以处理当前返回值的方法supportsReturnType()。HttpEntityMethodProcessor对该方法的实现如下。
 
 
public boolean supportsReturnType(MethodParameter returnType) {
    // 可以处理类型是HttpEntity且不是RequestEntity的返回值
    return (HttpEntity.class.isAssignableFrom(returnType.getParameterType()) &&
            !RequestEntity.class.isAssignableFrom(returnType.getParameterType()));
}
 
 
RequestResponseBodyMethodProcessor对该方法的实现如下。
 
 
public boolean supportsReturnType(MethodParameter returnType) {
    // 如果返回值所在方法或类由@ResponseBody注解修饰，则可以处理
    return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) ||
            returnType.hasMethodAnnotation(ResponseBody.class));
}
 
 
特别说明一下，每次循环遍历返回值处理器时时，HttpEntityMethodProcessor会比RequestResponseBodyMethodProcessor先被遍历到，因此如果handler类或handler方法既由@ResponseBody注解修饰同时返回值类型还是ResponseEntity，那么还是会使用HttpEntityMethodProcessor来处理该返回值。
 
 
HandlerMethodReturnValueHandler接口还声明了一个方法为handleReturnValue()，该方法会实际的执行处理返回值的逻辑。HttpEntityMethodProcessor对该方法的实现如下。
 
 
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
        ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

    mavContainer.setRequestHandled(true);
    if (returnValue == null) {
        return;
    }

    // 将HttpServletRequest封装成ServletServerHttpRequest对象
    ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
    // 将HttpServletResponse封装成ServletServerHttpResponse对象
    ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

    Assert.isInstanceOf(HttpEntity.class, returnValue);
    HttpEntity responseEntity = (HttpEntity) returnValue;

    HttpHeaders outputHeaders = outputMessage.getHeaders();
    HttpHeaders entityHeaders = responseEntity.getHeaders();
    if (!entityHeaders.isEmpty()) {
        // 设置响应头字段
        entityHeaders.forEach((key, value) -> {
            if (HttpHeaders.VARY.equals(key) && outputHeaders.containsKey(HttpHeaders.VARY)) {
                List values = getVaryRequestHeadersToAdd(outputHeaders, entityHeaders);
                if (!values.isEmpty()) {
                    outputHeaders.setVary(values);
                }
            }
            else {
                outputHeaders.put(key, value);
            }
        });
    }

    if (responseEntity instanceof ResponseEntity) {
        // 从ResponseEntity中获取响应码
        int returnStatus = ((ResponseEntity) responseEntity).getStatusCodeValue();
        // 设置HttpServletResponse的响应码
        outputMessage.getServletResponse().setStatus(returnStatus);
        if (returnStatus == 200) {
            HttpMethod method = inputMessage.getMethod();
            // 如果响应码为200，且http请求方法为GET或者HEAD，且请求的资源没有改变，此时立即调用HttpServletResponse的flushBuffer()方法将缓冲区的内容写入客户端
            if ((HttpMethod.GET.equals(method) || HttpMethod.HEAD.equals(method))
                    && isResourceNotModified(inputMessage, outputMessage)) {
                outputMessage.flush();
                return;
            }
        }
        else if (returnStatus / 100 == 3) {
            String location = outputHeaders.getFirst("location");
            if (location != null) {
                // 如果是重定向场景，将flash attributes添加到session中
                saveFlashAttributes(mavContainer, webRequest, location);
            }
        }
    }

    // 调用消息转换器将返回值写入响应
    writeWithMessageConverters(responseEntity.getBody(), returnType, inputMessage, outputMessage);

    outputMessage.flush();
}
 
 
RequestResponseBodyMethodProcessor对该方法的实现如下。
 
 
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
        ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
        throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

    mavContainer.setRequestHandled(true);
    ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
    ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

    writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
}
 
 
可以发现，HttpEntityMethodProcessor和RequestResponseBodyMethodProcessor在handleReturnValue()方法中做了同样的事情：先将ModelAndViewContainer对象的handler方法是否执行标志设置为true，然后基于HttpServletRequest和HttpServletResponse对象创建ServletServerHttpRequest和ServletServerHttpResponse对象，最后调用公共父类AbstractMessageConverterMethodProcessor的writeWithMessageConverters()方法处理返回值。其中HttpEntityMethodProcessor多做了两件事情：设置响应头和设置响应码。最后看一下writeWithMessageConverters()的实现。
 
 
protected  void writeWithMessageConverters(@Nullable T value, MethodParameter returnType,
        ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
        throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

    Object body;
    // 返回值类型的Class对象
    Class valueType;
    // 返回值的泛型类型
    Type targetType;

    if (value instanceof CharSequence) {
        body = value.toString();
        valueType = String.class;
        targetType = String.class;
    }
    else {
        body = value;
        valueType = getReturnValueType(body, returnType);
        targetType = GenericTypeResolver.resolveType(getGenericType(returnType), returnType.getContainingClass());
    }

    // 判断返回值类型是否是InputStreamResource或者Resource
    if (isResourceType(value, returnType)) {
        outputMessage.getHeaders().set(HttpHeaders.ACCEPT_RANGES, "bytes");
        if (value != null && inputMessage.getHeaders().getFirst(HttpHeaders.RANGE) != null &&
                outputMessage.getServletResponse().getStatus() == 200) {
            Resource resource = (Resource) value;
            try {
                List httpRanges = inputMessage.getHeaders().getRange();
                outputMessage.getServletResponse().setStatus(HttpStatus.PARTIAL_CONTENT.value());
                body = HttpRange.toResourceRegions(httpRanges, resource);
                valueType = body.getClass();
                targetType = RESOURCE_REGION_LIST_TYPE;
            }
            catch (IllegalArgumentException ex) {
                outputMessage.getHeaders().set(HttpHeaders.CONTENT_RANGE, "bytes */" + resource.contentLength());
                outputMessage.getServletResponse().setStatus(HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE.value());
            }
        }
    }

    // selectedMediaType表示响应体的媒体类型
    MediaType selectedMediaType = null;
    // 从响应头中获取媒体类型，如果在handler方法中没有手动设置响应体的媒体类型那么这里的contentType为null
    MediaType contentType = outputMessage.getHeaders().getContentType();
    boolean isContentTypePreset = contentType != null && contentType.isConcrete();
    // 如果在handler方法中设置了响应体媒体类型，则消息转换器使用设置的媒体类型对返回值进行类型转换
    // 如果在handler方法中没有设置响应体媒体类型，则从请求中获取客户端接受的媒体类型并选取最合适的媒体类型
    if (isContentTypePreset) {
        if (logger.isDebugEnabled()) {
            logger.debug("Found 'Content-Type:" + contentType + "' in response");
        }
        selectedMediaType = contentType;
    }
    else {
        HttpServletRequest request = inputMessage.getServletRequest();
        List acceptableTypes = getAcceptableMediaTypes(request);
        List producibleTypes = getProducibleMediaTypes(request, valueType, targetType);

        if (body != null && producibleTypes.isEmpty()) {
            throw new HttpMessageNotWritableException(
                    "No converter found for return value of type: " + valueType);
        }
        List mediaTypesToUse = new ArrayList<>();
        for (MediaType requestedType : acceptableTypes) {
            for (MediaType producibleType : producibleTypes) {
                if (requestedType.isCompatibleWith(producibleType)) {
                    mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
                }
            }
        }
        if (mediaTypesToUse.isEmpty()) {
            if (body != null) {
                throw new HttpMediaTypeNotAcceptableException(producibleTypes);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("No match for " + acceptableTypes + ", supported: " + producibleTypes);
            }
            return;
        }

        MediaType.sortBySpecificityAndQuality(mediaTypesToUse);

        for (MediaType mediaType : mediaTypesToUse) {
            if (mediaType.isConcrete()) {
                selectedMediaType = mediaType;
                break;
            }
            else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
                selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
                break;
            }
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Using '" + selectedMediaType + "', given " +
                    acceptableTypes + " and supported " + producibleTypes);
        }
    }

    if (selectedMediaType != null) {
        selectedMediaType = selectedMediaType.removeQualityValue();
        // 遍历所有消息转换器
        for (HttpMessageConverter converter : this.messageConverters) {
            GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ?
                    (GenericHttpMessageConverter) converter : null);
            // 判断消息转换器是否支持转换当前返回值为期望的媒体类型
            if (genericConverter != null ?
                    ((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) :
                    converter.canWrite(valueType, selectedMediaType)) {
                // 在消息转换器转换返回值前调用所有ResponseBodyAdvice接口的beforeBodyWrite()方法，以完成一些定制操作
                body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType,
                        (Class>) converter.getClass(),
                        inputMessage, outputMessage);
                if (body != null) {
                    Object theBody = body;
                    LogFormatUtils.traceDebug(logger, traceOn ->
                            "Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
                    // Content-Disposition响应头字段处理
                    addContentDispositionHeader(inputMessage, outputMessage);
                    // 调用消息处理器将返回值按照期望的媒体类型写入响应体
                    if (genericConverter != null) {
                        genericConverter.write(body, targetType, selectedMediaType, outputMessage);
                    }
                    else {
                        ((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
                    }
                }
                else {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Nothing to write: null body");
                    }
                }
                return;
            }
        }
    }

    if (body != null) {
        Set producibleMediaTypes =
                (Set) inputMessage.getServletRequest()
                        .getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

        if (isContentTypePreset || !CollectionUtils.isEmpty(producibleMediaTypes)) {
            throw new HttpMessageNotWritableException(
                    "No converter for [" + valueType + "] with preset Content-Type '" + contentType + "'");
        }
        throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
    }
}
 
 
在writeWithMessageConverters()方法中，主要是获取响应体媒体类型，然后调用消息转换器将返回值按照期望的媒体类型写入响应体，在写入前还会执行ResponseBodyAdvice切面对返回值实现一些定制操作。
 
 
小节：RequestMappingHandlerAdapter处理返回值首先会根据返回值类型匹配相应的返回值处理器来处理返回值，在返回值处理器中通常是先获取响应体的媒体类型，然后调用消息转换器将返回值按照期望的媒体类型写入响应体。
 
 
总结
 
 
RequestMappingHandlerAdapter是基于SpringMVC框架进行web开发使用频次最高的组件之一，RequestMappingHandlerAdapter在handler方法执行前会使用SpringMVC框架提供的和用户实现的参数解析器从request中获取handler方法需要的参数，然后基于反射方式调用handler方法，最后会使用SpringMVC框架提供的和用户实现的返回值处理器将handler方法的返回值写入响应体中。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(SpringMVC-RequestMappingHandlerAdapter)

        

            

                
    
                    
  • SpringMVC-RequestMappingHandlerAdapter
                        

                        
    前言在SpringMVC-RequestMappingHandlerMapping中对web请求到来时如何获取处理该请求的handler进行了分析，那么获取到web请求对应的handler之后，SpringMVC框架还会根据handler获取其对应的HandlerAdapter，handler的实际执行就是由HandlerAdapter完成，并且HandlerAdapter一共会做三件事情：入参解
    
                    
    • 
                                
  • JAVA中的Enum
                                    周凡杨
javaenum枚举
                                    
    Enum是计算机编程语言中的一种数据类型---枚举类型。 在实际问题中，有些变量的取值被限定在一个有限的范围内。       例如，一个星期内只有七天 我们通常这样实现上面的定义： 
public String monday;
public String tuesday;
public String wensday;
public String thursday
    
                                
    • 
                                
  • 赶集网mysql开发36条军规
                                    Bill_chen
mysql业务架构设计mysql调优mysql性能优化
                                    
    (一)核心军规   (1)不在数据库做运算      cpu计算务必移至业务层；   (2)控制单表数据量      int型不超过1000w，含char则不超过500w；      合理分表；      限制单库表数量在300以内；   (3)控制列数量      字段少而精，字段数建议在20以内
    
                                
    • 
                                
  • Shell test命令
                                    daizj
shell字符串test数字文件比较
                                    
    Shell test命令 
Shell中的 test 命令用于检查某个条件是否成立，它可以进行数值、字符和文件三个方面的测试。  数值测试    参数 说明   -eq 等于则为真   -ne 不等于则为真   -gt 大于则为真   -ge 大于等于则为真   -lt 小于则为真   -le 小于等于则为真    
实例演示： 
num1=100
num2=100if test $[num1]
    
                                
    • 
                                
  • XFire框架实现WebService(二)
                                    周凡杨
javawebservice
                                    
       有了XFire框架实现WebService(一)，就可以继续开发WebService的简单应用。 
Webservice的服务端(WEB工程)： 
两个java bean类： 
Course.java 
   package cn.com.bean; 
public class Course { 
    private 
    
                                
    • 
                                
  • 重绘之画图板
                                    朱辉辉33
画图板
                                    
           上次博客讲的五子棋重绘比较简单，因为只要在重写系统重绘方法paint（）时加入棋盘和棋子的绘制。这次我想说说画图板的重绘。 
       画图板重绘难在需要重绘的类型很多，比如说里面有矩形，园，直线之类的，所以我们要想办法将里面的图形加入一个队列中，这样在重绘时就
    
                                
    • 
                                
  • Java的IO流
                                    西蜀石兰
java
                                    
    刚学Java的IO流时，被各种inputStream流弄的很迷糊，看老罗视频时说想象成插在文件上的一根管道，当初听时觉得自己很明白，可到自己用时，有不知道怎么代码了。。。 
每当遇到这种问题时，我习惯性的从头开始理逻辑，会问自己一些很简单的问题，把这些简单的问题想明白了，再看代码时才不会迷糊。 
 
IO流作用是什么？ 
答：实现对文件的读写，这里的文件是广义的； 
 
Java如何实现程序到文件
    
                                
    • 
                                
  • No matching PlatformTransactionManager bean found for qualifier 'add' - neither
                                    林鹤霄

                                    
    java.lang.IllegalStateException: No matching PlatformTransactionManager bean found for qualifier 'add' - neither qualifier match nor bean name match! 
  
网上找了好多的资料没能解决，后来发现：项目中使用的是xml配置的方式配置事务，但是
    
                                
    • 
                                
  • Row size too large (> 8126). Changing some columns to TEXT or BLOB
                                    aigo
column
                                    
    原文：http://stackoverflow.com/questions/15585602/change-limit-for-mysql-row-size-too-large 
  
异常信息： 
Row size too large (> 8126). Changing some columns to TEXT or BLOB or using ROW_FORMAT=DYNAM
    
                                
    • 
                                
  • JS 格式化时间
                                    alxw4616
JavaScript
                                    
    /**
 * 格式化时间 2013/6/13 by 半仙 [email protected]
 * 需要 pad 函数
 * 接收可用的时间值.
 * 返回替换时间占位符后的字符串
 *
 * 时间占位符:年 Y 月 M 日 D 小时 h 分 m 秒 s 重复次数表示占位数
 * 如 YYYY 4占4位 YY 占2位<p></p>
 * MM DD hh mm
    
                                
    • 
                                
  • 队列中数据的移除问题
                                    百合不是茶
队列移除
                                    
      
   队列的移除一般都是使用的remov();都可以移除的,但是在昨天做线程移除的时候出现了点问题,没有将遍历出来的全部移除,  代码如下; 
  
   // 
package com.Thread0715.com;

import java.util.ArrayList;

public class Threa
    
                                
    • 
                                
  • Runnable接口使用实例
                                    bijian1013
javathreadRunnablejava多线程
                                    
    Runnable接口 
a.       该接口只有一个方法：public void run(); 
b.       实现该接口的类必须覆盖该run方法 
c.       实现了Runnable接口的类并不具有任何天
    
                                
    • 
                                
  • oracle里的extend详解
                                    bijian1013
oracle数据库extend
                                    
    扩展已知的数组空间，例： 
DECLARE
  TYPE CourseList IS TABLE OF VARCHAR2(10);
  courses CourseList;
BEGIN
  --   初始化数组元素，大小为3
  courses := CourseList('Biol   4412 ', 'Psyc   3112 ', 'Anth   3001 ');
  --   
    
                                
    • 
                                
  • 【httpclient】httpclient发送表单POST请求
                                    bit1129
httpclient
                                    
    浏览器Form Post请求 
浏览器可以通过提交表单的方式向服务器发起POST请求，这种形式的POST请求不同于一般的POST请求 
1. 一般的POST请求，将请求数据放置于请求体中，服务器端以二进制流的方式读取数据，HttpServletRequest.getInputStream()。这种方式的请求可以处理任意数据形式的POST请求，比如请求数据是字符串或者是二进制数据 
2. Form 
    
                                
    • 
                                
  • 【Hive十三】Hive读写Avro格式的数据
                                    bit1129
hive
                                    
     1. 原始数据 
hive> select * from word; 
OK
1	MSN  
10	QQ  
100	Gtalk  
1000	Skype  
  
  
 2. 创建avro格式的数据表 
  
hive> CREATE TABLE avro_table(age INT, name STRING)STORE
    
                                
    • 
                                
  • nginx+lua+redis自动识别封解禁频繁访问IP
                                    ronin47

                                    
    在站点遇到攻击且无明显攻击特征，造成站点访问慢，nginx不断返回502等错误时，可利用nginx+lua+redis实现在指定的时间段 内，若单IP的请求量达到指定的数量后对该IP进行封禁，nginx返回403禁止访问。利用redis的expire命令设置封禁IP的过期时间达到在 指定的封禁时间后实行自动解封的目的。 
一、安装环境： 
 
 CentOS x64 release 6.4(Fin
    
                                
    • 
                                
  • java-二叉树的遍历-先序、中序、后序（递归和非递归）、层次遍历
                                    bylijinnan
java
                                    
    
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;


public class BinTreeTraverse {
	//private int[] array={ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	private int[] array={ 10,6,
    
                                
    • 
                                
  • Spring源码学习-XML 配置方式的IoC容器启动过程分析
                                    bylijinnan
javaspringIOC
                                    
    以FileSystemXmlApplicationContext为例，把Spring IoC容器的初始化流程走一遍： 
 

ApplicationContext context = new FileSystemXmlApplicationContext
            ("C:/Users/ZARA/workspace/HelloSpring/src/Beans.xml&q
    
                                
    • 
                                
  • [科研与项目]民营企业请慎重参与军事科技工程
                                    comsci
企业
                                    
     
 
     军事科研工程和项目 并非要用最先进，最时髦的技术，而是要做到“万无一失” 
 
   而民营科技企业在搞科技创新工程的时候，往往考虑的是技术的先进性，而对先进技术带来的风险考虑得不够，在今天提倡军民融合发展的大环境下，这种“万无一失”和“时髦性”的矛盾会日益凸显。。。。。。所以请大家在参与任何重大的军事和政府项目之前，对
    
                                
    • 
                                
  • spring 定时器-两种方式
                                    cuityang
springquartz定时器
                                    
    方式一： 
间隔一定时间 运行 
 
<bean id="updateSessionIdTask" class="com.yang.iprms.common.UpdateSessionTask" autowire="byName" /> 
 
 <bean id="updateSessionIdSchedule
    
                                
    • 
                                
  • 简述一下关于BroadView站点的相关设计
                                    damoqiongqiu
view
                                    
    终于弄上线了，累趴，戳这里http://www.broadview.com.cn 
  
简述一下相关的技术点 
  
前端：jQuery+BootStrap3.2+HandleBars，全站Ajax（貌似对SEO的影响很大啊！怎么破？），用Grunt对全部JS做了压缩处理，对部分JS和CSS做了合并（模块间存在很多依赖，全部合并比较繁琐，待完善）。 
  
后端：U
    
                                
    • 
                                
  • 运维 PHP问题汇总
                                    dcj3sjt126com
windows2003
                                    
    1、Dede(织梦)发表文章时,内容自动添加关键字显示空白页 
解决方法： 
后台>系统>系统基本参数>核心设置>关键字替换（是/否），这里选择“是”。 
后台>系统>系统基本参数>其他选项>自动提取关键字，这里选择“是”。 
  
2、解决PHP168超级管理员上传图片提示你的空间不足 
网站是用PHP168做的，反映使用管理员在后台无法
    
                                
    • 
                                
  • mac 下 安装php扩展 - mcrypt
                                    dcj3sjt126com
PHP
                                    
    MCrypt是一个功能强大的加密算法扩展库，它包括有22种算法，phpMyAdmin依赖这个PHP扩展，具体如下： 
 
  
  下载并解压libmcrypt-2.5.8.tar.gz。 
  在终端执行如下命令：  tar zxvf libmcrypt-2.5.8.tar.gz cd libmcrypt-2.5.8/ ./configure --disable-posix-threads --
    
                                
    • 
                                
  • MongoDB更新文档 [四]
                                    eksliang
mongodbMongodb更新文档
                                    
    MongoDB更新文档 
转载请出自出处：http://eksliang.iteye.com/blog/2174104 
MongoDB对文档的CURD，前面的博客简单介绍了，但是对文档更新篇幅比较大，所以这里单独拿出来。 
语法结构如下： 
db.collection.update( criteria, objNew, upsert, multi) 
参数含义    参数   
    
                                
    • 
                                
  • Linux下的解压，移除，复制，查看tomcat命令
                                    y806839048
tomcat
                                    
    重复myeclipse生成webservice有问题删除以前的，干净 
 
 1、先切换到：cd usr/local/tomcat5/logs 
 
2、tail -f catalina.out 
 
3、这样运行时就可以实时查看运行日志了 
 
 
 
 
Ctrl+c 是退出tail命令。 
 有问题不明的先注掉 
   cp /opt/tomcat-6.0.44/webapps/g
    
                                
    • 
                                
  • Spring之使用事务缘由(3-XML实现)
                                    ihuning
spring
                                    
      
用事务通知声明式地管理事务 
  
事务管理是一种横切关注点。为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 <tx:advice> 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去。声明了事务通知后，就需要将它与切入点关联起来。由于事务通知是在 <aop:
    
                                
    • 
                                
  • GCD使用经验与技巧浅谈
                                    啸笑天
GC
                                    
    前言 
GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。 
dispatch_once_t必须是全局或static变量 
这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下：        1  
    
                                
    • 
                                
  • linux（Ubuntu）下常用命令备忘录1
                                    macroli
linux工作ubuntu
                                    
    在使用下面的命令是可以通过--help来获取更多的信息1,查询当前目录文件列表：ls 
 
 ls命令默认状态下将按首字母升序列出你当前文件夹下面的所有内容，但这样直接运行所得到的信息也是比较少的，通常它可以结合以下这些参数运行以查询更多的信息：  
 ls / 显示/.下的所有文件和目录  
 ls -l 给出文件或者文件夹的详细信息 
 ls -a 显示所有文件，包括隐藏文
    
                                
    • 
                                
  • nodejs同步操作mysql
                                    qiaolevip
学习永无止境每天进步一点点mysqlnodejs
                                    
    // db-util.js
var mysql = require('mysql');
var pool = mysql.createPool({
  connectionLimit : 10,
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'test',
  port: 3306
});


    
                                
    • 
                                
  • 一起学Hive系列文章
                                    superlxw1234
hiveHive入门
                                    
      
[一起学Hive]系列文章 目录贴，入门Hive，持续更新中。 
  
[一起学Hive]之一—Hive概述，Hive是什么 
[一起学Hive]之二—Hive函数大全-完整版 
[一起学Hive]之三—Hive中的数据库(Database)和表(Table) 
[一起学Hive]之四-Hive的安装配置 
[一起学Hive]之五-Hive的视图和分区 
[一起学Hive
    
                                
    • 
                                
  • Spring开发利器：Spring Tool Suite 3.7.0 发布
                                    wiselyman
spring
                                    
    Spring Tool Suite(简称STS)是基于Eclipse，专门针对Spring开发者提供大量的便捷功能的优秀开发工具。 
  
在3.7.0版本主要做了如下的更新： 
  
 
 将eclipse版本更新至Eclipse Mars 4.5 GA 
 Spring Boot(JavaEE开发的颠覆者集大成者，推荐大家学习)的配置语言YAML编辑器的支持(包含自动提示，
    
                                
    •