@Override public void afterPropertiesSet() { if (this.messageConverter == null) { this.messageConverter = new GenericMessageConverter(this.conversionService); } if (this.argumentResolvers.getResolvers().isEmpty()) { this.argumentResolvers.addResolvers(initArgumentResolvers()); } }
/** * 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); }
continue; if (!this.resolvers.supportsParameter(parameter)) { throw new MethodArgumentResolutionException( message, parameter, formatArgumentError(parameter, "No suitable resolver")); args[i] = this.resolvers.resolveArgument(parameter, message);
public HandlerMethodService(ConversionService conversionService, List<HandlerMethodArgumentResolver> customArgumentResolvers, ObjectMapper objectMapper, ApplicationContext applicationContext) { this.conversionService = conversionService; this.parameterNameDiscoverer = new DefaultParameterNameDiscoverer(); this.argumentResolvers = new HandlerMethodArgumentResolverComposite(); ConfigurableBeanFactory beanFactory = ClassUtils.isAssignableValue( ConfigurableApplicationContext.class, applicationContext) ? ((ConfigurableApplicationContext) applicationContext) .getBeanFactory() : null; this.argumentResolvers.addResolver( new HeaderMethodArgumentResolver(this.conversionService, beanFactory)); this.argumentResolvers.addResolver(new HeadersMethodArgumentResolver()); this.argumentResolvers.addResolver(new WampMessageMethodArgumentResolver()); this.argumentResolvers.addResolver(new PrincipalMethodArgumentResolver()); this.argumentResolvers.addResolver(new WampSessionIdMethodArgumentResolver()); this.argumentResolvers.addResolvers(customArgumentResolvers); this.objectMapper = objectMapper; }
/** * Return the complete list of argument resolvers. */ public List<HandlerMethodArgumentResolver> getArgumentResolvers() { return this.argumentResolvers.getResolvers(); }
/** * 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 illegalArgumentException() throws Exception { this.resolvers.addResolver(new StubArgumentResolver(Integer.class, "__not_an_int__")); this.resolvers.addResolver(new StubArgumentResolver("value")); try { Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0, "")).method(); invoke(new Handler(), method); fail("Expected exception"); } catch (IllegalStateException ex) { assertNotNull("Exception not wrapped", ex.getCause()); assertTrue(ex.getCause() instanceof IllegalArgumentException); assertTrue(ex.getMessage().contains("Endpoint [")); assertTrue(ex.getMessage().contains("Method [")); assertTrue(ex.getMessage().contains("with argument values:")); assertTrue(ex.getMessage().contains("[0] [type=java.lang.String] [value=__not_an_int__]")); assertTrue(ex.getMessage().contains("[1] [type=java.lang.String] [value=value")); } }
private StreamListenerMessageHandler buildStreamListener(Class<?> handlerClass, String handlerMethodName, Class<?>... parameters) throws Exception { String channelName = "reply_" + System.nanoTime(); GenericApplicationContext context = new GenericApplicationContext(); context.getBeanFactory().registerSingleton(channelName, new QueueChannel()); Method m = ReflectionUtils.findMethod(handlerClass, handlerMethodName, parameters); InvocableHandlerMethod method = new InvocableHandlerMethod(this, m); HandlerMethodArgumentResolverComposite resolver = new HandlerMethodArgumentResolverComposite(); CompositeMessageConverterFactory factory = new CompositeMessageConverterFactory(); resolver.addResolver(new PayloadArgumentResolver( factory.getMessageConverterForAllRegistered())); method.setMessageMethodArgumentResolvers(resolver); Constructor<?> c = ReflectionUtils.accessibleConstructor( StreamListenerMessageHandler.class, InvocableHandlerMethod.class, boolean.class, String[].class); StreamListenerMessageHandler handler = (StreamListenerMessageHandler) c .newInstance(method, false, new String[] { }); handler.setOutputChannelName(channelName); handler.setBeanFactory(context); handler.afterPropertiesSet(); context.refresh(); return handler; }
private StubArgumentResolver getStubResolver(int index) { return (StubArgumentResolver) this.resolvers.getResolvers().get(index); }
/** * Iterate over registered * {@link HandlerMethodArgumentResolver HandlerMethodArgumentResolvers} * and invoke the one that supports it. * @throws IllegalStateException if no suitable * {@link HandlerMethodArgumentResolver} is found. */ @Override @Nullable public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter); if (resolver == null) { throw new IllegalStateException( "Unsupported parameter type [" + parameter.getParameterType().getName() + "]." + " supportsParameter should be called first."); } return resolver.resolveArgument(parameter, message); }
@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); }
@Override public void afterPropertiesSet() { if (this.argumentResolvers.getResolvers().isEmpty()) { this.argumentResolvers.addResolvers(initArgumentResolvers());
/** * 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}. */ public void setArgumentResolvers(@Nullable List<HandlerMethodArgumentResolver> argumentResolvers) { if (argumentResolvers == null) { this.argumentResolvers.clear(); return; } this.argumentResolvers.addResolvers(argumentResolvers); }
continue; if (!this.resolvers.supportsParameter(parameter)) { throw new MethodArgumentResolutionException( message, parameter, formatArgumentError(parameter, "No suitable resolver")); args[i] = this.resolvers.resolveArgument(parameter, message);
/** * Return the complete list of argument resolvers. */ public List<HandlerMethodArgumentResolver> getArgumentResolvers() { return this.argumentResolvers.getResolvers(); }
/** * 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 // Based on SPR-13917 (spring-web) public void invocationErrorMessage() throws Exception { this.resolvers.addResolver(new StubArgumentResolver(double.class)); try { Method method = ResolvableMethod.on(Handler.class).mockCall(c -> c.handle(0.0)).method(); invoke(new Handler(), method); fail(); } catch (IllegalStateException ex) { assertThat(ex.getMessage(), containsString("Illegal argument")); } }
@Override public void afterPropertiesSet() { if (this.messageConverter == null) { this.messageConverter = new GenericMessageConverter(this.conversionService); } if (this.argumentResolvers.getResolvers().isEmpty()) { this.argumentResolvers.addResolvers(initArgumentResolvers()); } }
/** * 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); }
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer); if (this.argumentResolvers.supportsParameter(parameter)) { try { args[i] = this.argumentResolvers.resolveArgument(parameter, message); continue;