@Override public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) { HandlerMethodReturnValueHandler handler = getReturnValueHandler(returnType); return (handler instanceof AsyncHandlerMethodReturnValueHandler && ((AsyncHandlerMethodReturnValueHandler) handler).isAsyncReturnValue(returnValue, returnType)); }
/** * Configure the complete list of supported argument types effectively overriding * the ones configured by default. This is an advanced option. For most use cases * it should be sufficient to use {@link #setCustomArgumentResolvers(java.util.List)}. */ public void setArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) { if (argumentResolvers == null) { this.argumentResolvers.clear(); return; } this.argumentResolvers.addResolvers(argumentResolvers); }
@Override public InvocableHandlerMethod createInvocableHandlerMethod(Object bean, Method method) { InvocableHandlerMethod handlerMethod = new InvocableHandlerMethod(bean, method); handlerMethod.setMessageMethodArgumentResolvers(this.argumentResolvers); return handlerMethod; }
@Test public void resolveNoArgValue() throws Exception { this.resolvers.addResolver(new StubArgumentResolver(Integer.class)); this.resolvers.addResolver(new StubArgumentResolver(String.class)); Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method(); Object value = invoke(new Handler(), method); assertEquals(1, getStubResolver(0).getResolvedParameters().size()); assertEquals(1, getStubResolver(1).getResolvedParameters().size()); assertEquals("null-null", value); }
@Test public void resolveProvidedArgFirst() throws Exception { this.resolvers.addResolver(new StubArgumentResolver(1)); this.resolvers.addResolver(new StubArgumentResolver("value1")); Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method(); Object value = invoke(new Handler(), method, 2, "value2"); assertEquals("2-value2", value); }
@Test public void exceptionInResolvingArg() throws Exception { this.resolvers.addResolver(new ExceptionRaisingArgumentResolver()); try { Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method(); invoke(new Handler(), method); fail("Expected exception"); } catch (IllegalArgumentException ex) { // expected - allow HandlerMethodArgumentResolver exceptions to propagate } }
@Override @Nullable public ListenableFuture<?> toListenableFuture(Object returnValue, MethodParameter returnType) { HandlerMethodReturnValueHandler handler = getReturnValueHandler(returnType); Assert.state(handler instanceof AsyncHandlerMethodReturnValueHandler, "AsyncHandlerMethodReturnValueHandler required"); return ((AsyncHandlerMethodReturnValueHandler) handler).toListenableFuture(returnValue, returnType); }
private void addMatchesToCollection(Collection<T> mappingsToCheck, Message<?> message, List<Match> matches) { for (T mapping : mappingsToCheck) { T match = getMatchingMapping(mapping, message); if (match != null) { matches.add(new Match(match, this.handlerMethods.get(mapping))); } } }
/** * Return the complete list of argument resolvers. */ public List<HandlerMethodArgumentResolver> getArgumentResolvers() { return this.argumentResolvers.getResolvers(); }
public void registerHandler(Object handler) { super.detectHandlerMethods(handler); }
public void registerHandlerMethod(Object handler, Method method, String mapping) { super.registerHandlerMethod(handler, method, mapping); }
/** * Create a new instance providing the invalid {@code MethodParameter}. */ public MethodArgumentResolutionException(Message<?> message, MethodParameter parameter) { super(message, getMethodParameterMessage(parameter)); this.parameter = parameter; }
@Override public AsyncResultMethodParameter clone() { return new AsyncResultMethodParameter(this); } }
/** * Return the complete list of return value handlers. */ public List<HandlerMethodReturnValueHandler> getReturnValueHandlers() { return this.returnValueHandlers.getReturnValueHandlers(); }
/** * Whether the given {@linkplain MethodParameter method parameter} is * supported by any registered {@link HandlerMethodArgumentResolver}. */ @Override public boolean supportsParameter(MethodParameter parameter) { return getArgumentResolver(parameter) != null; }
@Override public boolean supportsReturnType(MethodParameter returnType) { return getReturnValueHandler(returnType) != null; }
@Test(expected = IllegalStateException.class) public void duplicateMapping() { this.messageHandler.registerHandler(new DuplicateMappingsController()); }
@Override protected AbstractExceptionHandlerMethodResolver createExceptionHandlerMethodResolverFor(Class<?> beanType) { return new TestExceptionHandlerMethodResolver(beanType); } }
public TestExceptionHandlerMethodResolver(Class<?> handlerType) { super(initExceptionMappings(handlerType)); }
/** * Create a new instance providing the invalid {@code MethodParameter} and * a prepared description. */ public MethodArgumentResolutionException(Message<?> message, MethodParameter parameter, String description) { super(message, getMethodParameterMessage(parameter) + ": " + description); this.parameter = parameter; }