This document discusses EAI (Enterprise Application Integration) patterns using Spring Integration. It provides an overview of messaging, pipes and filters, and common EAI patterns. It then demonstrates how Spring Integration implements these patterns through its API, with an emphasis on messaging channels. Examples are given for sending and receiving JMS, AMQP, HTTP, and email messages. Common patterns like filtering, routing, splitting, and aggregating messages are also explained.

1. EAI Patterns with Spring Integration
Oliver Gierke, Engineer
SpringSource, a division of VMware
NOT CONFIDENTIAL - TELL EVERYONE

2. About Me
Oliver Gierke
SpringSource
Spring Data
ogierke@vmware.com
www.olivergierke.de
olivergierke
2

3. Agenda
• What is EAI?
• Messaging
• Pipes and Filters
• EAI Patterns
• Spring Integration 2.0
• Spring Integration 2.1
3

4. What is EAI?
4

5. (Don’t try this at home)
5

6. A Better Solution: Spring Integration
• Spring Integration Brings EAI
To Your Application
• not the other way ‘round
• Provides the best support for
“Enterprise Integration
Patterns”
• patterns are built right into the
API
• Heavy Emphasis on
“channels”
• other solutions omit this key
concept
6

7. Messaging
• Integrates two different systems
• Different parties need to share the same data contract
• Not the same service contract
• Fault tolerant, since requests are enqueued and delivered as possible
• AMQP, JMS provide powerful, robust options
7

8. Messaging
8

9. Data Processing with Spring: Integration
• Messaging works by decoupling systems
• The Spring messaging machinery lets you react to messages,
declaratively
• Spring Integration takes this approach to the next level
?
Events
?
9

10. Data Processing with Spring: Messaging
• JMS
• Standard in the Java space
• Lots of open source options
• Provided with Java EE application servers
• Spring JMS
10

11. Data Processing with Spring: Messaging
Java producers Message broker Java consumers
C
P queue
C
P queue
C
11

12. JMS
• Sending JMS Messages
• Inject an instance of Spring's JmsTemplate.
• Provide the JMS ConnectionFactory in the JmsTemplate bean
definition.
12

13. JMS
@Component public class MessageSender {
@Autowired private JmsTemplate jmsTemplate;
public void send(String message) {
this.jmsTemplate.convertAndSend("example.queue", message);
}
}
@Bean public ConnnectionFactory cf (){
return new CachingConnectionFactory(...);
}
@Bean public JmsTemplate template(){
return new JmsTemplate(this.cf()) ;
}
13

14. Data Processing with Spring: Messaging
• AMQP
• Real standard
• A product of the the companies with the most mission critical
requirements
• Spring AMQP
1

15. Data Processing with Spring: Messaging
AMQP producers exchanges Message broker AMQP consumers
C
P X queue
C
P X queue
C
1

16. AMQP
• Sending AMQP Messages
• Use AmqpTemplate instead of JmsTemplate (accepts exchange and
routingKey).
• Nothing changes on the listener side (just a POJO).
@Component public class MessageSender {
@Autowired
private AmqpTemplate amqpTemplate;
public void send(String message) {
this.amqpTemplate.convertAndSend(
"myExchange", "some.routing.key", message);
}
}
16

17. HTTP
• HTTP Messaging (Request/Reply)
• Use RestTemplate, passing URI to methods based on HTTP methods
• Configure HttpMessageConverters if out-of-the-box support is
insufficient
17

18. HTTP
public class HttpClient {
private final String uri = “http://localhost/demo/{name}”;
private final RestTemplate template = new RestTemplate();
public String getResource(String name) {
this.template.getForObject(uri, String.class, name);
}
public URI postResource(String name, Object resource) {
this.template.postForLocation(uri, resource, name);
}
}
18

19. Mail
• Sending Mail Messages
• Create a SimpleMailMessage instance (or JavaMail MimeMessage).
• Use MailSender (or JavaMailSender) configured with host/user/
password, etc.
@Component public class MailClient {
@Autowired private MailSender mailSender;
public void send(String subject, String to, String text) {
SimpleMailMessage message = new SimpleMailMessage();
message.setSubject(subject);
message.setTo(to);
message.setText(text);
this.mailSender.send(message);
}
}
19

20. Pipes and Filters
20

21. Pipes and Filters
• Messaging
• Payload can be any object
• Header values are stored in a Map
21

22. Pipes and Filters
• Message and Headers
public interface Message<T> {
MessageHeaders getHeaders();
T getPayload();
}
Message<String> m1 = MessageBuilder.withPayload(“foo”)
.setHeader(“itemId”, 123).build();
Message<String> m2 = MessageBuilder.fromMessage(m1)
.setHeader(“itemId”, 456).build();
MessageHeaders headers = message.getHeaders();
long timestamp = headers.getTimestamp();
String value = headers.get(“someKey”, String.class);
22

23. Pipes and Filters
• Message channel
• Decouples Producers from Consumers
• Provides extension point for interceptors
• May be Point-to-Point
• Or Publish/Subscribe
23

24. Pipes and Filters
• Message channel Types
<channel id="sync-p2p"/>
<channel id="async-p2p">
<dispatcher task-executor="someThreadPool" />
</channel>
<channel id="async-buffering-p2p">
<queue capacity="50" />
</channel>
<publish-subscribe-channel id="sync-pubsub" />
<publish-subscribe-channel id="async-pubsub"
task-executor="someThreadPool" />
24

25. Pipes and Filters
• Sending Messages
public interface MessageChannel {
boolean send(Message<?> message);
boolean send(Message<?> message, long timeout);
}
MessagingTemplate template = new MessagingTemplate();
template.send(someChannel, message);
template.send(“fooChannel”, message);
template.convertAndSend(someChannel, “hello”);
template.convertAndSend(“fooChannel”, someObject);
template.setSendTimeout(5000);
template.setDefaultChannel(someChannel);
template.convertAndSend(someObject);
25

26. Pipes and Filters
• Receiving Messages
• Inversion of Control
• Endpoints delegate to Spring-managed objects
• Framework handles message reception and method invocation (including
conversion)
• Similar but more abstract than Spring JMS
• Clean separation of Code and Configuration
<service-activator input-channel="requests"
ref="loanBroker" method="processRequest"
output-channel="quotes"/>
@Component public class LoanBroaker {
public Message<Quote> processRequest( Message<Loan> loan) {
}
}
26

27. „Hello World“
27

28. Pipes and Filters
• Message Endpoint
• Producers send Messages to a MessageChannel
• Depending on their type, MessageChannels may have
PollingConsumers
• Or Event-Driven Consumers
28

29. Enterprise
Integration Patterns
29

30. Message Endpoint Types
• Transformer
• Convert payload or modify headers
• Filter
• Discard messages based on boolean evaluation
• Router
• Determine next channel based on content
• Splitter
• Generate multiple messages from one
• Aggregator
• Assemble a single message from multiple
30

31. Filtering and Routing
• Filter returns a boolean
• Router returns a channel name (or map key)
• Other routers included out of the box:
• recipient-list
• payload-type <filter input-channel="customers"
ref="customerRegistry"
• header-value,
method="isVip"
• xpath, ... output-channel="vips"
discard-channel="nonVips"/>
<router input-channel="customers"
ref="customerRegistry"
method="getStatus">
<mapping value="1" channel="platinum"/>
</router>
31

32. OddEven
32

33. Splitting and Aggregating
• Splitter returns a Collection or Array
• Aggregator accepts a Collection or Array
<splitter input-channel="orders"
ref="orderRepository"
method="getLineItems"
output-channel="lineItems"/>
• Default Splitter and Aggregator require no ref/method
• Aggregator also has ReleaseStrategy and CorrelationStrategy
<aggregator input-channel="processedItems"
ref="orderRepository"
method="generateConfirmation"
output-channel="confirmations"/>
33

34. Annotation Support
• Alternative to XML
@ServiceActivator(inputChannel=“accounts”)
public void createAccount(Account account) {…}
@Filter(inputChannel=“customers”, outputChannel=“vips”)
public boolean isVip(Customer customer) {…}
@Splitter(inputChannel=“orders”, outputChannel=“lineItems”)
public List<LineItem> getLineItems(Order order) {…}
34

35. Expression Language Support
• Alternative option for ref/method in endpoints
<filter input-channel="customers"
expression="payload.vip"
output-channel="vips"
discard-channel="nonVips"/>
• Mapping between Messages and Methods
public void createAccount(
@Payload("firstName") String firstName,
@Payload("lastName") String lastName,
@Header("userInfo.account.id") String accountId) {
…
}
35

36. Book orders
36

37. Channel Adapters and Messaging Gateways
• Many, many Adapters
• JMS • HTTP (REST) • Activiti BPMN 2
• AMQP • WS (SOAP/POX) • MongoDB
• TCP • Mail (POP3/IMAP/SMTP) • Redis
• UDP • JDBC • Native File System
Adapters
• File • XMPP(S)
• FTP(S) • Twitter • SMPP(-S) (SMS gateways)
• SFTP • Spring Events
• RMI • RSS/ATOM
37

38. Feed
38

39. Channel Adapters (one-way)
<file:inbound-channel-adapter
channel="fromFile"
directory="${java.io.tmpdir}/input"
filename-pattern="[a-z]+.txt">
<si:poller fixed-delay="5000" />
</file:inbound-channel-adapter>
<jms:outbound-channel-adapter channel="toJms"
destination="exampleQueue"/>
39

40. Gateways (request-reply)
<http:outbound-gateway request-channel="httpRequests"
url="http://trafficexample.org/{zipCode}">
<http:uri-variable name="zipCode"
expression="payload.address.zip" />
</http:outbound-gateway>
<ws:outbound-gateway request-channel="weatherRequests"
uri="http://weatherexample.org"
marshaller="jaxb2Marshaller" />
40

41. Spring Integration 2.0
41

42. Major Themes
• Spring 3.0 support
• JDK 5 Support
• New Message Stores
• New Adapters
• Misc.
42

43. Spring 3.0
• ConversionService
• Spring Integration takes advantage of a configured conversion service
whenever it wants to perform certain conversions, from a certain
primitives to complex objects in message parameters, for example.
• default Spring Integration conversion service bean ID:
integrationConversionService
• must implement org.springframework.core.convert.converter.Converter
<int:converter>
<bean class="….MyConverterImplementation" />
</int:converter>
43

44. Spring 3.0
• Spring Expression Language
• through XML or Java
<int:recipient-list-router id="customRouter"
input-channel="routingChannel">
<int:recipient channel="channel1"
selector-expression="payload.equals('foo')"/>
<int:recipient channel="channel2"
selector-expression="headers.contains('bar')"/>
</int:recipient-list-router>
<int:router input-channel="inChannel"
expression="payload + 'Channel'"/>
<filter input-channel="input"
expression="payload.equals('nonsense')"/>
44

45. Spring 3.0
• Spring Expression Language
• through XML or Java
<int:transformer input-channel="inChannel"
output-channel="outChannel"
expression="payload.toUpperCase() + '- [' +
T(java.lang.System).currentTimeMillis() + ']'" />
<filter input-channel="input" expression="payload.matches(
#{filterPatterns.nonsensePattern}
)" />
45

46. Spring Integration 2.0
• New Adapters
• Drastically improved file system support
• JDBC inbound and outbound adapters
• RSS / ATOM
• Twitter
• XMPP
• TCP/
• Misc
• new JMS channel
• revised HTTP support
46

47. Spring Integration 2.1
47

48. Spring Integration 2.0
• Spring 3.1 support
• JDK 7 support
• Conversations
• New message stores
• New adapters
• AMQP / Redis / SMPP / Gemfire
• Misc
• Activiti
• Flex 1.5 / Comet
• Feedback
• What‘s valuable to you?
48

49. Productivity boosters: STS Visual Editor
49

50. Productivity Boosters: Forthcoming
• Productivity boosters
• STS template project
• Spring Roo addon
50

51. Links
• Spring Framework Documentation
• http://static.springsource.org/spring/docs/3.0.x
• Spring Integration Sandbox
• git.springsource.org/spring-integration/sandbox
• Spring Integration
• http://www.springsource.org/spring-integration
• Enterprise Integration Patterns
• http://enterpriseintegrationpatterns.com
• Sample Code
• http://git.springsource.org/spring-integration/samples
• Getting Started with Spring Integration
• http://blog.springsource.com/category/green-beans/
51

52. Credits
• Slides
• Mark Fisher, Josh Long, Adam Fitzgerald, Oliver Gierke
• Demos
• Spring Integration team
52