protected List<HandlerMethodArgumentResolver> initArgumentResolvers() { List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(); ConfigurableBeanFactory cbf = (this.beanFactory instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory) this.beanFactory : null); // Annotation-based argument resolution resolvers.add(new HeaderMethodArgumentResolver(this.conversionService, cbf)); resolvers.add(new HeadersMethodArgumentResolver()); // Type-based argument resolution resolvers.add(new MessageMethodArgumentResolver(this.messageConverter)); if (this.customArgumentResolvers != null) { resolvers.addAll(this.customArgumentResolvers); } resolvers.add(new PayloadArgumentResolver(this.messageConverter, this.validator)); return resolvers; }
@Override public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { Class<?> targetMessageType = parameter.getParameterType(); Class<?> targetPayloadType = getPayloadType(parameter); if (!targetMessageType.isAssignableFrom(message.getClass())) { throw new MethodArgumentTypeMismatchException(message, parameter, "Actual message type '" + ClassUtils.getDescriptiveType(message) + "' does not match expected type '" + ClassUtils.getQualifiedName(targetMessageType) + "'"); } Object payload = message.getPayload(); if (targetPayloadType.isInstance(payload)) { return message; } if (isEmptyPayload(payload)) { throw new MessageConversionException(message, "Cannot convert from actual payload type '" + ClassUtils.getDescriptiveType(payload) + "' to expected payload type '" + ClassUtils.getQualifiedName(targetPayloadType) + "' when payload is empty"); } payload = convertPayload(message, parameter, targetPayloadType); return MessageBuilder.createMessage(payload, message.getHeaders()); }
@Test public void resolveWithPayloadTypeAsWildcardAndNoConverter() throws Exception { this.resolver = new MessageMethodArgumentResolver(); Message<String> message = MessageBuilder.withPayload("test").build(); MethodParameter parameter = new MethodParameter(this.method, 0); assertTrue(this.resolver.supportsParameter(parameter)); assertSame(message, this.resolver.resolveArgument(parameter, message)); }
@Test public void resolveWithMessageSubclassAndPayloadWildcard() throws Exception { ErrorMessage message = new ErrorMessage(new UnsupportedOperationException()); MethodParameter parameter = new MethodParameter(this.method, 0); assertTrue(this.resolver.supportsParameter(parameter)); assertSame(message, this.resolver.resolveArgument(parameter, message)); }
@Test // SPR-16486 public void resolveWithJacksonConverter() throws Exception { Message<String> inMessage = MessageBuilder.withPayload("{\"foo\":\"bar\"}").build(); MethodParameter parameter = new MethodParameter(this.method, 5); this.resolver = new MessageMethodArgumentResolver(new MappingJackson2MessageConverter()); Object actual = this.resolver.resolveArgument(parameter, inMessage); assertTrue(actual instanceof Message); Message<?> outMessage = (Message<?>) actual; assertTrue(outMessage.getPayload() instanceof Foo); assertEquals("bar", ((Foo) outMessage.getPayload()).getFoo()); }
@Test public void resolveWithConversion() throws Exception { Message<String> message = MessageBuilder.withPayload("test").build(); MethodParameter parameter = new MethodParameter(this.method, 1); when(this.converter.fromMessage(message, Integer.class)).thenReturn(4); @SuppressWarnings("unchecked") Message<Integer> actual = (Message<Integer>) this.resolver.resolveArgument(parameter, message); assertNotNull(actual); assertSame(message.getHeaders(), actual.getHeaders()); assertEquals(new Integer(4), actual.getPayload()); }
@Test public void resolveMessageSubclassMatch() throws Exception { ErrorMessage message = new ErrorMessage(new UnsupportedOperationException()); MethodParameter parameter = new MethodParameter(this.method, 4); assertTrue(this.resolver.supportsParameter(parameter)); assertSame(message, this.resolver.resolveArgument(parameter, message)); }
@Override public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { Class<?> targetMessageType = parameter.getParameterType(); Class<?> targetPayloadType = getPayloadType(parameter); if (!targetMessageType.isAssignableFrom(message.getClass())) { throw new MethodArgumentTypeMismatchException(message, parameter, "Actual message type '" + ClassUtils.getDescriptiveType(message) + "' does not match expected type '" + ClassUtils.getQualifiedName(targetMessageType) + "'"); } Object payload = message.getPayload(); if (targetPayloadType.isInstance(payload)) { return message; } if (isEmptyPayload(payload)) { throw new MessageConversionException(message, "Cannot convert from actual payload type '" + ClassUtils.getDescriptiveType(payload) + "' to expected payload type '" + ClassUtils.getQualifiedName(targetPayloadType) + "' when payload is empty"); } payload = convertPayload(message, parameter, targetPayloadType); return MessageBuilder.createMessage(payload, message.getHeaders()); }
protected List<HandlerMethodArgumentResolver> initArgumentResolvers() { ApplicationContext context = getApplicationContext(); ConfigurableBeanFactory beanFactory = (context instanceof ConfigurableApplicationContext ? ((ConfigurableApplicationContext) context).getBeanFactory() : null); List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(); // Annotation-based argument resolution resolvers.add(new HeaderMethodArgumentResolver(this.conversionService, beanFactory)); resolvers.add(new HeadersMethodArgumentResolver()); resolvers.add(new DestinationVariableMethodArgumentResolver(this.conversionService)); // Type-based argument resolution resolvers.add(new PrincipalMethodArgumentResolver()); resolvers.add(new MessageMethodArgumentResolver(this.messageConverter)); resolvers.addAll(getCustomArgumentResolvers()); resolvers.add(new PayloadArgumentResolver(this.messageConverter, this.validator)); return resolvers; }
@Test public void resolveWithConversionNeededButNoConverter() throws Exception { this.resolver = new MessageMethodArgumentResolver(); Message<String> message = MessageBuilder.withPayload("test").build(); MethodParameter parameter = new MethodParameter(this.method, 1); assertTrue(this.resolver.supportsParameter(parameter)); thrown.expect(MessageConversionException.class); thrown.expectMessage(Integer.class.getName()); thrown.expectMessage(String.class.getName()); this.resolver.resolveArgument(parameter, message); }
@Test public void resolveWithPayloadTypeOutOfBound() throws Exception { Message<Locale> message = MessageBuilder.withPayload(Locale.getDefault()).build(); MethodParameter parameter = new MethodParameter(this.method, 3); assertTrue(this.resolver.supportsParameter(parameter)); thrown.expect(MessageConversionException.class); thrown.expectMessage(Number.class.getName()); thrown.expectMessage(Locale.class.getName()); this.resolver.resolveArgument(parameter, message); }
@Override public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { Class<?> targetMessageType = parameter.getParameterType(); Class<?> targetPayloadType = getPayloadType(parameter); if (!targetMessageType.isAssignableFrom(message.getClass())) { throw new MethodArgumentTypeMismatchException(message, parameter, "Actual message type '" + ClassUtils.getDescriptiveType(message) + "' does not match expected type '" + ClassUtils.getQualifiedName(targetMessageType) + "'"); } Object payload = message.getPayload(); if (targetPayloadType.isInstance(payload)) { return message; } if (isEmptyPayload(payload)) { throw new MessageConversionException(message, "Cannot convert from actual payload type '" + ClassUtils.getDescriptiveType(payload) + "' to expected payload type '" + ClassUtils.getQualifiedName(targetPayloadType) + "' when payload is empty"); } payload = convertPayload(message, parameter, targetPayloadType); return MessageBuilder.createMessage(payload, message.getHeaders()); }
@Before public void setup() throws Exception { this.method = MessageMethodArgumentResolverTests.class.getDeclaredMethod("handle", Message.class, Message.class, Message.class, Message.class, ErrorMessage.class, Message.class); this.converter = mock(MessageConverter.class); this.resolver = new MessageMethodArgumentResolver(this.converter); }
@Test public void resolveWithConversionEmptyPayloadButNoConverter() throws Exception { this.resolver = new MessageMethodArgumentResolver(); Message<String> message = MessageBuilder.withPayload("").build(); MethodParameter parameter = new MethodParameter(this.method, 1); assertTrue(this.resolver.supportsParameter(parameter)); thrown.expect(MessageConversionException.class); thrown.expectMessage("payload is empty"); thrown.expectMessage(Integer.class.getName()); thrown.expectMessage(String.class.getName()); this.resolver.resolveArgument(parameter, message); }
@Test public void resolveWithWrongMessageType() throws Exception { UnsupportedOperationException ex = new UnsupportedOperationException(); Message<? extends Throwable> message = new GenericMessage<Throwable>(ex); MethodParameter parameter = new MethodParameter(this.method, 4); assertTrue(this.resolver.supportsParameter(parameter)); thrown.expect(MethodArgumentTypeMismatchException.class); thrown.expectMessage(ErrorMessage.class.getName()); thrown.expectMessage(GenericMessage.class.getName()); assertSame(message, this.resolver.resolveArgument(parameter, message)); }
@Override public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { Class<?> targetMessageType = parameter.getParameterType(); Class<?> targetPayloadType = getPayloadType(parameter); if (!targetMessageType.isAssignableFrom(message.getClass())) { throw new MethodArgumentTypeMismatchException(message, parameter, "Actual message type '" + ClassUtils.getDescriptiveType(message) + "' does not match expected type '" + ClassUtils.getQualifiedName(targetMessageType) + "'"); } Object payload = message.getPayload(); if (targetPayloadType.isInstance(payload)) { return message; } if (isEmptyPayload(payload)) { throw new MessageConversionException(message, "Cannot convert from actual payload type '" + ClassUtils.getDescriptiveType(payload) + "' to expected payload type '" + ClassUtils.getQualifiedName(targetPayloadType) + "' when payload is empty"); } payload = convertPayload(message, parameter, targetPayloadType); return MessageBuilder.createMessage(payload, message.getHeaders()); }
@Override protected List<? extends HandlerMethodArgumentResolver> initArgumentResolvers() { List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(); resolvers.add(new MessageMethodArgumentResolver(new SimpleMessageConverter())); resolvers.addAll(getCustomArgumentResolvers()); return resolvers; }
@Test public void resolveWithPayloadTypeAsWildcard() throws Exception { Message<String> message = MessageBuilder.withPayload("test").build(); MethodParameter parameter = new MethodParameter(this.method, 0); assertTrue(this.resolver.supportsParameter(parameter)); assertSame(message, this.resolver.resolveArgument(parameter, message)); }
protected List<HandlerMethodArgumentResolver> initArgumentResolvers() { List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>(); ConfigurableBeanFactory cbf = (this.beanFactory instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory) this.beanFactory : null); // Annotation-based argument resolution resolvers.add(new HeaderMethodArgumentResolver(this.conversionService, cbf)); resolvers.add(new HeadersMethodArgumentResolver()); // Type-based argument resolution resolvers.add(new MessageMethodArgumentResolver(this.messageConverter)); if (this.customArgumentResolvers != null) { resolvers.addAll(this.customArgumentResolvers); } resolvers.add(new PayloadArgumentResolver(this.messageConverter, this.validator)); return resolvers; }
@Test public void resolveWithMatchingPayloadType() throws Exception { Message<Integer> message = MessageBuilder.withPayload(123).build(); MethodParameter parameter = new MethodParameter(this.method, 1); assertTrue(this.resolver.supportsParameter(parameter)); assertSame(message, this.resolver.resolveArgument(parameter, message)); }