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

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

Introduction

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

Prototype

@Nullable
Object resolveArgument(MethodParameter methodParameter, NativeWebRequest webRequest) throws Exception;

Source Link

Document

Resolve an argument for the given handler method parameter within the given web request.

Usage

From source file:org.impalaframework.extension.mvc.annotation.collector.ArgumentCollectorHelper.java

public ArgumentCollector getArgumentCollector(Method handlerMethod, NativeWebRequest webRequest, int index) {

    //FIXME test/*from  w  ww  .jav a2s. com*/

    ArgumentCollector collector = null;
    MethodParameter parameter = new MethodParameter(handlerMethod, index);
    Annotation[] annotations = WebAnnotationUtils.getAnnotations(parameter, "getParameterAnnotations");
    //parameter.getParameterAnnotations();

    Class<?> parameterType = parameter.getParameterType();

    Annotation annotation = null;

    if (annotations.length > 2) {
        throw new IllegalStateException("Parameter with index " + index + " from method " + handlerMethod
                + " has more than one annotation");
    }

    if (annotations.length == 1) {
        annotation = annotations[0];
    }

    if (annotation != null) {

        //FIXME test

        if (RequestParam.class.isInstance(annotation)) {
            collector = new RequestParameterArgumentCollector((RequestParam) annotation, parameterType);
        } else if (ModelAttribute.class.isInstance(annotation)) {
            collector = new ModelAttributeArgumentCollector((ModelAttribute) annotation);
        } else {

            if (webArgumentResolvers != null) {
                for (WebArgumentResolver webArgumentResolver : webArgumentResolvers) {

                    try {
                        Object resolveArgument = webArgumentResolver.resolveArgument(parameter, webRequest);
                        if (!WebArgumentResolver.UNRESOLVED.equals(resolveArgument)) {
                            collector = new CustomResolverArgumentCollector(webArgumentResolver, parameter);
                        }
                    } catch (RuntimeException e) {
                        throw e;
                    } catch (Exception e) {
                        throw new ExecutionException(e.getMessage());
                    }
                }
            }
        }
    }

    if (collector == null) {

        //FIXME only handling from point of view of map
        if (Map.class.isAssignableFrom(parameterType)) {
            collector = new ModelArgumentCollector();
        } else if (HttpServletRequest.class.isAssignableFrom(parameterType)) {
            collector = new HttpServletRequestArgumentCollector();
        } else if (HttpServletResponse.class.isAssignableFrom(parameterType)) {
            collector = new HttpServletResponseArgumentCollector();
        } else if (HttpSession.class.isAssignableFrom(parameterType)) {
            collector = new HttpSessionArgumentCollector();
        }
    }

    if (collector == null) {
        throw new IllegalStateException("Unable to determine parameter type for arameter with index " + index
                + " from method " + handlerMethod);
    }
    return collector;
}

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  w  w  w .j a va 2s  .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

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. j a v a2  s .c om
        }
    }

    // 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.faces.mvc.annotation.support.AnnotatedMethodInvoker.java

/**
 * Invoke the specified {@link WebArgumentResolver}s.
 * @param methodParameter The method parameter
 * @param webRequest The web request//  www . j  a  va 2  s  .  c o  m
 * @param resolvers The resolvers (can be <tt>null</tt>)
 * @return The resolved argument (can be <tt>null</tt>) or {@link WebArgumentResolver#UNRESOLVED} if the argument
 * @throws Exception on error
 */
private Object invokeArgumentResolvers(MethodParameter methodParameter, NativeWebRequest webRequest,
        WebArgumentResolver[] resolvers) throws Exception {
    if (resolvers != null) {
        for (WebArgumentResolver resolver : resolvers) {
            Object value = resolver.resolveArgument(methodParameter, webRequest);
            if (value != WebArgumentResolver.UNRESOLVED) {
                return value;
            }
        }
    }
    return WebArgumentResolver.UNRESOLVED;
}

From source file:org.springframework.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;
            }/*ww  w.j a  v a2 s.  co  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;
}