diff --git a/spring-datastore-document-core/src/main/java/org/springframework/datastore/document/web/bind/annotation/support/HandlerMethodInvoker.java b/spring-datastore-document-core/src/main/java/org/springframework/datastore/document/web/bind/annotation/support/HandlerMethodInvoker.java
new file mode 100644
index 000000000..2fa6fc96d
--- /dev/null
+++ b/spring-datastore-document-core/src/main/java/org/springframework/datastore/document/web/bind/annotation/support/HandlerMethodInvoker.java
@@ -0,0 +1,898 @@
+/*
+ * Copyright 2002-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package org.springframework.datastore.document.web.bind.annotation.support;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.core.BridgeMethodResolver;
+import org.springframework.core.Conventions;
+import org.springframework.core.GenericTypeResolver;
+import org.springframework.core.MethodParameter;
+import org.springframework.core.ParameterNameDiscoverer;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpInputMessage;
+import org.springframework.http.HttpOutputMessage;
+import org.springframework.http.MediaType;
+import org.springframework.http.converter.HttpMessageConverter;
+import org.springframework.ui.ExtendedModelMap;
+import org.springframework.ui.Model;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.util.ReflectionUtils;
+import org.springframework.validation.BindException;
+import org.springframework.validation.BindingResult;
+import org.springframework.validation.Errors;
+import org.springframework.web.HttpMediaTypeNotSupportedException;
+import org.springframework.web.bind.WebDataBinder;
+import org.springframework.web.bind.annotation.CookieValue;
+import org.springframework.web.bind.annotation.InitBinder;
+import org.springframework.web.bind.annotation.ModelAttribute;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ValueConstants;
+import org.springframework.web.bind.annotation.support.HandlerMethodInvocationException;
+import org.springframework.web.bind.annotation.support.HandlerMethodResolver;
+import org.springframework.web.bind.support.DefaultSessionAttributeStore;
+import org.springframework.web.bind.support.SessionAttributeStore;
+import org.springframework.web.bind.support.SessionStatus;
+import org.springframework.web.bind.support.SimpleSessionStatus;
+import org.springframework.web.bind.support.WebArgumentResolver;
+import org.springframework.web.bind.support.WebBindingInitializer;
+import org.springframework.web.bind.support.WebRequestDataBinder;
+import org.springframework.web.context.request.NativeWebRequest;
+import org.springframework.web.context.request.WebRequest;
+import org.springframework.web.multipart.MultipartFile;
+import org.springframework.web.multipart.MultipartRequest;
+
+/**
+ * Support class for invoking an annotated handler method. Operates on the introspection results of a {@link
+ * HandlerMethodResolver} for a specific handler type.
+ *
+ * Used by {@link org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter} and {@link
+ * org.springframework.web.portlet.mvc.annotation.AnnotationMethodHandlerAdapter}.
+ *
+ * @author Juergen Hoeller
+ * @author Arjen Poutsma
+ * @since 2.5.2
+ * @see #invokeHandlerMethod
+ */
+public class HandlerMethodInvoker {
+
+ private static final String MODEL_KEY_PREFIX_STALE = SessionAttributeStore.class.getName() + ".STALE.";
+
+ /** We'll create a lot of these objects, so we don't want a new logger every time. */
+ private static final Log logger = LogFactory.getLog(HandlerMethodInvoker.class);
+
+ private final HandlerMethodResolver methodResolver;
+
+ private final WebBindingInitializer bindingInitializer;
+
+ private final SessionAttributeStore sessionAttributeStore;
+
+ private final ParameterNameDiscoverer parameterNameDiscoverer;
+
+ private final WebArgumentResolver[] customArgumentResolvers;
+
+ private final HttpMessageConverter[] messageConverters;
+
+ private final SimpleSessionStatus sessionStatus = new SimpleSessionStatus();
+
+
+ public HandlerMethodInvoker(HandlerMethodResolver methodResolver) {
+ this(methodResolver, null);
+ }
+
+ public HandlerMethodInvoker(HandlerMethodResolver methodResolver, WebBindingInitializer bindingInitializer) {
+ this(methodResolver, bindingInitializer, new DefaultSessionAttributeStore(), null, null, null);
+ }
+
+ public HandlerMethodInvoker(HandlerMethodResolver methodResolver, WebBindingInitializer bindingInitializer,
+ SessionAttributeStore sessionAttributeStore, ParameterNameDiscoverer parameterNameDiscoverer,
+ WebArgumentResolver[] customArgumentResolvers, HttpMessageConverter[] messageConverters) {
+
+ this.methodResolver = methodResolver;
+ this.bindingInitializer = bindingInitializer;
+ this.sessionAttributeStore = sessionAttributeStore;
+ this.parameterNameDiscoverer = parameterNameDiscoverer;
+ this.customArgumentResolvers = customArgumentResolvers;
+ this.messageConverters = messageConverters;
+ }
+
+
+ public final Object invokeHandlerMethod(Method handlerMethod, Object handler,
+ NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
+
+ Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod);
+ try {
+ boolean debug = logger.isDebugEnabled();
+ for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
+ Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName);
+ if (attrValue != null) {
+ implicitModel.addAttribute(attrName, attrValue);
+ }
+ }
+ for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) {
+ Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod);
+ Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel);
+ if (debug) {
+ logger.debug("Invoking model attribute method: " + attributeMethodToInvoke);
+ }
+ String attrName = AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value();
+ if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) {
+ continue;
+ }
+ ReflectionUtils.makeAccessible(attributeMethodToInvoke);
+ Object attrValue = attributeMethodToInvoke.invoke(handler, args);
+ if ("".equals(attrName)) {
+ Class resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass());
+ attrName = Conventions.getVariableNameForReturnType(attributeMethodToInvoke, resolvedType, attrValue);
+ }
+ if (!implicitModel.containsAttribute(attrName)) {
+ implicitModel.addAttribute(attrName, attrValue);
+ }
+ }
+ Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
+ if (debug) {
+ logger.debug("Invoking request handler method: " + handlerMethodToInvoke);
+ }
+ ReflectionUtils.makeAccessible(handlerMethodToInvoke);
+ return handlerMethodToInvoke.invoke(handler, args);
+ }
+ catch (IllegalStateException ex) {
+ // Internal assertion failed (e.g. invalid signature):
+ // throw exception with full handler method context...
+ throw new HandlerMethodInvocationException(handlerMethodToInvoke, ex);
+ }
+ catch (InvocationTargetException ex) {
+ // User-defined @ModelAttribute/@InitBinder/@RequestMapping method threw an exception...
+ ReflectionUtils.rethrowException(ex.getTargetException());
+ return null;
+ }
+ }
+
+ public final void updateModelAttributes(Object handler, Map mavModel,
+ ExtendedModelMap implicitModel, NativeWebRequest webRequest) throws Exception {
+
+ if (this.methodResolver.hasSessionAttributes() && this.sessionStatus.isComplete()) {
+ for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
+ this.sessionAttributeStore.cleanupAttribute(webRequest, attrName);
+ }
+ }
+
+ // Expose model attributes as session attributes, if required.
+ // Expose BindingResults for all attributes, making custom editors available.
+ Map model = (mavModel != null ? mavModel : implicitModel);
+ if (model != null) {
+ try {
+ String[] originalAttrNames = model.keySet().toArray(new String[model.size()]);
+ for (String attrName : originalAttrNames) {
+ Object attrValue = model.get(attrName);
+ boolean isSessionAttr = this.methodResolver.isSessionAttribute(
+ attrName, (attrValue != null ? attrValue.getClass() : null));
+ if (isSessionAttr) {
+ if (this.sessionStatus.isComplete()) {
+ implicitModel.put(MODEL_KEY_PREFIX_STALE + attrName, Boolean.TRUE);
+ }
+ else if (!implicitModel.containsKey(MODEL_KEY_PREFIX_STALE + attrName)) {
+ this.sessionAttributeStore.storeAttribute(webRequest, attrName, attrValue);
+ }
+ }
+ if (!attrName.startsWith(BindingResult.MODEL_KEY_PREFIX) &&
+ (isSessionAttr || isBindingCandidate(attrValue))) {
+ String bindingResultKey = BindingResult.MODEL_KEY_PREFIX + attrName;
+ if (mavModel != null && !model.containsKey(bindingResultKey)) {
+ WebDataBinder binder = createBinder(webRequest, attrValue, attrName);
+ initBinder(handler, attrName, binder, webRequest);
+ mavModel.put(bindingResultKey, binder.getBindingResult());
+ }
+ }
+ }
+ }
+ catch (InvocationTargetException ex) {
+ // User-defined @InitBinder method threw an exception...
+ ReflectionUtils.rethrowException(ex.getTargetException());
+ }
+ }
+ }
+
+
+ private Object[] resolveHandlerArguments(Method handlerMethod, Object handler,
+ NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
+
+ Class[] paramTypes = handlerMethod.getParameterTypes();
+ Object[] args = new Object[paramTypes.length];
+
+ for (int i = 0; i < args.length; i++) {
+ MethodParameter methodParam = new MethodParameter(handlerMethod, i);
+ methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer);
+ GenericTypeResolver.resolveParameterType(methodParam, handler.getClass());
+ String paramName = null;
+ String headerName = null;
+ boolean requestBodyFound = false;
+ String cookieName = null;
+ String pathVarName = null;
+ String attrName = null;
+ boolean required = false;
+ String defaultValue = null;
+ boolean validate = false;
+ int annotationsFound = 0;
+ Annotation[] paramAnns = methodParam.getParameterAnnotations();
+
+ for (Annotation paramAnn : paramAnns) {
+ if (RequestParam.class.isInstance(paramAnn)) {
+ RequestParam requestParam = (RequestParam) paramAnn;
+ paramName = requestParam.value();
+ required = requestParam.required();
+ defaultValue = parseDefaultValueAttribute(requestParam.defaultValue());
+ annotationsFound++;
+ }
+ else if (RequestHeader.class.isInstance(paramAnn)) {
+ RequestHeader requestHeader = (RequestHeader) paramAnn;
+ headerName = requestHeader.value();
+ required = requestHeader.required();
+ defaultValue = parseDefaultValueAttribute(requestHeader.defaultValue());
+ annotationsFound++;
+ }
+ else if (RequestBody.class.isInstance(paramAnn)) {
+ requestBodyFound = true;
+ annotationsFound++;
+ }
+ else if (CookieValue.class.isInstance(paramAnn)) {
+ CookieValue cookieValue = (CookieValue) paramAnn;
+ cookieName = cookieValue.value();
+ required = cookieValue.required();
+ defaultValue = parseDefaultValueAttribute(cookieValue.defaultValue());
+ annotationsFound++;
+ }
+ else if (PathVariable.class.isInstance(paramAnn)) {
+ PathVariable pathVar = (PathVariable) paramAnn;
+ pathVarName = pathVar.value();
+ annotationsFound++;
+ }
+ else if (ModelAttribute.class.isInstance(paramAnn)) {
+ ModelAttribute attr = (ModelAttribute) paramAnn;
+ attrName = attr.value();
+ annotationsFound++;
+ }
+ else if (Value.class.isInstance(paramAnn)) {
+ defaultValue = ((Value) paramAnn).value();
+ }
+ else if ("Valid".equals(paramAnn.annotationType().getSimpleName())) {
+ validate = true;
+ }
+ }
+
+ if (annotationsFound > 1) {
+ throw new IllegalStateException("Handler parameter annotations are exclusive choices - " +
+ "do not specify more than one such annotation on the same parameter: " + handlerMethod);
+ }
+
+ if (annotationsFound == 0) {
+ Object argValue = resolveCommonArgument(methodParam, webRequest);
+ if (argValue != WebArgumentResolver.UNRESOLVED) {
+ args[i] = argValue;
+ }
+ else if (defaultValue != null) {
+ args[i] = resolveDefaultValue(defaultValue);
+ }
+ else {
+ Class paramType = methodParam.getParameterType();
+ if (Model.class.isAssignableFrom(paramType) || Map.class.isAssignableFrom(paramType)) {
+ args[i] = implicitModel;
+ }
+ else if (SessionStatus.class.isAssignableFrom(paramType)) {
+ args[i] = this.sessionStatus;
+ }
+ else if (HttpEntity.class.isAssignableFrom(paramType)) {
+ args[i] = resolveHttpEntityRequest(methodParam, webRequest);
+ }
+ else if (Errors.class.isAssignableFrom(paramType)) {
+ throw new IllegalStateException("Errors/BindingResult argument declared " +
+ "without preceding model attribute. Check your handler method signature!");
+ }
+ else if (BeanUtils.isSimpleProperty(paramType)) {
+ paramName = "";
+ }
+ else {
+ attrName = "";
+ }
+ }
+ }
+
+ if (paramName != null) {
+ args[i] = resolveRequestParam(paramName, required, defaultValue, methodParam, webRequest, handler);
+ }
+ else if (headerName != null) {
+ args[i] = resolveRequestHeader(headerName, required, defaultValue, methodParam, webRequest, handler);
+ }
+ else if (requestBodyFound) {
+ args[i] = resolveRequestBody(methodParam, webRequest, handler);
+ }
+ else if (cookieName != null) {
+ args[i] = resolveCookieValue(cookieName, required, defaultValue, methodParam, webRequest, handler);
+ }
+ else if (pathVarName != null) {
+ args[i] = resolvePathVariable(pathVarName, methodParam, webRequest, handler);
+ }
+ else if (attrName != null) {
+ WebDataBinder binder =
+ resolveModelAttribute(attrName, methodParam, implicitModel, webRequest, handler);
+ boolean assignBindingResult = (args.length > i + 1 && Errors.class.isAssignableFrom(paramTypes[i + 1]));
+ if (binder.getTarget() != null) {
+ doBind(binder, webRequest, validate, !assignBindingResult);
+ }
+ args[i] = binder.getTarget();
+ if (assignBindingResult) {
+ args[i + 1] = binder.getBindingResult();
+ i++;
+ }
+ implicitModel.putAll(binder.getBindingResult().getModel());
+ }
+ }
+
+ return args;
+ }
+
+ protected void initBinder(Object handler, String attrName, WebDataBinder binder, NativeWebRequest webRequest)
+ throws Exception {
+
+ if (this.bindingInitializer != null) {
+ this.bindingInitializer.initBinder(binder, webRequest);
+ }
+ if (handler != null) {
+ Set initBinderMethods = this.methodResolver.getInitBinderMethods();
+ if (!initBinderMethods.isEmpty()) {
+ boolean debug = logger.isDebugEnabled();
+ for (Method initBinderMethod : initBinderMethods) {
+ Method methodToInvoke = BridgeMethodResolver.findBridgedMethod(initBinderMethod);
+ String[] targetNames = AnnotationUtils.findAnnotation(initBinderMethod, InitBinder.class).value();
+ if (targetNames.length == 0 || Arrays.asList(targetNames).contains(attrName)) {
+ Object[] initBinderArgs =
+ resolveInitBinderArguments(handler, methodToInvoke, binder, webRequest);
+ if (debug) {
+ logger.debug("Invoking init-binder method: " + methodToInvoke);
+ }
+ ReflectionUtils.makeAccessible(methodToInvoke);
+ Object returnValue = methodToInvoke.invoke(handler, initBinderArgs);
+ if (returnValue != null) {
+ throw new IllegalStateException(
+ "InitBinder methods must not have a return value: " + methodToInvoke);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private Object[] resolveInitBinderArguments(Object handler, Method initBinderMethod,
+ WebDataBinder binder, NativeWebRequest webRequest) throws Exception {
+
+ Class[] initBinderParams = initBinderMethod.getParameterTypes();
+ Object[] initBinderArgs = new Object[initBinderParams.length];
+
+ for (int i = 0; i < initBinderArgs.length; i++) {
+ MethodParameter methodParam = new MethodParameter(initBinderMethod, i);
+ methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer);
+ GenericTypeResolver.resolveParameterType(methodParam, handler.getClass());
+ String paramName = null;
+ boolean paramRequired = false;
+ String paramDefaultValue = null;
+ String pathVarName = null;
+ Annotation[] paramAnns = methodParam.getParameterAnnotations();
+
+ for (Annotation paramAnn : paramAnns) {
+ if (RequestParam.class.isInstance(paramAnn)) {
+ RequestParam requestParam = (RequestParam) paramAnn;
+ paramName = requestParam.value();
+ paramRequired = requestParam.required();
+ paramDefaultValue = parseDefaultValueAttribute(requestParam.defaultValue());
+ break;
+ }
+ else if (ModelAttribute.class.isInstance(paramAnn)) {
+ throw new IllegalStateException(
+ "@ModelAttribute is not supported on @InitBinder methods: " + initBinderMethod);
+ }
+ else if (PathVariable.class.isInstance(paramAnn)) {
+ PathVariable pathVar = (PathVariable) paramAnn;
+ pathVarName = pathVar.value();
+ }
+ }
+
+ if (paramName == null && pathVarName == null) {
+ Object argValue = resolveCommonArgument(methodParam, webRequest);
+ if (argValue != WebArgumentResolver.UNRESOLVED) {
+ initBinderArgs[i] = argValue;
+ }
+ else {
+ Class paramType = initBinderParams[i];
+ if (paramType.isInstance(binder)) {
+ initBinderArgs[i] = binder;
+ }
+ else if (BeanUtils.isSimpleProperty(paramType)) {
+ paramName = "";
+ }
+ else {
+ throw new IllegalStateException("Unsupported argument [" + paramType.getName() +
+ "] for @InitBinder method: " + initBinderMethod);
+ }
+ }
+ }
+
+ if (paramName != null) {
+ initBinderArgs[i] =
+ resolveRequestParam(paramName, paramRequired, paramDefaultValue, methodParam, webRequest, null);
+ }
+ else if (pathVarName != null) {
+ initBinderArgs[i] = resolvePathVariable(pathVarName, methodParam, webRequest, null);
+ }
+ }
+
+ return initBinderArgs;
+ }
+
+ @SuppressWarnings("unchecked")
+ private Object resolveRequestParam(String paramName, boolean required, String defaultValue,
+ MethodParameter methodParam, NativeWebRequest webRequest, Object handlerForInitBinderCall)
+ throws Exception {
+
+ Class paramType = methodParam.getParameterType();
+ if (Map.class.isAssignableFrom(paramType) && paramName.length() == 0) {
+ return resolveRequestParamMap((Class) paramType, webRequest);
+ }
+ if (paramName.length() == 0) {
+ paramName = getRequiredParameterName(methodParam);
+ }
+ Object paramValue = null;
+ MultipartRequest multipartRequest = webRequest.getNativeRequest(MultipartRequest.class);
+ if (multipartRequest != null) {
+ List files = multipartRequest.getFiles(paramName);
+ if (!files.isEmpty()) {
+ if (files.size() == 1 && !paramType.isArray() && !Collection.class.isAssignableFrom(paramType)) {
+ paramValue = files.get(0);
+ }
+ else {
+ paramValue = files;
+ }
+ }
+ }
+ if (paramValue == null) {
+ String[] paramValues = webRequest.getParameterValues(paramName);
+ if (paramValues != null) {
+ if (paramValues.length == 1 && !paramType.isArray() && !Collection.class.isAssignableFrom(paramType)) {
+ paramValue = paramValues[0];
+ }
+ else {
+ paramValue = paramValues;
+ }
+ }
+ }
+ if (paramValue == null) {
+ if (defaultValue != null) {
+ paramValue = resolveDefaultValue(defaultValue);
+ }
+ else if (required) {
+ raiseMissingParameterException(paramName, paramType);
+ }
+ paramValue = checkValue(paramName, paramValue, paramType);
+ }
+ WebDataBinder binder = createBinder(webRequest, null, paramName);
+ initBinder(handlerForInitBinderCall, paramName, binder, webRequest);
+ return binder.convertIfNecessary(paramValue, paramType, methodParam);
+ }
+
+ private Map resolveRequestParamMap(Class mapType, NativeWebRequest webRequest) {
+ Map parameterMap = webRequest.getParameterMap();
+ if (MultiValueMap.class.isAssignableFrom(mapType)) {
+ MultiValueMap result = new LinkedMultiValueMap(parameterMap.size());
+ for (Map.Entry entry : parameterMap.entrySet()) {
+ for (String value : entry.getValue()) {
+ result.add(entry.getKey(), value);
+ }
+ }
+ return result;
+ }
+ else {
+ Map result = new LinkedHashMap(parameterMap.size());
+ for (Map.Entry entry : parameterMap.entrySet()) {
+ if (entry.getValue().length > 0) {
+ result.put(entry.getKey(), entry.getValue()[0]);
+ }
+ }
+ return result;
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private Object resolveRequestHeader(String headerName, boolean required, String defaultValue,
+ MethodParameter methodParam, NativeWebRequest webRequest, Object handlerForInitBinderCall)
+ throws Exception {
+
+ Class paramType = methodParam.getParameterType();
+ if (Map.class.isAssignableFrom(paramType)) {
+ return resolveRequestHeaderMap((Class) paramType, webRequest);
+ }
+ if (headerName.length() == 0) {
+ headerName = getRequiredParameterName(methodParam);
+ }
+ Object headerValue = null;
+ String[] headerValues = webRequest.getHeaderValues(headerName);
+ if (headerValues != null) {
+ headerValue = (headerValues.length == 1 ? headerValues[0] : headerValues);
+ }
+ if (headerValue == null) {
+ if (defaultValue != null) {
+ headerValue = resolveDefaultValue(defaultValue);
+ }
+ else if (required) {
+ raiseMissingHeaderException(headerName, paramType);
+ }
+ headerValue = checkValue(headerName, headerValue, paramType);
+ }
+ WebDataBinder binder = createBinder(webRequest, null, headerName);
+ initBinder(handlerForInitBinderCall, headerName, binder, webRequest);
+ return binder.convertIfNecessary(headerValue, paramType, methodParam);
+ }
+
+ private Map resolveRequestHeaderMap(Class mapType, NativeWebRequest webRequest) {
+ if (MultiValueMap.class.isAssignableFrom(mapType)) {
+ MultiValueMap result;
+ if (HttpHeaders.class.isAssignableFrom(mapType)) {
+ result = new HttpHeaders();
+ }
+ else {
+ result = new LinkedMultiValueMap();
+ }
+ for (Iterator iterator = webRequest.getHeaderNames(); iterator.hasNext();) {
+ String headerName = iterator.next();
+ for (String headerValue : webRequest.getHeaderValues(headerName)) {
+ result.add(headerName, headerValue);
+ }
+ }
+ return result;
+ }
+ else {
+ Map result = new LinkedHashMap();
+ for (Iterator iterator = webRequest.getHeaderNames(); iterator.hasNext();) {
+ String headerName = iterator.next();
+ String headerValue = webRequest.getHeader(headerName);
+ result.put(headerName, headerValue);
+ }
+ return result;
+ }
+ }
+
+ /**
+ * Resolves the given {@link RequestBody @RequestBody} annotation.
+ */
+ protected Object resolveRequestBody(MethodParameter methodParam, NativeWebRequest webRequest, Object handler)
+ throws Exception {
+
+ return readWithMessageConverters(methodParam, createHttpInputMessage(webRequest), methodParam.getParameterType());
+ }
+
+ private HttpEntity resolveHttpEntityRequest(MethodParameter methodParam, NativeWebRequest webRequest)
+ throws Exception {
+
+ HttpInputMessage inputMessage = createHttpInputMessage(webRequest);
+ Class paramType = getHttpEntityType(methodParam);
+ Object body = readWithMessageConverters(methodParam, inputMessage, paramType);
+ return new HttpEntity