@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); }
@Override public Object getCorrelationKey(Message<?> message) { return this.processor.processMessage(message); }
@Override public boolean isRunning() { return this.processor.isRunning(); }
@Test(expected = MessageHandlingException.class) public void requiredHeaderNotProvided() throws Exception { Method method = TestService.class.getMethod("requiredHeader", Integer.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(testService, method); processor.setBeanFactory(mock(BeanFactory.class)); processor.processMessage(new GenericMessage<>("foo")); }
@SuppressWarnings("unchecked") public MethodInvokingSelector(Object object) { super(object instanceof MessageProcessor<?> ? (MessageProcessor<Boolean>) object : new MethodInvokingMessageProcessor<Boolean>(object, Filter.class)); }
@Test public void testProcessMessageMethodNotFound() throws Exception { expected.expect(new ExceptionCauseMatcher(SpelEvaluationException.class)); TestDifferentErrorService service = new TestDifferentErrorService(); Method method = TestErrorService.class.getMethod("checked", String.class); MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(service, method); processor.setUseSpelInvoker(true); processor.setBeanFactory(mock(BeanFactory.class)); processor.processMessage(new GenericMessage<>("foo")); }
@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 testCollectionIsConverted() { DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory(); DefaultConversionService conversionService = new DefaultConversionService(); conversionService.addConverter(new Converter<Foo, Bar>() { // Must be explicit type with generics @Override public Bar convert(Foo source) { return new Bar(); } }); BeanFactoryTypeConverter typeConverter = new BeanFactoryTypeConverter(conversionService); beanFactory.setConversionService(conversionService); typeConverter.setBeanFactory(beanFactory); Service service = new Service(); MethodInvokingMessageProcessor<Service> processor = new MethodInvokingMessageProcessor<>(service, "handle"); processor.setConversionService(conversionService); processor.setUseSpelInvoker(true); processor.setBeanFactory(beanFactory); ServiceActivatingHandler handler = new ServiceActivatingHandler(processor); QueueChannel replyChannel = new QueueChannel(); handler.setOutputChannel(replyChannel); handler.handleMessage(new GenericMessage<Collection<Foo>>(Collections.singletonList(new Foo()))); Message<?> message = replyChannel.receive(10000); assertNotNull(message); assertEquals("baz", message.getPayload()); }
public void testHandlerInheritanceMethodImplInSubClassAndSuper() { class A { @SuppressWarnings("unused") public Message<String> myMethod(Message<String> msg) { return MessageBuilder.fromMessage(msg).setHeader("A", "A").build(); } } class B extends A { } class C extends B { @Override public Message<String> myMethod(Message<String> msg) { return MessageBuilder.fromMessage(msg).setHeader("C", "C").build(); } } MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new C(), "myMethod"); Message<?> message = (Message<?>) processor.processMessage(new GenericMessage<>("")); assertEquals("C", message.getHeaders().get("C")); }
private void optionalAndRequiredWithAnnotatedMethodGuts(MethodInvokingMessageProcessor processor, boolean compiled) { processor.setBeanFactory(mock(BeanFactory.class)); Message<String> message = MessageBuilder.withPayload("foo") .setHeader("num", 42) .build(); Object result = processor.processMessage(message); assertEquals("null42", result); message = MessageBuilder.withPayload("foo") .setHeader("prop", "bar") .setHeader("num", 42) .build(); result = processor.processMessage(message); assertEquals("bar42", result); message = MessageBuilder.withPayload("foo") .setHeader("prop", "bar") .build(); try { result = processor.processMessage(message); fail("Expected MessageHandlingException"); } catch (MessageHandlingException e) { if (compiled) { assertThat(e.getCause().getMessage(), equalTo("required header not available: num")); } else { assertThat(e.getCause().getCause().getMessage(), equalTo("required header not available: num")); } } }
@Override public void setBeanFactory(BeanFactory beanFactory) throws BeansException { if (beanFactory != null) { this.processor.setBeanFactory(beanFactory); } }
@Override public void start() { this.processor.start(); }
@Override public void stop() { this.processor.stop(); }
@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")); }
@SuppressWarnings("unchecked") public MethodInvokingSplitter(Object object) { super(object instanceof MessageProcessor<?> ? (MessageProcessor<Collection<?>>) object : new MethodInvokingMessageProcessor<Collection<?>>(object, Splitter.class)); }
@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); }
public void testHandlerInheritanceMethodImplInSubClass() { class A { @SuppressWarnings("unused") public Message<String> myMethod(Message<String> msg) { return MessageBuilder.fromMessage(msg).setHeader("A", "A").build(); } } class B extends A { @Override public Message<String> myMethod(Message<String> msg) { return MessageBuilder.fromMessage(msg).setHeader("B", "B").build(); } } class C extends B { @Override public Message<String> myMethod(Message<String> msg) { return MessageBuilder.fromMessage(msg).setHeader("C", "C").build(); } } MethodInvokingMessageProcessor processor = new MethodInvokingMessageProcessor(new C(), "myMethod"); Message<?> message = (Message<?>) processor.processMessage(new GenericMessage<>("")); assertEquals("C", message.getHeaders().get("C")); }
private void optionalAndRequiredDottedWithAnnotatedMethodGuts(MethodInvokingMessageProcessor processor, boolean compiled) { processor.setBeanFactory(mock(BeanFactory.class)); Message<String> message = MessageBuilder.withPayload("hello") .setHeader("dot2", new DotBean()) .build(); Object result = processor.processMessage(message); assertEquals("null42", result); message = MessageBuilder.withPayload("hello") .setHeader("dot1", new DotBean()) .setHeader("dot2", new DotBean()) .build(); result = processor.processMessage(message); assertEquals("bar42", result); message = MessageBuilder.withPayload("hello") .setHeader("dot1", new DotBean()) .build(); try { result = processor.processMessage(message); fail("Expected MessageHandlingException"); } catch (MessageHandlingException e) { if (compiled) { assertThat(e.getCause().getMessage(), equalTo("required header not available: dot2")); } else { // interpreted assertThat(e.getCause().getCause().getMessage(), equalTo("required header not available: dot2")); } } }
@Override public void setBeanFactory(BeanFactory beanFactory) { super.setBeanFactory(beanFactory); this.processor.setBeanFactory(beanFactory); }
@Override public void start() { this.processor.start(); }