INTEXT-96: The Java DSL initial implementation

JIRA: https://jira.springsource.org/browse/INTEXT-96

* `MessageChannels` Builder
* Configuration infrastructure
* `Pollers` Builder
* Initial `IntegrationFlows` Builder
* `EndpointConfigurer` Specs
* EIP-methods `from(MessageSource)`, `from(MessageChannel)`, `transform`, `filter`

spring-integration-java-dsl/src/test/java/org/springframework/integration/dsl/test/IntegrationFlowTests.java

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2014 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.integration.dsl.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.aopalliance.aop.Advice;
+import org.hamcrest.Matchers;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.Lifecycle;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.integration.MessageDispatchingException;
+import org.springframework.integration.channel.DirectChannel;
+import org.springframework.integration.channel.QueueChannel;
+import org.springframework.integration.config.EnableIntegration;
+import org.springframework.integration.core.MessageSource;
+import org.springframework.integration.dsl.IntegrationFlow;
+import org.springframework.integration.dsl.IntegrationFlows;
+import org.springframework.integration.dsl.channel.MessageChannels;
+import org.springframework.integration.dsl.support.Pollers;
+import org.springframework.integration.endpoint.MethodInvokingMessageSource;
+import org.springframework.integration.handler.advice.ExpressionEvaluatingRequestHandlerAdvice;
+import org.springframework.integration.scheduling.PollerMetadata;
+import org.springframework.integration.store.SimpleMessageStore;
+import org.springframework.integration.support.MessageBuilder;
+import org.springframework.integration.transformer.PayloadDeserializingTransformer;
+import org.springframework.integration.transformer.PayloadSerializingTransformer;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageDeliveryException;
+import org.springframework.messaging.PollableChannel;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+import org.springframework.test.context.support.AnnotationConfigContextLoader;
+
+/**
+ * @author Artem Bilan
+ */
+@ContextConfiguration(loader = AnnotationConfigContextLoader.class)
+@RunWith(SpringJUnit4ClassRunner.class)
+public class IntegrationFlowTests {
+
+	@Autowired
+	@Qualifier("flow1QueueChannel")
+	private PollableChannel outputChannel;
+
+	@Autowired
+	private DirectChannel inputChannel;
+
+	@Autowired
+	private PollableChannel successChannel;
+
+	@Autowired
+	private BeanFactory beanFactory;
+
+	@Test
+	public void testPollingFlow() {
+		for (int i = 0; i < 10; i++) {
+			Message<?> message = this.outputChannel.receive(5000);
+			assertNotNull(message);
+			assertEquals("" + i, message.getPayload());
+		}
+	}
+
+	@Test
+	public void testDirectFlow() {
+		assertTrue(this.beanFactory.containsBean("filter"));
+		assertTrue(this.beanFactory.containsBean("filter.handler"));
+		QueueChannel replyChannel = new QueueChannel();
+		Message<String> message = MessageBuilder.withPayload("100").setReplyChannel(replyChannel).build();
+		try {
+			this.inputChannel.send(message);
+			fail("Expected MessageDispatchingException");
+		}
+		catch (Exception e) {
+			assertThat(e, Matchers.instanceOf(MessageDeliveryException.class));
+			assertThat(e.getCause(), Matchers.instanceOf(MessageDispatchingException.class));
+			assertThat(e.getMessage(), Matchers.containsString("Dispatcher has no subscribers"));
+		}
+		this.beanFactory.getBean("payloadSerializingTransformer", Lifecycle.class).start();
+		this.inputChannel.send(message);
+		Message<?> reply = replyChannel.receive(5000);
+		assertNotNull(reply);
+		assertEquals(200, reply.getPayload());
+
+		Message<?> successMessage = this.successChannel.receive(5000);
+		assertNotNull(successMessage);
+		assertEquals(100, successMessage.getPayload());
+	}
+
+
+	@Configuration
+	@EnableIntegration
+	public static class ContextConfiguration {
+
+		@Bean
+		public MessageSource<?> integerMessageSource() {
+			MethodInvokingMessageSource source = new MethodInvokingMessageSource();
+			source.setObject(new AtomicInteger());
+			source.setMethodName("getAndIncrement");
+			return source;
+		}
+
+		@Bean
+		public IntegrationFlow flow1() {
+			return IntegrationFlows.from(this.integerMessageSource(), Pollers.fixedRate(100).get())
+					.transform("payload.toString()")
+					.channel(MessageChannels.queue().id("flow1QueueChannel").get())
+					.get();
+		}
+
+		@Bean
+		public DirectChannel inputChannel() {
+			return MessageChannels.direct().get();
+		}
+
+		@Bean
+		public QueueChannel successChannel() {
+			return MessageChannels.queue().get();
+		}
+
+		@Bean(name = PollerMetadata.DEFAULT_POLLER_METADATA_BEAN_NAME)
+		public PollerMetadata poller() {
+			return Pollers.fixedRate(500).get();
+		}
+
+		@Bean
+		public Advice expressionAdvice() {
+			ExpressionEvaluatingRequestHandlerAdvice advice = new ExpressionEvaluatingRequestHandlerAdvice();
+			advice.setOnSuccessExpression("payload");
+			advice.setSuccessChannel(this.successChannel());
+			return advice;
+		}
+
+		@Bean
+		public IntegrationFlow flow2() {
+			return IntegrationFlows.from(this.inputChannel())
+					.filter(p -> p instanceof String, c -> c.id("filter"))
+					.<String, Integer>transform(Integer::parseInt)
+					.transform(new PayloadSerializingTransformer(),
+							c -> c.autoStartup(false).id("payloadSerializingTransformer"))
+					.channel(MessageChannels.queue(new SimpleMessageStore(), "fooQueue").get())
+					.transform(new PayloadDeserializingTransformer())
+					.transform((Integer p) -> p * 2, c -> c.advice(this.expressionAdvice()))
+					.get();
+		}
+
+	}
+
+}