Example usage for org.springframework.web.bind.support WebArgumentResolver UNRESOLVED

List of usage examples for org.springframework.web.bind.support WebArgumentResolver UNRESOLVED

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.web.bind.support.*
  5. WebArgumentResolver
  6. UNRESOLVED

Introduction

In this page you can find the example usage for org.springframework.web.bind.support WebArgumentResolver UNRESOLVED.

Prototype

Object UNRESOLVED

To view the source code for org.springframework.web.bind.support WebArgumentResolver UNRESOLVED.

Click Source Link

Document

Marker to be returned when the resolver does not know how to handle the given method parameter.

Usage

From source file:com.xiongyingqi.spring.mvc.method.annotation.RequestJsonParamMethodArgumentResolver.java

/**
 * spring 3.1?/*from w w  w .  j av  a2s  . co m*/
 */
public Object resolveArgument(MethodParameter parameter, NativeWebRequest request) throws Exception {
    String[] values = request.getParameterValues(parameter.getParameterName());
    for (String paramValue : values) {
        EntityHelper.print(paramValue);
    }
    if (!supportsParameter(parameter)) {
        return WebArgumentResolver.UNRESOLVED;
    }
    return resolveArgument(parameter, null, request, null);
}

From source file:ch.ralscha.extdirectspring.util.ParametersResolver.java

@SuppressWarnings("unchecked")
public Object[] resolveParameters(HttpServletRequest request, HttpServletResponse response, Locale locale,
        ExtDirectRequest directRequest, MethodInfo methodInfo) throws Exception {

    int jsonParamIndex = 0;
    Map<String, Object> remainingParameters = null;
    ExtDirectStoreReadRequest extDirectStoreReadRequest = null;

    List<Object> directStoreModifyRecords = null;
    Class<?> directStoreEntryClass;

    if (methodInfo.isType(ExtDirectMethodType.STORE_READ) || methodInfo.isType(ExtDirectMethodType.FORM_LOAD)
            || methodInfo.isType(ExtDirectMethodType.TREE_LOAD)) {

        List<Object> data = (List<Object>) directRequest.getData();

        if (data != null && data.size() > 0) {
            if (methodInfo.isType(ExtDirectMethodType.STORE_READ)) {
                extDirectStoreReadRequest = new ExtDirectStoreReadRequest();
                remainingParameters = fillReadRequestFromMap(extDirectStoreReadRequest,
                        (Map<String, Object>) data.get(0));
            } else {
                remainingParameters = (Map<String, Object>) data.get(0);
            }//from   ww w .  j  a  va2s.  c o m
            jsonParamIndex = 1;
        }
    } else if (methodInfo.isType(ExtDirectMethodType.STORE_MODIFY)) {
        directStoreEntryClass = methodInfo.getCollectionType();
        List<Object> data = (List<Object>) directRequest.getData();

        if (directStoreEntryClass != null && data != null && data.size() > 0) {
            Object obj = data.get(0);
            if (obj instanceof List) {
                directStoreModifyRecords = convertObjectEntriesToType((List<Object>) obj,
                        directStoreEntryClass);
            } else {
                Map<String, Object> jsonData = (Map<String, Object>) obj;
                Object records = jsonData.get("records");
                if (records != null) {
                    if (records instanceof List) {
                        directStoreModifyRecords = convertObjectEntriesToType((List<Object>) records,
                                directStoreEntryClass);
                    } else {
                        directStoreModifyRecords = new ArrayList<Object>();
                        directStoreModifyRecords
                                .add(this.jsonHandler.convertValue(records, directStoreEntryClass));
                    }
                    remainingParameters = new HashMap<String, Object>(jsonData);
                    remainingParameters.remove("records");
                } else {
                    directStoreModifyRecords = new ArrayList<Object>();
                    directStoreModifyRecords
                            .add(this.jsonHandler.convertValue(jsonData, directStoreEntryClass));
                }
            }
            jsonParamIndex = 1;

        } else if (data != null && data.size() > 0) {
            Object obj = data.get(0);
            if (obj instanceof Map) {
                remainingParameters = new HashMap<String, Object>((Map<String, Object>) obj);
                remainingParameters.remove("records");
            }
        }
    } else if (methodInfo.isType(ExtDirectMethodType.SIMPLE_NAMED)) {
        Map<String, Object> data = (Map<String, Object>) directRequest.getData();
        if (data != null && data.size() > 0) {
            remainingParameters = new HashMap<String, Object>(data);
        }
    } else if (methodInfo.isType(ExtDirectMethodType.POLL)) {
        throw new IllegalStateException("this controller does not handle poll calls");
    } else if (methodInfo.isType(ExtDirectMethodType.FORM_POST)) {
        throw new IllegalStateException("this controller does not handle form posts");
    } else if (methodInfo.isType(ExtDirectMethodType.FORM_POST_JSON)) {
        List<Object> data = (List<Object>) directRequest.getData();

        if (data != null && data.size() > 0) {
            Object obj = data.get(0);
            if (obj instanceof Map) {
                remainingParameters = new HashMap<String, Object>((Map<String, Object>) obj);
                remainingParameters.remove("records");
            }
        }

    }

    List<ParameterInfo> methodParameters = methodInfo.getParameters();
    Object[] parameters = null;

    if (!methodParameters.isEmpty()) {
        parameters = new Object[methodParameters.size()];

        for (int paramIndex = 0; paramIndex < methodParameters.size(); paramIndex++) {
            ParameterInfo methodParameter = methodParameters.get(paramIndex);

            if (methodParameter.isSupportedParameter()) {
                parameters[paramIndex] = SupportedParameters.resolveParameter(methodParameter.getType(),
                        request, response, locale, directRequest);
            } else if (ExtDirectStoreReadRequest.class.isAssignableFrom(methodParameter.getType())) {
                parameters[paramIndex] = extDirectStoreReadRequest;
            } else if (directStoreModifyRecords != null && methodParameter.getCollectionType() != null) {
                parameters[paramIndex] = directStoreModifyRecords;
            } else if (methodParameter.hasRequestParamAnnotation()) {
                parameters[paramIndex] = resolveRequestParam(null, remainingParameters, methodParameter);
            } else if (methodParameter.hasMetadataParamAnnotation()) {
                parameters[paramIndex] = resolveRequestParam(null, directRequest.getMetadata(),
                        methodParameter);
            } else if (methodParameter.hasRequestHeaderAnnotation()) {
                parameters[paramIndex] = resolveRequestHeader(request, methodParameter);
            } else if (methodParameter.hasCookieValueAnnotation()) {
                parameters[paramIndex] = resolveCookieValue(request, methodParameter);
            } else if (methodParameter.hasAuthenticationPrincipalAnnotation()) {
                parameters[paramIndex] = resolveAuthenticationPrincipal(methodParameter);
            } else if (remainingParameters != null
                    && remainingParameters.containsKey(methodParameter.getName())) {
                Object jsonValue = remainingParameters.get(methodParameter.getName());
                parameters[paramIndex] = convertValue(jsonValue, methodParameter);
            } else if (directRequest.getData() != null && directRequest.getData() instanceof List
                    && ((List<Object>) directRequest.getData()).size() > jsonParamIndex) {
                Object jsonValue = ((List<Object>) directRequest.getData()).get(jsonParamIndex);
                parameters[paramIndex] = convertValue(jsonValue, methodParameter);
                jsonParamIndex++;
            } else {

                if (methodInfo.isType(ExtDirectMethodType.SIMPLE_NAMED)) {
                    if (Map.class.isAssignableFrom(methodParameter.getType())) {
                        parameters[paramIndex] = remainingParameters;
                        continue;
                    } else if (methodParameter.isJavaUtilOptional()) {
                        parameters[paramIndex] = javaUtilOptionalEmpty;
                        continue;
                    }
                }

                log.info("WebResolvers size:" + this.webArgumentResolvers.size());
                log.info("ParamIndex:" + paramIndex);

                log.info("Request params size:" + request.getParameterMap().isEmpty());
                log.info("Request params names:" + request.getParameterMap().keySet());
                log.info("Direct Request:" + directRequest.toString());

                MethodParameter p = new MethodParameter(methodInfo.getMethod(), paramIndex);
                request.setAttribute("directRequest", directRequest);
                request.setAttribute("extDirectStoreReadRequest", extDirectStoreReadRequest);
                ServletWebRequest r = new ServletWebRequest(request);
                Object result = WebArgumentResolver.UNRESOLVED;

                for (WebArgumentResolver resolver : this.webArgumentResolvers) {
                    log.info("Resolving with:" + resolver.getClass().getCanonicalName());

                    result = resolver.resolveArgument(p, r);
                    if (result != WebArgumentResolver.UNRESOLVED) {
                        log.info("Resolved by:" + resolver.getClass().getCanonicalName());
                        parameters[paramIndex] = result;
                        break;
                    }
                }
                if (result == WebArgumentResolver.UNRESOLVED) {
                    throw new IllegalArgumentException(
                            "Error, parameter mismatch. Please check your remoting method signature to ensure all supported parameters types are used.");
                }
            }
        }
    }

    return parameters;
}

From source file:org.springframework.data.document.web.bind.annotation.support.HandlerMethodInvoker.java

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;/* w w  w .j a va 2s.  co m*/
        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;
}

From source file:org.springframework.data.document.web.bind.annotation.support.HandlerMethodInvoker.java

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;/*from   ww w.ja v a 2s. c  o m*/
        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;
}

From source file:org.springframework.data.document.web.bind.annotation.support.HandlerMethodInvoker.java

protected Object resolveCommonArgument(MethodParameter methodParameter, NativeWebRequest webRequest)
        throws Exception {

    // Invoke custom argument resolvers if present...
    if (this.customArgumentResolvers != null) {
        for (WebArgumentResolver argumentResolver : this.customArgumentResolvers) {
            Object value = argumentResolver.resolveArgument(methodParameter, webRequest);
            if (value != WebArgumentResolver.UNRESOLVED) {
                return value;
            }/* w ww  .  ja  v a  2  s  .c  o  m*/
        }
    }

    // Resolution of standard parameter types...
    Class paramType = methodParameter.getParameterType();
    Object value = resolveStandardArgument(paramType, webRequest);
    if (value != WebArgumentResolver.UNRESOLVED && !ClassUtils.isAssignableValue(paramType, value)) {
        throw new IllegalStateException("Standard argument type [" + paramType.getName()
                + "] resolved to incompatible value of type [" + (value != null ? value.getClass() : null)
                + "]. Consider declaring the argument type in a less specific fashion.");
    }
    return value;
}

From source file:org.springframework.data.document.web.bind.annotation.support.HandlerMethodInvoker.java

protected Object resolveStandardArgument(Class<?> parameterType, NativeWebRequest webRequest) throws Exception {
    if (WebRequest.class.isAssignableFrom(parameterType)) {
        return webRequest;
    }/*from  ww  w .  j a  va  2 s . co m*/
    return WebArgumentResolver.UNRESOLVED;
}

From source file:org.springframework.data.document.web.servlet.mvc.annotation.support.InterceptingHandlerMethodInvoker.java

protected 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;/*from w  ww  .  j  a  va  2s .c o m*/
        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;
}

From source file:org.springframework.faces.mvc.annotation.support.AnnotatedMethodInvoker.java

/**
 * Resolve the arguments on a {@link InitBinder} annotated method.
 * @param handler The handler//from   ww  w.j av a 2  s  .c  o m
 * @param initBinderMethod The {@link InitBinder} annotated method
 * @param binder The data binder
 * @param webRequest The web request
 * @return Resolved arguments
 * @throws Exception on error
 */
private Object[] resolveInitBinderArguments(Object handler, Method initBinderMethod, final WebDataBinder binder,
        NativeWebRequest webRequest) throws Exception {
    WebArgumentResolver initBinderArgumentResolver = new WebArgumentResolver() {
        public Object resolveArgument(MethodParameter methodParameter, NativeWebRequest webRequest)
                throws Exception {
            if (methodParameter.getParameterType().isInstance(binder)) {
                return binder;
            }
            return WebArgumentResolver.UNRESOLVED;
        }
    };
    WebArgumentResolver[] argumentResolvers = { initBinderArgumentResolver };
    return resolveArguments(handler, initBinderMethod, webRequest, argumentResolvers,
            INIT_BINDER_NO_MODEL_ARGUMENT_RESOLVER, null);
}

From source file:org.springframework.faces.mvc.annotation.support.AnnotatedMethodInvoker.java

/**
 * Resolve the arguments for a specific handler method.
 * @param handler The handler//from  w ww  .  jav  a2 s  . c o  m
 * @param handlerMethod The method
 * @param webRequest The web request
 * @param argumentResolvers Additional {@link WebArgumentResolver}s that are used to resolver argument (can be
 * <tt>null</tt>)
 * @param modelArgumentResolver The model argument resolver
 * @param handlerForInitBinderCall The handler for use with init binder (can be <tt>null</tt>)
 * @return Resolved arguments
 * @throws Exception on error
 */
private Object[] resolveArguments(Object handler, Method handlerMethod, NativeWebRequest webRequest,
        WebArgumentResolver[] argumentResolvers, ModelArgumentResolver modelArgumentResolver,
        Object handlerForInitBinderCall) throws Exception {

    Class[] paramTypes = handlerMethod.getParameterTypes();
    Object[] args = new Object[paramTypes.length];

    for (int i = 0; i < args.length; i++) {
        MethodParameter methodParameter = new MethodParameter(handlerMethod, i);
        methodParameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
        GenericTypeResolver.resolveParameterType(methodParameter, handler.getClass());
        String requestParamName = null;
        boolean requestParamRequired = false;
        String modelAttributeName = null;
        Object[] methodParamAnnotations = methodParameter.getParameterAnnotations();

        for (int j = 0; j < methodParamAnnotations.length; j++) {
            Object methodParamAnnotation = methodParamAnnotations[j];
            if (RequestParam.class.isInstance(methodParamAnnotation)) {
                RequestParam requestParam = (RequestParam) methodParamAnnotation;
                requestParamName = requestParam.value();
                requestParamRequired = requestParam.required();
                break;
            } else if (ModelAttribute.class.isInstance(methodParamAnnotation)) {
                ModelAttribute modelAttribute = (ModelAttribute) methodParamAnnotation;
                modelAttributeName = modelAttribute.value();
            }
        }
        if (requestParamName != null && modelAttributeName != null) {
            throw new IllegalStateException("@RequestParam and @ModelAttribute are an exclusive choice -"
                    + "do not specify both on the same parameter: " + handlerMethod);
        }

        if (requestParamName == null && modelAttributeName == null) {
            Object argValue = resolveCommonArgument(methodParameter, webRequest);
            if (argValue != WebArgumentResolver.UNRESOLVED) {
                args[i] = argValue;
            } else {
                Class paramType = paramTypes[i];
                if (Errors.class.isAssignableFrom(paramType)) {
                    throw new IllegalStateException("Errors/BindingResult argument declared "
                            + "without preceding model attribute. Check your handler method signature!");
                }
                args[i] = invokeArgumentResolvers(methodParameter, webRequest, argumentResolvers);
                if (args[i] == WebArgumentResolver.UNRESOLVED) {
                    if (BeanUtils.isSimpleProperty(paramType)) {
                        // Set the request param to a non null value to trigger a resolve
                        requestParamName = "";
                    } else {
                        // Set the model attribute name to a non null value to trigger a model resolve
                        modelAttributeName = "";
                    }
                }
            }
        }

        if (requestParamName != null) {
            args[i] = resolveRequestParam(requestParamName, requestParamRequired, methodParameter, webRequest,
                    handlerForInitBinderCall);
        } else if (modelAttributeName != null) {
            boolean assignBindingResult = (args.length > i + 1
                    && Errors.class.isAssignableFrom(paramTypes[i + 1]));
            ResolvedModelArgument resolved = null;
            if (modelArgumentResolver != null) {
                resolved = modelArgumentResolver.resolve(
                        (modelAttributeName.length() == 0 ? null : modelAttributeName), methodParameter,
                        webRequest, !assignBindingResult);
            }
            if (resolved != null) {
                args[i] = resolved.getResult();
                if (assignBindingResult) {
                    args[i + 1] = resolved.getErrors();
                    i++;
                }
            }
        }
    }

    return args;
}