@SuppressWarnings("unchecked") public MethodInvokingSelector(Object object) { super(object instanceof MessageProcessor<?> ? (MessageProcessor<Boolean>) object : new MethodInvokingMessageProcessor<Boolean>(object, Filter.class)); }
public MethodInvokingMessageHandler(Object object, Method method) { Assert.isTrue(method.getReturnType().equals(void.class), "MethodInvokingMessageHandler requires a void-returning method"); this.processor = new MethodInvokingMessageProcessor<Object>(object, method); }
public MethodInvokingSelector(Object object, Method method) { super(new MethodInvokingMessageProcessor<Boolean>(object, method)); Class<?> returnType = method.getReturnType(); Assert.isTrue(boolean.class.isAssignableFrom(returnType) || Boolean.class.isAssignableFrom(returnType), "MethodInvokingSelector method must return a boolean result."); }
@Override public T processMessage(Message<?> message) { if (this.delegate == null) { Object target = this.beanFactory.getBean(this.beanName); MethodInvokingMessageProcessor<T> methodInvokingMessageProcessor = new MethodInvokingMessageProcessor<>(target, this.methodName); methodInvokingMessageProcessor.setBeanFactory(this.beanFactory); this.delegate = methodInvokingMessageProcessor; } return this.delegate.processMessage(message); }
@Test public void optionalAndRequiredWithAnnotatedMethod() throws Exception { AnnotatedTestService service = new AnnotatedTestService(); Method method = service.getClass().getMethod("optionalAndRequiredHeader", String.class, Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setUseSpelInvoker(true); optionalAndRequiredWithAnnotatedMethodGuts(processor, false); }
@Test public void optionalAndRequiredDottedWithAnnotatedMethod() throws Exception { AnnotatedTestService service = new AnnotatedTestService(); Method method = service.getClass().getMethod("optionalAndRequiredDottedHeader", String.class, Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setUseSpelInvoker(true); optionalAndRequiredDottedWithAnnotatedMethodGuts(processor, false); }
@Test(expected = MessageHandlingException.class) public void conversionFailureWithAnnotatedMethod() throws Exception { AnnotatedTestService service = new AnnotatedTestService(); Method method = service.getClass().getMethod("integerMethod", Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setBeanFactory(mock(BeanFactory.class)); processor.processMessage(new GenericMessage<>("foo")); }
@Test public void payloadWithAnnotatedMethod() throws Exception { AnnotatedTestService service = new AnnotatedTestService(); Method method = service.getClass().getMethod("integerMethod", Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setBeanFactory(mock(BeanFactory.class)); Object result = processor.processMessage(new GenericMessage<>(123)); assertEquals(123, result); }
@Test public void headerAnnotationWithExpression() throws Exception { Message<?> message = this.getMessage(); Method method = TestService.class.getMethod("headerAnnotationWithExpression", String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Object result = processor.processMessage(message); Assert.assertEquals("monday", result); }
@Test public void optionalHeader() throws Exception { Method method = TestService.class.getMethod("optionalHeader", Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Object result = processor.processMessage(new GenericMessage<>("foo")); assertNull(result); }
@Test public void testProcessMessageBadExpression() throws Exception { expected.expect(MessageHandlingException.class); AnnotatedTestService service = new AnnotatedTestService(); Method method = service.getClass().getMethod("integerMethod", Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setBeanFactory(mock(BeanFactory.class)); assertEquals("foo", processor.processMessage(new GenericMessage<>("foo"))); }
@Test public void messageSubclassAsMethodParameterAndMessageSubclassAsReturnValue() { MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new TestBean(), "acceptMessageSubclassAndReturnMessageSubclass"); processor.setBeanFactory(mock(BeanFactory.class)); Message<?> result = (Message<?>) processor.processMessage(new GenericMessage<String>("testing")); assertEquals("testing-6", result.getPayload()); }
@Test public void fromMessageToHyphenatedHeaderName() throws Exception { Method method = TestService.class.getMethod("headerNameWithHyphen", String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<?> message = MessageBuilder.withPayload("payload").setHeader("foo-bar", "abc").build(); Object result = processor.processMessage(message); assertEquals("ABC", result); }
@Test(expected = MessageHandlingException.class) public void requiredHeaderNotProvidedOnSecondMessage() throws Exception { Method method = TestService.class.getMethod("requiredHeader", Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<String> messageWithHeader = MessageBuilder.withPayload("foo") .setHeader("num", 123).build(); GenericMessage<String> messageWithoutHeader = new GenericMessage<>("foo"); processor.processMessage(messageWithHeader); processor.processMessage(messageWithoutHeader); }
@Test public void fromMessageWithOptionalAndRequiredHeaderAndBothHeadersProvided() throws Exception { Method method = TestService.class.getMethod("optionalAndRequiredHeader", String.class, Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); Message<String> message = MessageBuilder.withPayload("foo") .setHeader("num", 123) .setHeader("prop", "bar") .build(); Object result = processor.processMessage(message); assertEquals("bar123", result); }
@Test public void messageAsMethodParameterAndObjectAsReturnValue() { MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new TestBean(), "acceptMessageAndReturnObject"); processor.setBeanFactory(mock(BeanFactory.class)); Object result = processor.processMessage(new GenericMessage<String>("testing")); assertEquals("testing-3", result); }
@Test public void compiledOptionalAndRequiredDottedWithAnnotatedMethod() throws Exception { AnnotatedTestService service = new AnnotatedTestService(); Method method = service.getClass().getMethod("optionalAndRequiredDottedHeader", String.class, Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setUseSpelInvoker(true); DirectFieldAccessor compilerConfigAccessor = compileImmediate(processor); optionalAndRequiredDottedWithAnnotatedMethodGuts(processor, true); assertNotNull(TestUtils.getPropertyValue(processor, "delegate.handlerMethod.expression.compiledAst")); optionalAndRequiredDottedWithAnnotatedMethodGuts(processor, true); compilerConfigAccessor.setPropertyValue("compilerMode", SpelCompilerMode.OFF); }
@Test public void payloadAsMethodParameterAndObjectAsReturnValue() { MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new TestBean(), "acceptPayloadAndReturnObject"); processor.setBeanFactory(mock(BeanFactory.class)); Object result = processor.processMessage(new GenericMessage<String>("testing")); assertEquals("testing-1", result); }
@Test public void filterSelectsAnnotationMethodsOnly() { OverloadedMethodBean bean = new OverloadedMethodBean(); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(bean, ServiceActivator.class); processor.setBeanFactory(mock(BeanFactory.class)); processor.processMessage(MessageBuilder.withPayload(123).build()); assertNotNull(bean.lastArg); assertEquals(String.class, bean.lastArg.getClass()); assertEquals("123", bean.lastArg); }
@Test public void testIneligible() { IneligibleMethodBean bean = new IneligibleMethodBean(); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(bean, "foo"); processor.setBeanFactory(mock(BeanFactory.class)); processor.processMessage(MessageBuilder.withPayload("true").build()); assertNotNull(bean.lastArg); assertEquals(String.class, bean.lastArg.getClass()); assertEquals("true", bean.lastArg); }