Styles of Applicaton Integration Using Spring

Styles of Application Integration
Using Spring
Bruce Snyder, Senior Software Engineer, SpringSource/VMware

Friday, July 15, 2011

Integrations Are About Coupling

2


Where Coupling Exists, Concerns Arise

• Tight coupling is easy
• Loose coupling can be difficult

• Tight coupling causes issues in the long run
• Loose coupling pays off in the long run

• Integrations are usually tightly coupled
• Integrations should be loosely coupled

• Integrations are commonly addressed using commands
• Integrations should be addressed using events


What is Coupling?

“... the degree to which each program module relies
on each one of the other modules”
(Wikipedia.com)

• Given two lines of code, A and B, they are coupled when B
must change behavior only because A changed

4


Characteristics Tight Coupling

• Components are highly dependent upon one another
• Components are directly linked
• Changes in one component cause a ripple effect
• Less reusability
• More difficult to maintain
• Does not handle unforeseen change well

• Examples
– Clients designed to interact only with specific systems
– Use of proprietary APIs or commands for interaction
– Components designed to work specifically with other
components
5


Characteristics of Loose Coupling

• Components have little or no knowledge of one another
• Components are not directly linked to one another
• Changes in one component do not affect other components
• Increased reusability
• Easier to maintain
• More easily handles unforeseen changes

• Examples
– Dependence upon interfaces instead of concrete classes
– Use of DI encourages looser coupling
– A design using a level of indirection

6


Tight Coupling is Easy

• App design with tight coupling is more widely understood
• App development with tight coupling requires less time
• Debugging a tightly coupled app is easier
• Benefits of tight coupling are seen immediately
• Tightly coupled prototypes commonly live on

7


Loose Coupling is Difficult

• App design with loose coupling is not widely understood
• App development with loosely coupling requires more
thought and more time
• Debugging loosely coupled apps is different
• Benefits of loose coupling are only seen over time

8


Integrations and Coupling

• But it’s easy to write a point-to-point, one-off piece of code
for integration!
• Too many disadvantages
– Difficult to maintain
– No reusability
– Every integration is unique
– Bites you over time

9


Integrations and Coupling

• But designing integrations to be loosely coupled requires
too much work!
• With the right knowledge and preparation, it doesn’t need
to be this way

10


Commands vs. Events

• Commands are not natural
– Verify credit card
• Commands are too specific

• Events are natural
– Order received
• Events are more broad
• Events are what happen in the real world

11


Enterprise Integration Patterns (EIP)

http://enterpriseintegrationpatterns.com/
12


Spring Integration

• Provides both concurrency and messaging
– Message Endpoints
• Connections between services
– Channel Adapters
• Adapter between application and message broker
– Messaging Gateways
• Provides uni-directional or bi-directional messaging
– Service Activators
• Invokes a services based on an incoming message
– Routers
• Determines where to dispatch a message
– Splitters and Aggregators
• Breaks up a message and reassembles it after processing

13


Spring Integration

• Supports
– AMQP
– Email
– File system
– Gemfire
– JMS
– JMX
– MongoDB
– Redis
– Spring Batch
– Testing
– Web Services

14


Spring Integration

15


Spring Integration

16


Spring Integration

17


Spring Integration

18


Spring Integration

19


Spring Integration

20


Spring Integration

21


Spring Integration

22


Spring Integration

23


Spring Integration

24


Types of Integration

• Intra-application integration
• Inter-application integration
• External system integration

25


Typical Application Layers

26


Intra-Application Integration

27


Spring Integration Config

<int:gateway id="sender"
service-interface="org.bsnyder.spring.integration.simple.Sender"/>

<int:channel id="orderReceived"/>

<int:service-activator input-channel="orderReceived" ref="receiver"
method="receive" />

<bean id="receiver" class="org.bsnyder.spring.integration.simple.Receiver"/>

28


Intra-Application Integration

29


service-interface="org.bsnyder.spring.integration.appa.Sender"/>

<channel id="orderReceived" />

<amqp:outbound-channel-adapter channel="orderReceived"
exchange-name="order.received.exchange"
routing-key="order.received.binding"
amqp-template="amqpTemplate" />

<rabbit:connection-factory id="connectionFactory" />
<rabbit:template id="amqpTemplate" connection-factory="connectionFactory" />
<rabbit:admin connection-factory="connectionFactory" />
<rabbit:queue name="order.received.queue" />
<rabbit:direct-exchange name="order.received.exchange">
<rabbit:bindings>
<rabbit:binding queue="order.received.queue" key="order.received.binding" />
</rabbit:bindings>
</rabbit:direct-exchange>

30



<amqp:inbound-channel-adapter channel="orderReceived"
queue-names="order.received.queue"
connection-factory="connectionFactory" />

method="receive" />

<bean id="receiver" class="org.bsnyder.spring.integration.appa.Receiver"/>

<rabbit:bindings>
</rabbit:bindings>

31


Inter-Application Integration

33


Inter-Application Integration

34



<channel id="orderReceived" />

<amqp:outbound-channel-adapter channel="orderReceived"
exchange-name="order.received.exchange"
routing-key="order.received.binding"
amqp-template="amqpTemplate" />

<rabbit:bindings>
</rabbit:bindings>

35



<amqp:inbound-channel-adapter channel="orderReceived"
queue-names="order.received.queue"
connection-factory="connectionFactory" />

method="receive" />

<bean id="receiver" class="org.bsnyder.spring.integration.appb.Receiver"/>

<rabbit:bindings>
</rabbit:bindings>

36


External System Integration

38




<bean id="ftpClientFactory"
class="org.springframework.integration.ftp.session.DefaultFtpSessionFactory"
p:host" value="localhost" p:username" value="${user}" p:password="$
{password}"/>
!
<int:channel id="ftpChannel"/>

<int-ftp:outbound-channel-adapter id="ftpOutbound"
channel="ftpChannel"
remote-directory="/foo/bar/baz/"
client-factory="ftpClientFactory"/>

39



<int:channel id="ftpChannel">
<int:queue/>
</int:channel>

<bean id="ftpClientFactory"
class="org.springframework.integration.ftp.session.DefaultFtpSessionFactory"
p:host="localhost" p:username="${user}" p:password="${password}"/>
!
<int-ftp:inbound-channel-adapter id="ftpInbound"
channel="ftpChannel" session-factory="ftpClientFactory"
filename-regex=".*.txt$" auto-create-local-directory="true"
delete-remote-files="false" remote-directory="/foo/bar/baz/"
local-directory="file:local-target-dir">
<int:poller fixed-rate="1000"/>
</int-ftp:inbound-channel-adapter>

<int:service-activator input-channel="ftpChannel" ref="receiver" method="receive" />

<bean id="receiver" class="org.bsnyder.spring.integration.appb.Receiver"/>

40


Combined Integration

42


Thank You!

Q&A


Styles of Applicaton Integration Using Spring

More Related Content

Similar to Styles of Applicaton Integration Using Spring (20)

More from Bruce Snyder (14)

Recently uploaded (20)

Styles of Applicaton Integration Using Spring