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:org.springframework.faces.mvc.annotation.support.AnnotatedMethodInvoker.java

/**
 * Resolve a single argument. This method supports custom resolvers and standard argument types.
 * @param methodParameter The parameter to resolver
 * @param webRequest The web request//from ww w.j av a 2 s.  co m
 * @return The resolved argument (can be <tt>null</tt>) or {@link WebArgumentResolver#UNRESOLVED} if the argument
 * cannot be resolved.
 * @throws Exception on error
 * @see #resolveStandardArgument(Class, NativeWebRequest)
 */
protected Object resolveCommonArgument(MethodParameter methodParameter, NativeWebRequest webRequest)
        throws Exception {
    // Invoke custom argument resolvers if present...
    Object custom = invokeArgumentResolvers(methodParameter, webRequest, customArgumentResolvers);
    if (custom != WebArgumentResolver.UNRESOLVED) {
        return custom;
    }

    // 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

/**
 * Resolve a standard argument type. This method can be overridden by subclasses to extend supported argument types.
 * @param parameterType The paramter type to resolve
 * @param webRequest The web request//from w w  w.j  a  v  a2s.  c  om
 * @return The resolved argument (can be <tt>null</tt>) or {@link WebArgumentResolver#UNRESOLVED} if the argument
 * @throws Exception on error
 */
protected Object resolveStandardArgument(Class parameterType, NativeWebRequest webRequest) throws Exception {
    if ((webRequest.getNativeRequest() instanceof HttpServletRequest)
            && (webRequest.getNativeResponse() instanceof HttpServletResponse)) {

        HttpServletRequest request = (HttpServletRequest) webRequest.getNativeRequest();
        HttpServletResponse response = (HttpServletResponse) webRequest.getNativeResponse();

        if (ServletRequest.class.isAssignableFrom(parameterType)) {
            return request;
        } else if (ServletResponse.class.isAssignableFrom(parameterType)) {
            return response;
        } else if (HttpSession.class.isAssignableFrom(parameterType)) {
            return request.getSession();
        } else if (Principal.class.isAssignableFrom(parameterType)) {
            return request.getUserPrincipal();
        } else if (Locale.class.equals(parameterType)) {
            return RequestContextUtils.getLocale(request);
        } else if (InputStream.class.isAssignableFrom(parameterType)) {
            return request.getInputStream();
        } else if (Reader.class.isAssignableFrom(parameterType)) {
            return request.getReader();
        } else if (OutputStream.class.isAssignableFrom(parameterType)) {
            return response.getOutputStream();
        } else if (Writer.class.isAssignableFrom(parameterType)) {
            return response.getWriter();
        } else if (WebRequest.class.isAssignableFrom(parameterType)) {
            return webRequest;
        }
    }
    return WebArgumentResolver.UNRESOLVED;
}

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/*from  w w w  . j  ava  2  s . com*/
 * @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

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 ww  w . j  a v a  2 s .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;
        Object[] validationHints = null;
        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 {
                Validated validatedAnn = AnnotationUtils.getAnnotation(paramAnn, Validated.class);
                if (validatedAnn != null || paramAnn.annotationType().getSimpleName().startsWith("Valid")) {
                    validate = true;
                    Object hints = (validatedAnn != null ? validatedAnn.value()
                            : AnnotationUtils.getValue(paramAnn));
                    validationHints = (hints instanceof Object[] ? (Object[]) hints : new Object[] { hints });
                }
            }
        }

        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)) {
                    if (!paramType.isAssignableFrom(implicitModel.getClass())) {
                        throw new IllegalStateException("Argument [" + paramType.getSimpleName()
                                + "] is of type "
                                + "Model or Map but is not assignable from the actual model. You may need to switch "
                                + "newer MVC infrastructure classes to use this argument.");
                    }
                    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, validationHints, !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.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 a2s . 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.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 w w.  java 2  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;
}

From source file:org.springframework.web.method.annotation.AbstractWebArgumentResolverAdapter.java

/**
 * Actually resolve the value and check the resolved value is not
 * {@link WebArgumentResolver#UNRESOLVED} absorbing _any_ exceptions.
 *///from   w w w .j  av a2  s  .com
@Override
public boolean supportsParameter(MethodParameter parameter) {
    try {
        NativeWebRequest webRequest = getWebRequest();
        Object result = this.adaptee.resolveArgument(parameter, webRequest);
        if (result == WebArgumentResolver.UNRESOLVED) {
            return false;
        } else {
            return ClassUtils.isAssignableValue(parameter.getParameterType(), result);
        }
    } catch (Exception ex) {
        // ignore (see class-level doc)
        logger.debug(
                "Error in checking support for parameter [" + parameter + "], message: " + ex.getMessage());
        return false;
    }
}

From source file:org.springframework.web.method.annotation.AbstractWebArgumentResolverAdapter.java

/**
 * Delegate to the {@link WebArgumentResolver} instance.
 * @throws IllegalStateException if the resolved value is not assignable
 * to the method parameter./*w w  w  . j a v a 2s.  com*/
 */
@Override
@Nullable
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    Class<?> paramType = parameter.getParameterType();
    Object result = this.adaptee.resolveArgument(parameter, webRequest);
    if (result == WebArgumentResolver.UNRESOLVED || !ClassUtils.isAssignableValue(paramType, result)) {
        throw new IllegalStateException("Standard argument type [" + paramType.getName() + "] in method "
                + parameter.getMethod() + "resolved to incompatible value of type ["
                + (result != null ? result.getClass() : null)
                + "]. Consider declaring the argument type in a less specific fashion.");
    }
    return result;
}

From source file:org.springframework.web.method.annotation.support.AbstractWebArgumentResolverAdapter.java

/**
 * See the class-level documentation for an important consideration about exceptions arising in this method.
 *///  ww  w  .  j  ava2 s.  c o m
public boolean supportsParameter(MethodParameter parameter) {
    try {
        NativeWebRequest webRequest = getWebRequest();
        Object result = adaptee.resolveArgument(parameter, webRequest);
        if (result == WebArgumentResolver.UNRESOLVED) {
            return false;
        } else {
            return ClassUtils.isAssignableValue(parameter.getParameterType(), result);
        }
    } catch (Exception ex) {
        // ignore
        logger.trace(
                "Error in checking support for parameter [" + parameter + "], message: " + ex.getMessage());
        return false;
    }
}

From source file:org.springframework.web.method.annotation.support.AbstractWebArgumentResolverAdapter.java

/**
 * Resolves the argument value by delegating to the {@link WebArgumentResolver} instance.
 * @exception IllegalStateException if the resolved value is {@link WebArgumentResolver#UNRESOLVED} or if the 
 * return value type cannot be assigned to the method parameter type.
 *///from   ww w .  ja  v  a 2  s.c o  m
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
        NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
    Class<?> paramType = parameter.getParameterType();
    Object result = adaptee.resolveArgument(parameter, webRequest);
    if (result == WebArgumentResolver.UNRESOLVED || !ClassUtils.isAssignableValue(paramType, result)) {
        throw new IllegalStateException("Standard argument type [" + paramType.getName()
                + "] resolved to incompatible value of type [" + (result != null ? result.getClass() : null)
                + "]. Consider declaring the argument type in a less specific fashion.");
    }
    return result;
}