This document discusses Enterprise Integration Patterns (EIPs) using Apache Camel, a Java framework for integration and mediation. It provides an overview of common EIPs like content-based routing, normalization, and the transactional client pattern. It also demonstrates how to implement EIPs like these using the Java and Spring DSLs in Camel. Key features of Camel like components, exchanges, processors and error handling are explained. Tools for working with Camel like Fuse IDE and Hawt.io are also introduced.

1. Enterprise Integration
Patterns
with
Apache Camel
Ioan Eugen Stan
20 Septembrie 2013
Axway Kickoff

2. ● Why = The purpose - What is
you cause? What do you belive
in?
● How = The Process - specifc
actions taken to realize the Why
● What = The result - what do
you do, the result of Why. Proof.
TED, Simon Sinek, May 2010

3. Why do we need
integration?
A integra = include, a (se) îngloba, a (se)
încorpora, a (se) armoniza într-un tot.

5. Why EIP Where does complexity
come from?
Much of the complexity stems from two issues:
● dealing with the specifics of applications and
transports
● coming up with good solutions to integration
problems

6. The Book
● 65 design patterns
● Formalized language
● Covers:
○ Integration Styles
○ Messaging Systems
○ Message Construction
○ Message Routing
○ Message Transformation
○ Messaging Endpoints
○ System Management

7. EIPs in detail (1)
Message
Pipes and Filters
Message translator
Message router
Messaging Systems

8. EIPs in detail (2)
Point to Point channel
Publish Subscribe Channel
Dead letter queue
Guaranteed delivery
Messaging Channels

9. EIPs in detail (3)
Event message
Request reply
Correlation identifier
Return Address
Messaging Construction

10. EIPs in detail (4)
Content based router
Message filter
Dynamic router
Recipient list
Messaging Routing

11. EIPs in detail (5)
Splitter
Aggregator
Resequencer
Routing slip
Messaging Routing

12. EIPs in detail (6)
Content enricher
Content filter
Claim check
Normalizer
Messaging Transformation

13. EIPs in detail (7)
Event driven consumer
Pooling consumer
Transactional client
Service activator
Messaging Endpoints

14. EIPs in detail (8)
Control bus
Detour
Wire Tap
System Management

15. Flight Mash-up
Image from: http://appzdevelop.blogspot.ro/2012/02/apache-camel-flight-aggregation-mashup.html
Code: https://code.google.com/p/apache-camel-mashup/

16. Purchase example

17. Normalization
Transform multiple message types into a common format

18. Other examples

19. Apache Camel
● java framework for integration and mediation
● rules in multiple DSLs:
○ Fluent Java
○ Spring XML
○ Blueprint XML
○ Scala
● over > 150 out-of-box components
● bean binding and integration with popular
frameworks
● active comunity ~ 900 messages/month

20. Camel Architecture
Image from: http://java.dzone.com/articles/open-source-integration-apache (Camel in Action)

21. Basics
● create a CamelContext
● optionally configure components or
endpoints
● add routing rules
● start the context

22. Example Java DSL

23. Example Spring DSL

24. Vocabulary: Component & Endpoint
● Component is an Endpoint factory
● Enpoints are refered by URIs: file://, jms://
● Has methods:
○ createProducer()
○ createConsumer()
○ createPoolingConsumer()

25. (Some) Standard components
● AHC - Async HTTP client
● Atom
● AMPQ
● AWS-* - Amazon cloud services
● Bean - Bean binding
● DNS - DNS look-up
● Elasticsearch
● JPA
● File & FTP
● HBase
● HTTP
● LDAP
● MongoDB
● Mustache
● Netty
● POP3
● RabbitMQ
● Salesforce
● Servlet
● JMS & ActiveMQ
● SQL
● SSH
● Validation - XML validation
● Websocket
● XMPP
● Activiti BPMN
● Smooks

26. Vocabulary: Exchange
● Exchange = Wrapper object
● encapsulates Messages (IN and
OUT) and Metadata

27. ● Java interface used to implement message consumers
or Message Translator EIP
● you can create a Component from a Processor
Camel Processor

28. Remember
Processing files with Apache Camel

29. Content Based Router EIP
Route messages to destination based on message contents

30. Content Based Router - Spring DSL

31. Normalizer EIP

32. Camel ETL - sample
● read files from src/data/ directory
● convert content to PersonDocument class using TypeConvertor system
(JAXB)
● persist to DB using JPA component using TypeConvertor
● read from DB with JPA component as entity class
● convert entity to XML file with JAXB and File component

33. Transactional Client EIP
Make client session with messaging system transactional
● uses Spring transactions
● Transactional endpoints: JMS, ActiveMQ, AMPQ, JPA
Camel also supports Transactional Routes

34. Transactional Client

35. Load Balancer Pattern
● delegate processing based on load
balancing policies
● out-of-the-box-policies:
○ Round robin
○ Random
○ Sticky
○ Topic
○ Failover
○ Weighted Round-robin
○ Weighted random
○ Custom

36. Load Balancer

37. Error Handling
Two distinct types:
● transactional
● non-transactional
Can configure policies like:
● message redelivery
● dead-letter queue

38. Error Handling - Try - Catch

39. Error Handling - Dead Letter Queue
● exceptions caught by Dead Letter Channel - which
decides either:
○ to redeliver
○ or send to dead letted queue

40. Camel BAM
● business activity monitoring framework
● monitor business processes across multiple exchanges
● works across different endpoints
For every purchase order created by A, B generates an invoice.

41. Flight Mash-up revisited

42. Tooling: Fuse IDE
● Eclipse based RedHat JBoss product
● build Camel routes graphically (Spring XML
DSL)
● import existing XML routes
● comes with pre-defined EIP building blocks
● view local and remote ActiveMq brokers,
Camel end-points and routes
● trace Camel routes at run-time

43. Fuse IDE - diagram view

44. Hawt.io - ultimate admin console
● lightweight html5 modular web-console
● open-source (JBoss Cumunity project)
● discovers what the JVM is running (JMX,
other) and exposes a web UI
● lots of plugins:
○ ActiveMQ - default console for 5.9.x
○ Camel - view/control routes
○ OSGi - view/control bundles
○ Karaf
○ JMX
○ …..

45. Hawt.io - view routes

46. Hawt.io - ActiveMQ - browse/send

47. Hawt.io - monitor

48. Hawt.io - inspect JMX

49. Conclusions
● Camel is awesome tehnology
● easy to get started
● very powerfull
● the comunity is great and helpful

50. Întrebări?

51. Resources
● http://camel.apache.org
● https://access.redhat.com/site/documentation/Fuse_ESB_Enterprise/
● http://www.eaipatterns.com/
● http://java.dzone.com/articles/open-source-integration-apache
● http://activemq.apache.org/
● http://hawt.io/
● http://fusesource.com/products/fuse-ide/
● https://code.google.com/p/apache-camel-mashup/
● http://appzdevelop.blogspot.ro/2012/02/apache-camel-flight-aggregation-
mashup.html

52. Contact
● stan.ieugen@gmail.com
● ieugen@apache.org
● http://github.com/ieugen/
● ro.linkedin.com/in/ieugen/