Example usage for org.springframework.core MethodParameter getParameterAnnotations

List of usage examples for org.springframework.core MethodParameter getParameterAnnotations

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.core.*
  5. MethodParameter
  6. getParameterAnnotations

Introduction

In this page you can find the example usage for org.springframework.core MethodParameter getParameterAnnotations.

Prototype

public Annotation[] getParameterAnnotations()

Source Link

Document

Return the annotations associated with the specific method/constructor parameter.

Usage

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

public ParameterInfo(Class<?> clazz, Method method, int paramIndex) {

    MethodParameter methodParam = new MethodParameter(method, paramIndex);
    methodParam.initParameterNameDiscovery(discoverer);
    GenericTypeResolver.resolveParameterType(methodParam, clazz);

    this.name = methodParam.getParameterName();
    this.typeDescriptor = new TypeDescriptor(methodParam);

    Class<?> paramType = methodParam.getParameterType();
    javaUtilOptional = paramType.getName().equals("java.util.Optional");

    this.supportedParameter = SupportedParameters.isSupported(typeDescriptor.getObjectType());

    Annotation[] paramAnnotations = methodParam.getParameterAnnotations();

    for (Annotation paramAnn : paramAnnotations) {

        this.hasRequestParamAnnotation = false;
        this.hasMetadataParamAnnotation = false;
        this.hasRequestHeaderAnnotation = false;
        this.hasCookieValueAnnotation = false;
        this.hasAuthenticationPrincipalAnnotation = null;

        if (RequestParam.class.isInstance(paramAnn)) {
            RequestParam requestParam = (RequestParam) paramAnn;
            if (StringUtils.hasText(requestParam.value())) {
                this.name = requestParam.value();
            }//from  ww  w.  j  a  va 2s  .  c  o m
            this.required = requestParam.required();
            this.defaultValue = ValueConstants.DEFAULT_NONE.equals(requestParam.defaultValue()) ? null
                    : requestParam.defaultValue();
            this.hasRequestParamAnnotation = true;
            break;
        } else if (MetadataParam.class.isInstance(paramAnn)) {
            MetadataParam metadataParam = (MetadataParam) paramAnn;
            if (StringUtils.hasText(metadataParam.value())) {
                this.name = metadataParam.value();
            }
            this.required = metadataParam.required();
            this.defaultValue = ValueConstants.DEFAULT_NONE.equals(metadataParam.defaultValue()) ? null
                    : metadataParam.defaultValue();
            this.hasMetadataParamAnnotation = true;
            break;
        } else if (RequestHeader.class.isInstance(paramAnn)) {
            RequestHeader requestHeader = (RequestHeader) paramAnn;
            if (StringUtils.hasText(requestHeader.value())) {
                this.name = requestHeader.value();
            }
            this.required = requestHeader.required();
            this.defaultValue = ValueConstants.DEFAULT_NONE.equals(requestHeader.defaultValue()) ? null
                    : requestHeader.defaultValue();
            this.hasRequestHeaderAnnotation = true;
            break;
        } else if (CookieValue.class.isInstance(paramAnn)) {
            CookieValue cookieValue = (CookieValue) paramAnn;
            if (StringUtils.hasText(cookieValue.value())) {
                this.name = cookieValue.value();
            }
            this.required = cookieValue.required();
            this.defaultValue = ValueConstants.DEFAULT_NONE.equals(cookieValue.defaultValue()) ? null
                    : cookieValue.defaultValue();
            this.hasCookieValueAnnotation = true;
            break;
        } else if (paramAnn.annotationType().getName()
                .equals("org.springframework.security.web.bind.annotation.AuthenticationPrincipal")
                || paramAnn.annotationType().getName()
                        .equals("org.springframework.security.core.annotation.AuthenticationPrincipal")) {
            hasAuthenticationPrincipalAnnotation = (Boolean) AnnotationUtils.getValue(paramAnn,
                    "errorOnInvalidType");
        }
    }
}

From source file:com.ms.commons.summer.web.handler.DataBinderUtil.java

/**
 * ?//  w ww  .  j  a v  a 2  s  .com
 * 
 * @param method
 * @param model
 * @param request
 * @param response
 * @param c
 * @return
 */
@SuppressWarnings("unchecked")
public static Object[] getArgs(Method method, Map<String, Object> model, HttpServletRequest request,
        HttpServletResponse response, Class<?> c) {
    Class<?>[] paramTypes = method.getParameterTypes();
    Object[] args = new Object[paramTypes.length];
    Map<String, Object> argMap = new HashMap<String, Object>(args.length);
    Map<String, String> pathValues = null;
    PathPattern pathPattern = method.getAnnotation(PathPattern.class);
    if (pathPattern != null) {
        String path = request.getRequestURI();
        int index = path.lastIndexOf('.');
        if (index != -1) {
            path = path.substring(0, index);
            String[] patterns = pathPattern.patterns();
            pathValues = getPathValues(patterns, path);
        }
    }
    MapBindingResult errors = new MapBindingResult(argMap, "");
    ParameterNameDiscoverer parameterNameDiscoverer = new LocalVariableTableParameterNameDiscoverer();
    for (int i = 0; i < paramTypes.length; i++) {
        Class<?> paramType = paramTypes[i];

        MethodParameter methodParam = new MethodParameter(method, i);
        methodParam.initParameterNameDiscovery(parameterNameDiscoverer);
        GenericTypeResolver.resolveParameterType(methodParam, c.getClass());

        String paramName = methodParam.getParameterName();
        // map
        if (Map.class.isAssignableFrom(paramType)) {
            args[i] = model;
        }
        // HttpServletRequest
        else if (HttpServletRequest.class.isAssignableFrom(paramType)) {
            args[i] = request;
        }
        // HttpServletResponse
        else if (HttpServletResponse.class.isAssignableFrom(paramType)) {
            args[i] = response;
        }
        // HttpSession
        else if (HttpSession.class.isAssignableFrom(paramType)) {
            args[i] = request.getSession();
        }
        // Errors
        else if (Errors.class.isAssignableFrom(paramType)) {
            args[i] = errors;
        }
        // MultipartFile
        else if (MultipartFile.class.isAssignableFrom(paramType)) {
            MultipartFile[] files = resolveMultipartFiles(request, errors, paramName);
            if (files != null && files.length > 0) {
                args[i] = files[0];
            }
        }
        // MultipartFile[]
        else if (MultipartFile[].class.isAssignableFrom(paramType)) {
            args[i] = resolveMultipartFiles(request, errors, paramName);
        } else {
            // ??
            if (BeanUtils.isSimpleProperty(paramType)) {
                SimpleTypeConverter converter = new SimpleTypeConverter();
                Object value;
                // ?
                if (paramType.isArray()) {
                    value = request.getParameterValues(paramName);
                } else {
                    Object[] parameterAnnotations = methodParam.getParameterAnnotations();
                    value = null;
                    if (parameterAnnotations != null && parameterAnnotations.length > 0) {
                        if (pathValues != null && pathValues.size() > 0) {
                            for (Object object : parameterAnnotations) {
                                if (PathVariable.class.isInstance(object)) {
                                    PathVariable pv = (PathVariable) object;
                                    if (StringUtils.isEmpty(pv.value())) {
                                        value = pathValues.get(paramName);
                                    } else {
                                        value = pathValues.get(pv.value());
                                    }
                                    break;
                                }
                            }
                        }
                    } else {
                        value = request.getParameter(paramName);
                    }
                }
                try {
                    args[i] = converter.convertIfNecessary(value, paramType, methodParam);
                    model.put(paramName, args[i]);
                } catch (TypeMismatchException e) {
                    errors.addError(new FieldError(paramName, paramName, e.getMessage()));
                }
            } else {
                // ???POJO
                if (paramType.isArray()) {
                    ObjectArrayDataBinder binder = new ObjectArrayDataBinder(paramType.getComponentType(),
                            paramName);
                    args[i] = binder.bind(request);
                    model.put(paramName, args[i]);
                } else {
                    Object bindObject = BeanUtils.instantiateClass(paramType);
                    SummerServletRequestDataBinder binder = new SummerServletRequestDataBinder(bindObject,
                            paramName);
                    binder.bind(request);
                    BindException be = new BindException(binder.getBindingResult());
                    List<FieldError> fieldErrors = be.getFieldErrors();
                    for (FieldError fieldError : fieldErrors) {
                        errors.addError(fieldError);
                    }
                    args[i] = binder.getTarget();
                    model.put(paramName, args[i]);
                }
            }
        }
    }
    return args;
}

From source file:com.qatickets.web.common.SessionParamArgumentResolver.java

@SuppressWarnings("rawtypes")
@Override/* ww  w.  ja v a2  s  . c o  m*/
public boolean supportsParameter(MethodParameter parameter) {

    final Annotation[] paramAnns = parameter.getParameterAnnotations();

    for (final Annotation paramAnn : paramAnns) {

        for (Class c : supported) {
            if (c.isInstance(paramAnn)) {
                return true;
            }
        }
    }

    return false;

}

From source file:com.qatickets.web.common.SessionParamArgumentResolver.java

@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {

    Annotation[] paramAnns = parameter.getParameterAnnotations();

    HttpServletRequest req = (HttpServletRequest) webRequest.getNativeRequest();
    HttpSession session = req.getSession(false);

    Object result = null;//from w ww . j a v a2  s . com

    // parameter
    if (session != null) {
        for (Annotation paramAnn : paramAnns) {

            if (SessionUser.class.isInstance(paramAnn)) {
                result = session.getAttribute(UserHelper.USER);
            } else if (ParamTicket.class.isInstance(paramAnn)) {

                int ticketId = 0;

                if (NumberUtils.isDigits(req.getParameter(Attr.PARAM_TICKET_ID))) {
                    ticketId = Integer.parseInt(req.getParameter(Attr.PARAM_TICKET_ID));
                }

                result = this.ticketService.findById(ticketId);

            } else if (HTML5Date.class.isInstance(paramAnn)) {
                HTML5Date html5Date = (HTML5Date) paramAnn;
                String html5DateParameterName = null;
                if (StringUtils.isNotBlank(html5Date.value())) {
                    html5DateParameterName = html5Date.value();
                } else {
                    html5DateParameterName = parameter.getParameterName();
                }
                String date = req.getParameter(html5DateParameterName);
                if (StringUtils.isNotBlank(date)) {
                    if (date.contains(",")) {
                        // UI date
                        result = DateTime.parse(date, UI_DATE_PARSER).toDate();
                    } else {
                        // native picker date
                        result = DateTime.parse(date, HTML5_DATE_PARSER).toDate();
                    }
                }

            } else if (Checkbox.class.isInstance(paramAnn)) {
                Checkbox checkbox = (Checkbox) paramAnn;
                String checkboxParameterName = null;
                if (StringUtils.isNotBlank(checkbox.value())) {
                    checkboxParameterName = checkbox.value();
                } else {
                    checkboxParameterName = parameter.getParameterName();
                }
                String checkboxValue = req.getParameter(checkboxParameterName);
                if (StringUtils.isNotBlank(checkboxValue)) {
                    result = Boolean.TRUE;
                } else {
                    result = Boolean.FALSE;
                }
            } else if (IntParam.class.isInstance(paramAnn)) {
                IntParam intParam = (IntParam) paramAnn;
                String parameterName = null;
                if (StringUtils.isNotBlank(intParam.value())) {
                    parameterName = intParam.value();
                } else {
                    parameterName = parameter.getParameterName();
                }
                String value = req.getParameter(parameterName);
                if (value != null && NumberUtils.isDigits(value)) {
                    result = Integer.parseInt(value);
                } else {
                    result = 0;
                }
            }

        }
    }

    return result;

}

From source file:dstrelec.nats.listener.adapter.MessagingMessageListenerAdapter.java

/**
 * Subclasses can override this method to use a different mechanism to determine
 * the target type of the payload conversion.
 * @param method the method./*  w ww .j  a va2s .co  m*/
 * @return the type.
 */
protected Type determineInferredType(Method method) {
    if (method == null) {
        return null;
    }

    Type genericParameterType = null;

    for (int i = 0; i < method.getParameterTypes().length; i++) {
        MethodParameter methodParameter = new MethodParameter(method, i);
        /*
         * We're looking for a single non-annotated parameter, or one annotated with @Payload.
         * We ignore parameters with type Message because they are not involved with conversion.
         */
        if (eligibleParameter(methodParameter) && (methodParameter.getParameterAnnotations().length == 0
                || methodParameter.hasParameterAnnotation(Payload.class))) {
            if (genericParameterType == null) {
                genericParameterType = methodParameter.getGenericParameterType();
                if (genericParameterType instanceof ParameterizedType) {
                    ParameterizedType parameterizedType = (ParameterizedType) genericParameterType;
                    if (parameterizedType.getRawType().equals(Message.class)) {
                        genericParameterType = ((ParameterizedType) genericParameterType)
                                .getActualTypeArguments()[0];
                    } else if (parameterizedType.getRawType().equals(List.class)
                            && parameterizedType.getActualTypeArguments().length == 1) {
                        Type paramType = parameterizedType.getActualTypeArguments()[0];
                        this.isConsumerRecordList = paramType.equals(io.nats.client.Message.class)
                                || (paramType instanceof ParameterizedType && ((ParameterizedType) paramType)
                                        .getRawType().equals(io.nats.client.Message.class));
                        this.isMessageList = paramType.equals(Message.class)
                                || (paramType instanceof ParameterizedType
                                        && ((ParameterizedType) paramType).getRawType().equals(Message.class));
                    }
                }
            } else {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Ambiguous parameters for target payload for method " + method
                            + "; no inferred type available");
                }
                break;
            }
        }
    }
    Assert.state(!this.isConsumerRecordList || method.getParameterTypes().length == 1,
            "A parameter of type 'List<ConsumerRecord>' must be the only parameter");
    Assert.state(!this.isMessageList || method.getParameterTypes().length == 1,
            "A parameter of type 'List<Message<?>>' must be the only parameter");

    return genericParameterType;
}

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;//from  w  w w .  j  av  a 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.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;// w  ww  . jav  a 2 s  .  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.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  v a 2  s .c  om
        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 for a specific handler method.
 * @param handler The handler//from   w  ww. j a va 2 s .c  om
 * @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;
}

From source file:org.springframework.integration.gateway.GatewayMethodInboundMessageMapper.java

private Message<?> mapArgumentsToMessage(Object[] arguments) {
    Object messageOrPayload = null;
    boolean foundPayloadAnnotation = false;
    Map<String, Object> headers = new HashMap<String, Object>();
    EvaluationContext methodInvocationEvaluationContext = createMethodInvocationEvaluationContext(arguments);
    if (this.payloadExpression != null) {
        messageOrPayload = this.payloadExpression.getValue(methodInvocationEvaluationContext);
    }/*w  w  w .j  av  a 2  s.  c om*/
    for (int i = 0; i < this.parameterList.size(); i++) {
        Object argumentValue = arguments[i];
        MethodParameter methodParameter = this.parameterList.get(i);
        Annotation annotation = this.findMappingAnnotation(methodParameter.getParameterAnnotations());
        if (annotation != null) {
            if (annotation.annotationType().equals(Payload.class)) {
                if (messageOrPayload != null) {
                    this.throwExceptionForMultipleMessageOrPayloadParameters(methodParameter);
                }
                String expression = ((Payload) annotation).value();
                if (!StringUtils.hasText(expression)) {
                    messageOrPayload = argumentValue;
                } else {
                    messageOrPayload = this.evaluatePayloadExpression(expression, argumentValue);
                }
                foundPayloadAnnotation = true;
            } else if (annotation.annotationType().equals(Header.class)) {
                Header headerAnnotation = (Header) annotation;
                String headerName = this.determineHeaderName(headerAnnotation, methodParameter);
                if (headerAnnotation.required() && argumentValue == null) {
                    throw new IllegalArgumentException(
                            "Received null argument value for required header: '" + headerName + "'");
                }
                headers.put(headerName, argumentValue);
            } else if (annotation.annotationType().equals(Headers.class)) {
                if (argumentValue != null) {
                    if (!(argumentValue instanceof Map)) {
                        throw new IllegalArgumentException(
                                "@Headers annotation is only valid for Map-typed parameters");
                    }
                    for (Object key : ((Map<?, ?>) argumentValue).keySet()) {
                        Assert.isInstanceOf(String.class, key,
                                "Invalid header name [" + key + "], name type must be String.");
                        Object value = ((Map<?, ?>) argumentValue).get(key);
                        headers.put((String) key, value);
                    }
                }
            }
        } else if (messageOrPayload == null) {
            messageOrPayload = argumentValue;
        } else if (Map.class.isAssignableFrom(methodParameter.getParameterType())) {
            if (messageOrPayload instanceof Map && !foundPayloadAnnotation) {
                if (payloadExpression == null) {
                    throw new MessagingException("Ambiguous method parameters; found more than one "
                            + "Map-typed parameter and neither one contains a @Payload annotation");
                }
            }
            this.copyHeaders((Map<?, ?>) argumentValue, headers);
        } else if (this.payloadExpression == null) {
            this.throwExceptionForMultipleMessageOrPayloadParameters(methodParameter);
        }
    }
    Assert.isTrue(messageOrPayload != null,
            "unable to determine a Message or payload parameter on method [" + method + "]");
    MessageBuilder<?> builder = (messageOrPayload instanceof Message)
            ? MessageBuilder.fromMessage((Message<?>) messageOrPayload)
            : MessageBuilder.withPayload(messageOrPayload);
    builder.copyHeadersIfAbsent(headers);
    if (!CollectionUtils.isEmpty(this.headerExpressions)) {
        Map<String, Object> evaluatedHeaders = new HashMap<String, Object>();
        for (Map.Entry<String, Expression> entry : this.headerExpressions.entrySet()) {
            Object value = entry.getValue().getValue(methodInvocationEvaluationContext);
            if (value != null) {
                evaluatedHeaders.put(entry.getKey(), value);
            }
        }
        builder.copyHeaders(evaluatedHeaders);
    }
    return builder.build();
}