/** * An overloaded method that uses the ConversionService created at construction. */ public void contributeMethodArgument(MethodParameter parameter, Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables) { this.contributeMethodArgument(parameter, value, builder, uriVariables, this.conversionService); }
private InvocableHandlerMethod createModelAttributeMethod(WebDataBinderFactory factory, Object bean, Method method) { InvocableHandlerMethod attrMethod = new InvocableHandlerMethod(bean, method); if (this.argumentResolvers != null) { attrMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers); } attrMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer); attrMethod.setDataBinderFactory(factory); return attrMethod; }
/** * Whether the given {@linkplain MethodParameter method return type} is supported by any registered * {@link HandlerMethodReturnValueHandler}. */ @Override public boolean supportsReturnType(MethodParameter returnType) { return getReturnValueHandler(returnType) != null; }
@Override public void afterPropertiesSet() { // Do this first, it may add ResponseBodyAdvice beans initExceptionHandlerAdviceCache(); if (this.argumentResolvers == null) { List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers(); this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers); } if (this.returnValueHandlers == null) { List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers(); this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers); } }
private Object testResolveArgument(MethodParameter param, WebDataBinderFactory factory) throws Exception { ModelAndViewContainer mavContainer = new ModelAndViewContainer(); return this.resolver.resolveArgument(param, mavContainer, this.webRequest, factory); }
@Test public void handleReturnValue() throws Exception { this.handlers.handleReturnValue(55, this.integerType, this.mavContainer, null); verify(this.integerHandler).handleReturnValue(55, this.integerType, this.mavContainer, null); }
@Test public void resolveNoArgValue() throws Exception { this.composite.addResolver(new StubArgumentResolver(Integer.class)); this.composite.addResolver(new StubArgumentResolver(String.class)); Object returnValue = getInvocable(Integer.class, String.class).invokeForRequest(request, null); assertEquals(1, getStubResolver(0).getResolvedParameters().size()); assertEquals(1, getStubResolver(1).getResolvedParameters().size()); assertEquals("null-null", returnValue); }
@Nullable private HandlerMethodReturnValueHandler selectHandler(@Nullable Object value, MethodParameter returnType) { boolean isAsyncValue = isAsyncReturnValue(value, returnType); for (HandlerMethodReturnValueHandler handler : this.returnValueHandlers) { if (isAsyncValue && !(handler instanceof AsyncHandlerMethodReturnValueHandler)) { continue; } if (handler.supportsReturnType(returnType)) { return handler; } } return null; }
@Test public void resolveProvidedArgFirst() throws Exception { this.composite.addResolver(new StubArgumentResolver(1)); this.composite.addResolver(new StubArgumentResolver("value1")); Object value = getInvocable(Integer.class, String.class).invokeForRequest(request, null, 2, "value2"); assertEquals("2-value2", value); }
@Test public void checkArgumentResolverOrder() throws Exception { this.resolverComposite.addResolver(new StubArgumentResolver(1)); this.resolverComposite.addResolver(new StubArgumentResolver(2)); Object resolvedValue = this.resolverComposite.resolveArgument(paramInt, null, null, null); assertEquals("Didn't use the first registered resolver", 1, resolvedValue); }
@Override public void contributeMethodArgument(MethodParameter parameter, Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables, ConversionService conversionService) { for (Object contributor : this.contributors) { if (contributor instanceof UriComponentsContributor) { UriComponentsContributor ucc = (UriComponentsContributor) contributor; if (ucc.supportsParameter(parameter)) { ucc.contributeMethodArgument(parameter, value, builder, uriVariables, conversionService); break; } } else if (contributor instanceof HandlerMethodArgumentResolver) { if (((HandlerMethodArgumentResolver) contributor).supportsParameter(parameter)) { break; } } } }
@Test public void exceptionInResolvingArg() throws Exception { this.composite.addResolver(new ExceptionRaisingArgumentResolver()); try { getInvocable(Integer.class, String.class).invokeForRequest(request, null); fail("Expected exception"); } catch (IllegalArgumentException ex) { // expected - allow HandlerMethodArgumentResolver exceptions to propagate } }
private InvocableHandlerMethod getInvocable(Class<?>... argTypes) { Method method = ResolvableMethod.on(Handler.class).argTypes(argTypes).resolveMethod(); InvocableHandlerMethod handlerMethod = new InvocableHandlerMethod(new Handler(), method); handlerMethod.setHandlerMethodArgumentResolvers(this.composite); return handlerMethod; }
public boolean checkDependencies(ModelAndViewContainer mavContainer) { for (String name : this.dependencies) { if (!mavContainer.containsAttribute(name)) { return false; } } return true; }
@Override public boolean supportsParameter(MethodParameter parameter) { for (Object contributor : this.contributors) { if (contributor instanceof UriComponentsContributor) { if (((UriComponentsContributor) contributor).supportsParameter(parameter)) { return true; } } else if (contributor instanceof HandlerMethodArgumentResolver) { if (((HandlerMethodArgumentResolver) contributor).supportsParameter(parameter)) { return false; } } } return false; }
@Test public void supportsParameter() { this.resolverComposite.addResolver(new StubArgumentResolver(Integer.class)); assertTrue(this.resolverComposite.supportsParameter(paramInt)); assertFalse(this.resolverComposite.supportsParameter(paramStr)); }
/** * Whether the given {@linkplain MethodParameter method parameter} is * supported by any registered {@link HandlerMethodArgumentResolver}. */ @Override public boolean supportsParameter(MethodParameter parameter) { return getArgumentResolver(parameter) != null; }
@Test public void resolveArg() throws Exception { this.composite.addResolver(new StubArgumentResolver(99)); this.composite.addResolver(new StubArgumentResolver("value")); Object value = getInvocable(Integer.class, String.class).invokeForRequest(request, null); assertEquals(1, getStubResolver(0).getResolvedParameters().size()); assertEquals(1, getStubResolver(1).getResolvedParameters().size()); assertEquals("99-value", value); assertEquals("intArg", getStubResolver(0).getResolvedParameters().get(0).getParameterName()); assertEquals("stringArg", getStubResolver(1).getResolvedParameters().get(0).getParameterName()); }
@Test // SPR-13917 public void invocationErrorMessage() throws Exception { this.composite.addResolver(new StubArgumentResolver(double.class)); try { getInvocable(double.class).invokeForRequest(this.request, null); fail(); } catch (IllegalStateException ex) { assertThat(ex.getMessage(), containsString("Illegal argument")); } }
@Test public void resolveArgument() throws Exception { this.resolverComposite.addResolver(new StubArgumentResolver(55)); Object resolvedValue = this.resolverComposite.resolveArgument(paramInt, null, null, null); assertEquals(55, resolvedValue); }