EIP In Practice

Enterprise Integration
Patterns in Practice
Andreas Egloff
Sun Microsystems
Bruce Snyder
SpringSource
&

What Are Design Patterns?
A design pattern is a formal way of
documenting a solution to a design
problem in a particular ﬁeld of expertise.
(Wikipedia)
2

Core Principles of EIP
> Patterns using asynchronous messaging as a style
of integration
> Pros
• Scaling
• Decoupling
> Cons
• Latency vs. throughput
• Decoupling not always appropriate
4

Identifying and Expressing Patterns
6

Layers of Functionality
> Not an either/or choice, combine layers as
appropriate
7

Message Flow / Service Composition
> Strengths and uses
• De-coupling and re-using Services
• Easier to evolve
• Scaling, Throughput
• Asynchronous nature
• Message routing, processing, transformation
• Easy to mediate
8

Message Endpoints / Services
> Message Endpoints / Services
• Message based interface
• Expose coarse grained services
• Typically stateless
• Anticipate re-use
• Visibility scope examples
• Within application
• Within ESB
• Anyone with access to JMS server
• External
9

Code Composition
> Strengths and uses
• Fine grained API access
• Stateful, ﬁne grained interactions
• Low latency
> Challenge
• Interface tighter coupled
10

Implicit and Explicit Patterns
> Some patterns inherent in technology / framework
• Not every pattern a "keyword"
• e.g. JMS publish/subscribe ...
> Patterns realized in user code
• e.g. Scatter-Gather realized in Java
> Platform has pre-built constructs
• e.g. Unix pipe symbol "|" : pipes-and-ﬁlters
• Route in Camel or Fuji: pipes-and-ﬁlters
11

Visualizing EIPs
• Stencils exist for Visio and OmniGrafﬂe
• http://www.eaipatterns.com/downloads.html
12

> Issue: Too little explicit support out-of-the-box
• Too much roll your own
> Issue: Explicit support out-of-the-box is too rigid
• Does not exactly ﬁt the use case
• Forced to work around or again roll your own
> What you want is out-of-the-box productivity with
explicit constructs AND ﬂexibility to customize the
constructs
Gotcha - Flexibility vs. Productivity
14

Intro to Frameworks
• Apache Camel
• http://camel.apache.org/
• Project Fuji / OpenESB v3
• http://fuji.dev.java.net/
15

What is Apache Camel?
A framework for simplifying integration
through the use of the
Enterprise Integration Patterns for
message mediation, processing,
routing and transformation
http://camel.apache.org/
16

Apache Camel is Focused on EIP
17
http://camel.apache.org/
=>
http://eaipatterns.com/

Message Routing
18
from("A").to("B");

Slightly More Complex Routing
19
from("file:///tmp/myFile.txt").
to("bean:MyBean?method=handleMessage").
to("jms:TEST.Q");

Multicast Routing
20
choice().when().
method("MyBean", "matches").
to("Q").
end().
multicast("B", "C", "D");

Pipeline Routing
21
choice().when().
method("MyBean", "matches").
to("Q").
end().
pipeline("B", "C", "D");

Camel Components
22
> 70+ components supported

What is Project Fuji?
> Basis for OpenESB v3
> Fuji Goals
• Agility + Flexibility + Ease of Use = Productivity
> Service Platform to realize
• Service Oriented Architecture (SOA)
• Light weight SOA (aka Web Oriented Architecture)
• Event Driven Architecture (EDA)
• ... last but not least MOM style applications
> > 40 Components in OpenESB community today
http://fuji.dev.java.net/
23

Interesting Properties of Fuji
• Convention, Conﬁguration, Code... in that order
• Light weight, OSGi based
• Not JMS centric but Service Centric
• In-VM service composition option
• Choice of transport when going across VMs
• E.g. load balancing via http or federating using JXTA
• Visual and textual (DSL) editing for EIPs
• Camel component is another option
24

Web Tooling Option
Service Composition with EIPs in a Browser
25

Web UI Gives the User...
• All-in-one interface for service composition
• Service Deﬁnition
• Routing, EIPs
• Conﬁguration
• Deployment
• Layered on textual representation (DSL)
• Check out from version control, edit in IDE
• Tooling option for different preferences and skills
• e.g. casual technologist vs, Developer
• Extensible
26

Composition in an IDE / Text Editor
A textual representation of EIPs
> Goals
• Simple, concise syntax
• Easy to type and read
• Top-down design
• Generate service templates
• Concept
• used to declare and conﬁgure services, routing
• Sets up services and routing at deployment time;
NOT interpreted on the ﬂy at runtime
"Hello World 1" -
simple routing
27

Basic Concepts of the DSL
Integration Flow Language
"Hello World 2" -
pipes-and-filters
Output of one filter/stage flows to input of next
stage similar to Unix Pipes
28

Basic Concepts of the DSL
Explicit EIP Constructs
"Hello World 3" -
adding EIP constructs
29

Example Pattern Implementations
30

Message Routing: Content-Based Router
31
RouteBuilder builder = new RouteBuilder() {
public void conﬁgure() {
from("activemq:NewOrders").
choice().
when(header("product").
isEqualTo("widget")).
to("http://remotehost:8888/someApp/").
to("activemq:Orders.Widgets").
when(header("product").
isEqualTo("gadget")).
to("ftp://bsnyder@remotehost/private/reports/").
to("activemq:Orders.Gadgets").
otherwise().
to("activemq:ERRORS");
}
};
}
Apache Camel Java DSL

32
<route>
<from uri="activemq:NewOrders"/>
<choice>
<when>
<xpath>/order/product = 'widget'</xpath>
<to uri="activemq:Orders.Widgets"/>
</when>
<when>
<xpath>/order/product = 'gadget'</xpath>
<to uri="activemq:Orders.Gadgets"/>
</when>
<otherwise>
<to uri="activemq:ERRORS"/>
</otherwise>
</choice>
</route>
Apache Camel Spring DSL

Message Channels: Dead Letter Channel
33
errorHandler(deadLetterChannel("activemq:ERRORS.QUEUE"));
from("ﬁle:///tmp/MyFile.txt?delay=2000").
to("activemq:TEST.Q");
}
};
}

Message Channels: Dead Letter Channel
34
<bean id="errorHandler" class="org.apache.camel.builder.DeadLetterChannelBuilder"
p:deadLetterUri="smtp://mail.springsource.com:25" />
<camelContext id="camel" errorHandlerRef="errorHandler"
xmlns="http://camel.apache.org/schema/spring">
<route>
<from uri="seda:a" />
<to uri="seda:b" />
</route>
</camelContext>

Message Transformation: Content Filter
35
from("activemq:THIS.QUEUE").
process(new Processor() {
public void process(Exchange e) {
Message in = exchange.getIn();
in.setBody(in.getBody(String.class) + " Ride the Camel!");
}
}).
to("activemq:THAT.QUEUE");
}
};
}

Message Transformation: Content Filter
36
<bean id="transformerBean" class="com.mycompany.orders.transform.MyTransformerBean" />
<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
<from uri="activemq:THIS.QUEUE" />
<bean ref="transformerBean" method="transformMessage" />
<to uri="activemq:THAT.QUEUE" />
</camelContext>

Camel Pattern: Throttler
> Limit the number of messages to be sent in a given
time window
> (only send three messages every 10 seconds)
37
public class MyRouteBuilder extends RouteBuilder {
from("activemq:TEST.QUEUE”).
throttler(3).timePeriodMillis(10000).
to("http://remotehost:8888/meticProcessingService");
}
}

Camel Pattern: Delayer
> Impose a simple delay on messages before being
sent along
> (delay messages for a duration of JMSTimestamp
value plus three seconds)
38
public class MyRouteBuilder extends RouteBuilder {
from("activemq:TEST.QUEUE").
delayer(header("JMSTimestamp", 3000).
to("http://remotehost:8888/meticProcessingService");
}
}

Message Routing: Scatter-Gather ("all")
Fuji - DSL and Web UI
39

Message Routing: Scatter-Gather ("best")
40

41

Message Routing: Content-Based Router (dynamic)
• CBR rules conﬁgured at deployment/runtime
42

Message Routing: Composed Message Processor
43

EIP Product Demo
• Apache Camel
• Project Fuji
44

Andreas Egloff
andreas.egloff@sun.com
Bruce Snyder
bruce.snyder@springsource.com

EIP In Practice

More Related Content

What's hot (20)

Similar to EIP In Practice (20)

More from Bruce Snyder (13)

Recently uploaded (20)

EIP In Practice