Spring Integration Java DSL (pre Java 8): Line by Line Tutorial
Join the DZone community and get the full member experience.
Join For FreeOriginally written by Artem Bilan on the SpringSource blog.
Dear Spring Community!
Recently we published the Spring Integration Java DSL: Line by line tutorial, which uses Java 8 Lambdas extensively. We received some feedback that this is good introduction to the DSL, but a similar tutorial is needed for those users, who can't move to the Java 8 or aren't yet familiar with Lambdas
, but wish to take advantage
So, to help those Spring Integration users who want to moved from XML configuration to Java & Annotation configuration, we provide this line-by-line tutorial
to demonstrate that, even without Lambdas
, we gain a lot from Spring Integration Java DSL usage. Although, most will agree that the lambda syntax provides for a more succinct definition.
We analyse here the same Cafe Demo sample, but using the pre Java 8 variant for configuration. Many options are the same, so we just copy/paste their description here to achieve a complete picture. Since this Spring Integration Java DSL configuration is quite different to the Java 8 lambda style, it will be useful for all users to get a knowlage how we can achieve the same result with a rich variety of options provided by the Spring Integration Java DSL.
The source code for our application is placed in a single class, which is a Boot
application; significant lines are annotated with a number corresponding to the comments, which follow:
@SpringBootApplication // 1 @IntegrationComponentScan // 2 public class Application { public static void main(String[] args) throws Exception { ConfigurableApplicationContext ctx = SpringApplication.run(Application.class, args); // 3 Cafe cafe = ctx.getBean(Cafe.class); // 4 for (int i = 1; i <= 100; i++) { // 5 Order order = new Order(i); order.addItem(DrinkType.LATTE, 2, false); order.addItem(DrinkType.MOCHA, 3, true); cafe.placeOrder(order); } System.out.println("Hit 'Enter' to terminate"); // 6 System.in.read(); ctx.close(); } @MessagingGateway // 7 public interface Cafe { @Gateway(requestChannel = "orders.input") // 8 void placeOrder(Order order); // 9 } private final AtomicInteger hotDrinkCounter = new AtomicInteger(); private final AtomicInteger coldDrinkCounter = new AtomicInteger(); // 10 @Autowired private CafeAggregator cafeAggregator; // 11 @Bean(name = PollerMetadata.DEFAULT_POLLER) public PollerMetadata poller() { // 12 return Pollers.fixedDelay(1000).get(); } @Bean @SuppressWarnings("unchecked") public IntegrationFlow orders() { // 13 return IntegrationFlows.from("orders.input") // 14 .split("payload.items", (Consumer) null) // 15 .channel(MessageChannels.executor(Executors.newCachedThreadPool()))// 16 .route("payload.iced", // 17 new Consumer<RouterSpec<ExpressionEvaluatingRouter>>() { // 18 @Override public void accept(RouterSpec<ExpressionEvaluatingRouter> spec) { spec.channelMapping("true", "iced") .channelMapping("false", "hot"); // 19 } }) .get(); // 20 } @Bean public IntegrationFlow icedFlow() { // 21 return IntegrationFlows.from(MessageChannels.queue("iced", 10)) // 22 .handle(new GenericHandler<OrderItem>() { // 23 @Override public Object handle(OrderItem payload, Map<String, Object> headers) { Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); System.out.println(Thread.currentThread().getName() + " prepared cold drink #" + coldDrinkCounter.incrementAndGet() + " for order #" + payload.getOrderNumber() + ": " + payload); return payload; // 24 } }) .channel("output") // 25 .get(); } @Bean public IntegrationFlow hotFlow() { // 26 return IntegrationFlows.from(MessageChannels.queue("hot", 10)) .handle(new GenericHandler<OrderItem>() { @Override public Object handle(OrderItem payload, Map<String, Object> headers) { Uninterruptibles.sleepUninterruptibly(5, TimeUnit.SECONDS); // 27 System.out.println(Thread.currentThread().getName() + " prepared hot drink #" + hotDrinkCounter.incrementAndGet() + " for order #" + payload.getOrderNumber() + ": " + payload); return payload; } }) .channel("output") .get(); } @Bean public IntegrationFlow resultFlow() { // 28 return IntegrationFlows.from("output") // 29 .transform(new GenericTransformer<OrderItem, Drink>() { // 30 @Override public Drink transform(OrderItem orderItem) { return new Drink(orderItem.getOrderNumber(), orderItem.getDrinkType(), orderItem.isIced(), orderItem.getShots()); // 31 } }) .aggregate(new Consumer<AggregatorSpec>() { // 32 @Override public void accept(AggregatorSpec aggregatorSpec) { aggregatorSpec.processor(cafeAggregator, null); // 33 } }, null) .handle(CharacterStreamWritingMessageHandler.stdout()) // 34 .get(); } @Component public static class CafeAggregator { // 35 @Aggregator // 36 public Delivery output(List<Drink> drinks) { return new Delivery(drinks); } @CorrelationStrategy // 37 public Integer correlation(Drink drink) { return drink.getOrderNumber(); } } }
Examining the code line by line...
@SpringBootApplication
This new meta-annotation from Spring Boot 1.2. Includes @Configuration
and@EnableAutoConfiguration
. Since we are in a Spring Integration application and Spring Boot has auto-configuration for it, the @EnableIntegration
is automatically applied, to initialize the Spring Integration infrastructure including an environment for the Java DSL -DslIntegrationConfigurationInitializer
, which is picked up by theIntegrationConfigurationBeanFactoryPostProcessor
from /META-INF/spring.factories
.
@IntegrationComponentScan
The Spring Integration analogue of @ComponentScan
to scan components based on interfaces, (the Spring Framework's @ComponentScan
only looks at classes). Spring Integration supports the discovery of interfaces annotated with @MessagingGateway
(see #7 below).
ConfigurableApplicationContext ctx = SpringApplication.run(Application.class, args);
The main
method of our class is designed to start the Spring Boot application using the configuration from this class and starts an ApplicationContext
via Spring Boot. In addition, it delegates command line arguments to the Spring Boot. For example you can specify --debug
to see logs for the boot auto-configuration report.
Cafe cafe = ctx.getBean(Cafe.class);
Since we already have an ApplicationContext
we can start to interact with application. AndCafe
is that entry point - in EIP terms a gateway
. Gateways are simply interfaces and the application does not interact with the Messaging API; it simply deals with the domain (see #7 below).
for (int i = 1; i <= 100; i++) {
To demonstrate the cafe "work" we intiate 100 orders with two drinks - one hot and one iced. And send the Order
to the Cafe
gateway.
System.out.println("Hit 'Enter' to terminate");
Typically Spring Integration application are asynchronous, hence to avoid early exit from themain
Thread we block the main
method until some end-user interaction through the command line. Non daemon threads will keep the application open but System.read()
provides us with a mechanism to close the application cleanly.
@MessagingGateway
The annotation to mark a business interface to indicate it is a gateway
between the end-application and integration layer. It is an analogue of <gateway />
component from Spring Integration XML configuration. Spring Integration creates a Proxy
for this interface and populates it as a bean in the application context. The purpose of this Proxy
is to wrap parameters in a Message<?>
object and send it to the MessageChannel
according to the provided options.
@Gateway(requestChannel = "orders.input")
The method level annotation to distinct business logic by methods as well as by the target integration flows. In this sample we use a requestChannel
reference of orders.input
, which is a MessageChannel
bean name of our IntegrationFlow
input channel (see below #14).
void placeOrder(Order order);
The interface method is a central point to interact from end-application with the integration layer. This method has a void
return type. It means that our integration flow is one-way
and we just send messages to the integration flow, but don't wait for a reply.
private AtomicInteger hotDrinkCounter = new AtomicInteger(); private AtomicInteger coldDrinkCounter = new AtomicInteger();
Two counters to gather the information how our cafe works with drinks.
@Autowired private CafeAggregator cafeAggregator;
The POJO for the Aggregator
logic (see #33 and #35 below). Since it is a Spring bean, we can simply inject it even to the current @Configuration
and use in any place below, e.g. from the .aggregate()
EIP-method.
@Bean(name = PollerMetadata.DEFAULT_POLLER) public PollerMetadata poller() {
The default
poller
bean. It is a analogue of <poller default="true">
component from Spring Integration XML configuration. Required for endpoints where the inputChannel
is a PollableChannel
. In this case, it is necessary for the two Cafe queues
- hot and iced (see below #18). Here we use the Pollers
factory from the DSL project and use its method-chain fluent API to build the poller metadata. Note that Pollers
can be used directly from an IntegrationFlow
definition, if a specific poller
(rather than the default poller) is needed for an endpoint.
@Bean public IntegrationFlow orders() {
The IntegrationFlow
bean definition. It is the central component of the Spring Integration Java DSL, although it does not play any role at runtime, just during the bean registration phase. All other code below registers Spring Integration components (MessageChannel
,MessageHandler
, EventDrivenConsumer
, MessageProducer
, MessageSource
etc.) in theIntegrationFlow
object, which is parsed by the IntegrationFlowBeanPostProcessor
to process those components and register them as beans in the application context as necessary (some elements, such as channels may already exist).
return IntegrationFlows.from("orders.input")
The IntegrationFlows
is the main factory
class to start the IntegrationFlow
. It provides a number of overloaded .from()
methods to allow starting a flow from aSourcePollingChannelAdapter
for a MessageSource<?>
implementations, e.g.JdbcPollingChannelAdapter
; from a MessageProducer
, e.g.WebSocketInboundChannelAdapter
; or simply a MessageChannel
. All ".from()" options have several convenient variants to configure the appropriate component for the start of theIntegrationFlow
. Here we use just a channel name, which is converted to aDirectChannel
bean definition during the bean definition phase while parsing theIntegrationFlow
. In the Java 8 variant, we used here a Lambda definition
- and thisMessageChannel
has been implicitly created with the bean name based on theIntegrationFlow
bean name.
.split("payload.items", (Consumer) null)
Since our integration flow accepts messages through the orders.input
channel, we are ready to consume and process them. The first EIP-method in our scenario is .split()
. We know that the message payload
from orders.input
channel is an Order
domain object, so we can simply use here a Spring (SpEL) Expression to return Collection<OrderItem>
. So, this performs the split
EI pattern, and we send each collection entry as a separate message to the next channel. In the background, the .split()
method registers aExpressionEvaluatingSplitter
MessageHandler
implementation and anEventDrivenConsumer
for that MessageHandler
, wiring in the orders.input
channel as the inputChannel
.
The second argument for the .split()
EIP-method is for an endpointConfigurer
to customize options like autoStartup
, requiresReply
, adviceChain
etc. We use herenull
to show that we rely on the default options for the endpoint. Many of EIP-methods provide overloaded versions with and without endpointConfigurer
. Currently.split(String expression)
EIP-method without the endpointConfigurer
argument is not available; this will be addressed in a future release.
.channel(MessageChannels.executor(Executors.newCachedThreadPool()))
The .channel()
EIP-method allows the specification of concrete MessageChannel
s between endpoints, as it is done via output-channel
/input-channel
attributes pair with Spring Integration XML configuration. By default, endpoints in the DSL integration flow definition are wired with DirectChannel
s, which get bean names based on theIntegrationFlow
bean name and index
in the flow chain. In this case we select a specificMessageChannel
implementation from the Channels
factory class; the selected channel here is an ExecutorChannel
, to allow distribution of messages from the splitter
to separate Thread
s, to process them in parallel in the downstream flow.
.route("payload.iced",
The next EIP-method in our scenario is .route()
, to send hot/iced
order items to different Cafe kitchens. We again use here a SpEL expression to get the routingKey
from the incoming message. In the Java 8 variant, we used a method-reference
Lambda expression, but for pre Java 8 style we must use SpEL or an inline interface implementation. Many anonymous classes in a flow can make the flow difficult to read so we prefer SpEL in most cases.
new Consumer<RouterSpec<ExpressionEvaluatingRouter>>() {
The second argument of .route()
EIP-method is a functional interface Consumer
to specify ExpressionEvaluatingRouter
options using a RouterSpec
Builder. Since we don't have any choice with pre Java 8, we just provide here an inline implementation for this interface.
spec.channelMapping("true", "iced") .channelMapping("false", "hot");
With the Consumer<RouterSpec<ExpressionEvaluatingRouter>>#accept()
implementation we can provide desired AbstractMappingMessageRouter
options. One of them is channelMappings
, when we specify the routing logic by the result of router expresion and the target MessageChannel
for the apropriate result. In this case iced
andhot
are MessageChannel
names for IntegrationFlow
s below.
.get();
This finalizes the flow. Any IntegrationFlows.from()
method returns anIntegrationFlowBuilder
instance and this get()
method extracts an IntegrationFlow
object from the IntegrationFlowBuilder
configuration. Everything starting from the.from()
and up to the method before the .get()
is an IntegrationFlow
definition. All defined components are stored in the IntegrationFlow
and processed by theIntegrationFlowBeanPostProcessor
during the bean creation phase.
@Bean public IntegrationFlow icedFlow() {
This is the second IntegrationFlow
bean definition - for iced
drinks. Here we demonstrate that several IntegrationFlow
s can be wired together to create a single complex application. Note: it isn't recommended to inject one IntegrationFlow
to another; it might cause unexpected behaviour. Since they provide Integration components for the bean registration and MessageChannel
s one of them, the best way to wire and inject is viaMessageChannel
or @MessagingGateway
interfaces.
return IntegrationFlows.from(MessageChannels.queue("iced", 10))
The iced
IntegrationFlow
starts from a QueueChannel
that has a capacity of 10
messages; it is registered as a bean with the name iced
. As you remember we use this name as one of the route mappings (see above #19).
In our sample, we use here a restricted QueueChannel
to reflect the Cafe kitchen busy state from real life. And here is a place where we need that global poller
for the next endpoint which is listening on this channel.
.handle(new GenericHandler<OrderItem>() {
The .handle()
EIP-method of the iced
flow demonstrates the concrete Cafe kitchen work. Since we can't minimize the code with something like Java 8 Lambda expression, we provide here an inline implementation for the GenericHandler
functional interface with the expected payload
type as the generic argument. With the Java 8 example, we distribute this.handle()
between several subscriber subflows for a PublishSubscribeChannel
. However in this case, the logic is all implemented in the one method.
Uninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS); System.out.println(Thread.currentThread().getName() + " prepared cold drink #" + coldDrinkCounter.incrementAndGet() + " for order #" + payload.getOrderNumber() + ": " + payload); return payload;
The business logic implementation for the current .handle()
EIP-component. WithUninterruptibles.sleepUninterruptibly(1, TimeUnit.SECONDS);
we just block the current Thread
for some timeout to demonstrate how quickly the Cafe kitchen prepares a drink. After that we just report to STDOUT
that the drink is ready and return the currentOrderItem
from the GenericHandler
for the next endpoint in our IntegrationFlow
. In the background, the DSL framework registers a ServiceActivatingHandler
for theMethodInvokingMessageProcessor
to invoke the GenericHandler#handle
at runtime. In addition, the framework registers a PollingConsumer
endpoint for the QueueChannel
above. This endpoint relies on the default poller
to poll messages from the queue. Of course, we always can use a specific poller
for any concrete endpoint. In that case, we would have to provide a second endpointConfigurer
argument to the .handle()
EIP-method.
.channel("output")
Since it is not the end of our Cafe scenario, we send the result of the current flow to theoutput
channel using the convenient EIP-method .channel()
and the name of theMessageChannel
bean (see below #29). This is the logical end of the current iced drink subflow, so we use the .get()
method to return the IntegrationFlow
. Flows that end with a reply-producing handler that don't have a final .channel()
will return the reply to the message replyChannel
header.
@Bean public IntegrationFlow hotFlow() {
The IntegrationFlow
definition for hot
drinks. It is similar to the previous iced
drinks flow, but with specific hot
business logic. It starts from the hot
QueueChannel
which is mapped from the router above.
Uninterruptibles.sleepUninterruptibly(5, TimeUnit.SECONDS);
The sleepUninterruptibly
for hot
drinks. Right, we need more time to boil the water!
@Bean public IntegrationFlow resultFlow() {
One more IntegrationFlow
bean definition to prepare the Delivery
for the Cafe client based on the Drink
s.
return IntegrationFlows.from("output")
The resultFlow
starts from the DirectChannel
, which is created during the bean definition phase with this provided name. You should remember that we use the output
channel name from the Cafe kitchens flows in the last .channel()
in those definitions.
.transform(new GenericTransformer<OrderItem, Drink>() {
The .transform()
EIP-method is for the appropriate pattern implementation and expects some object to convert one payload to another. In our sample we use an inline implementation of the GenericTransformer
functional interface to convert OrderItem
to Drink
and we specify that using generic arguments. In the background, the DSL framework registers aMessageTransformingHandler
and an EventDrivenConsumer
endpoint with default options to consume messages from the output
MessageChannel
.
public Drink transform(OrderItem orderItem) { return new Drink(orderItem.getOrderNumber(), orderItem.getDrinkType(), orderItem.isIced(), orderItem.getShots()); }
The business-specific GenericTransformer#transform()
implementation to demonstrate how we benefit from Java Generics to transform one payload
to another. Note: Spring Integration uses ConversionService
before any method invocation and if you provide some specific Converter
implementation, some domain payload
can be converted to another automatically, when the framework has an appropriate registered Converter
.
.aggregate(new Consumer<AggregatorSpec>() {
The .aggregate()
EIP-method provides options to configure anAggregatingMessageHandler
and its endpoint, similar to what we can do with the<aggregator>
component when using Spring Integration XML configuration. Of course, with the Java DSL we have more power to configure the aggregator in place, without any other extra beans. However we demonstrate here an aggregator configuration with annotations (see below #35). From the Cafe business logic perspective we compose the Delivery
for the initial Order
, since we .split()
the original order to the OrderItem
s near the beginning.
public void accept(AggregatorSpec aggregatorSpec) { aggregatorSpec.processor(cafeAggregator, null); }
An inline implementation of the Consumer
for the AggregatorSpec
. Using theaggregatorSpec
Builder we can provide desired options for the aggregator
component, which will be registered as an AggregatingMessageHandler
bean. Here we just provide theprocessor
as a reference to the autowired (see #11 above) CafeAggregator
component (see #35 below). The second argument of the .processor()
option is methodName
. Since we are relying on the aggregator annotation configuration for the POJO, we don't need to provide the method here and the framework will determine the correct POJO methods in the background.
.handle(CharacterStreamWritingMessageHandler.stdout())
It is the end of our flow - the Delivery
is delivered to the client! We just print here the message payload
to STDOUT using out-of-the-boxCharacterStreamWritingMessageHandler
from Spring Integration Core. This is a case to show how existing components from Spring Integration Core (and its modules) can be used from the Java DSL.
@Component public static class CafeAggregator {
The bean to specify the business logic for the aggregator
above. This bean is picked up by the @ComponentScan
, which is a part of the @SpringBootApplication
meta-annotation (see above #1). So, this component becomes a bean and we can automatically wire (@Autowired
) it to other components in the application context (see #11 above).
@Aggregator public Delivery output(List<Drink> drinks) { return new Delivery(drinks); }
The POJO-specific MessageGroupProcessor
to build the output payload
based on the payloads from aggregated messages. Since we mark this method with the @Aggregator
annotation, the target AggregatingMessageHandler
can extract this method for theMethodInvokingMessageGroupProcessor
.
@CorrelationStrategy public Integer correlation(Drink drink) { return drink.getOrderNumber(); }
The POJO-specific CorrelationStrategy
to extract the custom correlationKey
from each inbound aggregator message. Since we mark this method with @CorrelationStrategy
annotation the target AggregatingMessageHandler
can extract this method for theMethodInvokingCorrelationStrategy
. There is a similar self-explained@ReleaseStrategy
annotation, but we rely in our Cafe sample just on the defaultSequenceSizeReleaseStrategy
, which is based on the sequenceDetails
message header populated by the splitter
from the beginning of our integration flow.
Well, we have finished describing the Cafe Demo sample based on the Spring Integration Java DSL when Java Lambda support is not available. Compare it with XML sample and also seeLambda support tutorial to get more information regarding Spring Integration.
As you can see, using the DSL without lambdas is a little more verbose because you need to provide boilerplate code for inline anonymous implementations of functional interfaces. However, we believe it is important to support the use of the DSL for users who can't yet move to Java 8. Many of the DSL benefits (fluent API, compile-time validation etc) are available for all users.
The use of lambdas continues the Spring Framework tradition of reducing or eliminating boilerplate code, so we encourage users to try Java 8 and lambdas and to encourage their organizations to consider allowing the use of Java 8 for Spring Integration applications.
In addition see the Reference Manual for more information.
As always, we look forward to your comments and feedback (StackOverflow (spring-integration
tag), Spring JIRA, GitHub) and we very much welcome contributions!
Thank you for your time and patience to read this!
Published at DZone with permission of Pieter Humphrey, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.
Comments