Mule 2 Developer's Guide to ESB and Integration Platform

158 Pages·2008·1.31 MB·English

by  Peter Delia

Contents
Chapter 1: Fundamental Mule......................................................1
The Enterprise Service Bus....................................................................1
Mule Features.........................................................................................4
Enterprise vs. Community Edition.........................................................5
Anatomy of a Mule..................................................................................6
Installing Mule as a Service (or Daemon).....................................................7
The Design-Time Container..........................................................................8
Mule 2 Configuration File Structure.............................................................8
Service Components....................................................................................11
Configuring Service Components...............................................................12
Endpoints.....................................................................................................13
Configuring Global Endpoints....................................................................16
Connectors...................................................................................................17
Routers.........................................................................................................18
Transformers ...............................................................................................23
Complete Mule 2.0 Configuration File.......................................................25
Summary................................................................................................27
Chapter 2: Routers and Routing.................................................29
Routing Patterns....................................................................................29
Inbound Routing..........................................................................................30
The Response Routing Pattern....................................................................34
Inbound vs. Outbound.................................................................................35
Routing Options..........................................................................................38
Summary................................................................................................47
Mule 2: A Developer’s Guide to ESB and Integration Platform i
Chapter 3: Modeling Applications ...............................................49
Real-World Scenario.............................................................................49
Checking In.................................................................................................50
Luggage Handling.......................................................................................50
Airport Interaction.......................................................................................51
Modeling the Solution.................................................................................51
Modeling Points..........................................................................................55
Implementing a Modeled Application.........................................................56
Summary................................................................................................56
Chapter 4: Creating a Mule Application.......................................57
Core Tools and Components ................................................................57
Installing Mule............................................................................................57
The Mule IDE..............................................................................................58
Creating Your Mule Application..........................................................59
Service Components....................................................................................59
The Mule Configuration File.......................................................................61
Running Your Mule Application.................................................................61
Installing Mule as a Service (or Daemon)...................................................62
Unit Tests...............................................................................................63
Testing Applications....................................................................................63
Black Box Testing a Mule Server...............................................................64
Creating a Test Case....................................................................................65
Messages in Mule........................................................................................67
Communicating with the Mule Server........................................................70
Asserting Output..........................................................................................71
Testing Mule Using JUnit...........................................................................71
Summary................................................................................................74
ii Mule 2: A Developer’s Guide to ESB and Integration Platform
Chapter 5: Mule Transports .......................................................75
Transport Architecture .........................................................................75
Connectors and Endpoints...........................................................................75
A Transport..................................................................................................76
The MessageReceiver Interface..................................................................77
The MessageDispatcher Interface...............................................................77
Transport Overrides.....................................................................................78
Service Descriptor File................................................................................78
Transports and Their Configuration....................................................79
The Console Transport................................................................................79
The Virtual Machine (VM) Transport.........................................................81
Processing Queues.......................................................................................82
The File Transport.......................................................................................83
The HTTP Transport...................................................................................87
The FTP Transport......................................................................................90
The SMTP Transport...................................................................................92
The JMS Transport......................................................................................95
The JDBC Transport.................................................................................100
Summary..............................................................................................103
Chapter 6: Web Services in Mule..............................................105
Overview ..............................................................................................105
Simple Object Access Protocol.................................................................105
Mule and Web Services.............................................................................106
The CXF Transport.............................................................................107
From XFire to CXF...................................................................................108
The CXF Connector..................................................................................108
Attributes...................................................................................................109
Hosting a CXF Web Service.....................................................................109
CXF Outbound Endpoint ..........................................................................113
Mule 2: A Developer’s Guide to ESB and Integration Platform iii
The Axis Transport.............................................................................114
Axis Connector Attributes.........................................................................115
Hosting an Axis Web Service...................................................................116
Connecting to an Axis Web Service .........................................................117
Invoking Non-Axis Web Services.............................................................118
REST....................................................................................................120
Summary..............................................................................................121
Chapter 7: Extending Mule ......................................................123
Building a Transformer......................................................................123
Transforms: ESB or Service?....................................................................124
Introducing AbstractTransformer..............................................................124
Building a Filter..................................................................................127
Overview...................................................................................................128
Complex to Simple Filter..........................................................................128
Creating a New Filter................................................................................130
Building a Router................................................................................131
Overview...................................................................................................131
MuleEvent Methods..................................................................................132
Inbound Routers........................................................................................133
Outbound Routers......................................................................................134
Extending a Router....................................................................................135
An Idempotent Router...............................................................................135
Summary..............................................................................................137
Chapter 8: Resilient Mule Applications ......................................139
Error Handling and Recovery............................................................139
Mule’s Exception Strategy Classes...........................................................140
Configuring Exception Strategies.............................................................140
Flexible Exception Strategies....................................................................141
iv Mule 2: A Developer’s Guide to ESB and Integration Platform
Exception Strategies—Create Your Own.................................................144
Routing Patterns—Exception Router........................................................144
Transactions in Mule..........................................................................145
Single vs. XA Transactions.......................................................................146
The Transaction Manager..........................................................................146
Transactional Endpoints............................................................................147
Poison Messages........................................................................................149
Connection Strategies.........................................................................150
Summary..............................................................................................150
Mule 2: A Developer’s Guide to ESB and Integration Platform v
Mule 2: A Developer’s Guide to
ESB and Integration Platform
by Peter Delia, and Antoine Borg
ESB. SOA. CXF. JXF. EIP. EAI. These are just a few of the myriad acronyms
that make our work harder, not because the subject matter is complex but
because the subject matter is vast. What is the real definition of a Service
Oriented Architecture (SOA)? Should you perform transformations on an
Enterprise Service Bus (ESB) or should that be a service? There are so many
things that are not standardized or that are being debated in online forums
around the globe.
The thing is, once you've decided that you might need to use an ESB—whether as
part of an Enterprise Integration Project (EIP) or as part of a wider SOA
initiative, you're faced with a second problem. How do you use it? Vendors are
great when it comes to certain types of documentation, but locking yourself into a
single vendor's embrace may not be your cup of tea. In the open-source world,
while there is a great wealth of documentation available, you need to trawl
through wikis, forums, newsgroups, and conferences to get it all.
Our goal when we set out was to take everything we learned while building
course materials to teach developers about Mule in the classroom, and make it
available in book form. We take a reader who is new to Mule and perhaps ESBs
through a series of logical steps starting from basic concepts to building Mule
components such as routers and transformers. After reading this book you will
be able to write full-blown Mule applications.
Mule 2: A Developer’s Guide to ESB and Integration Platform vii
Acknowledgements
We’d like to thank all the people who helped make this book possible: Ross
Mason, founder of the Mule project and MuleSource for somehow making the
time for a thorough technical review; Susan Forshaw, who is helping drive
Ricston forward; Wendy Devolder, founder of Skills Matter; and Lisa Hamilton
and everyone with Ricston, Apress, and MuleSource that contributed in one way
or the other. Last but not least, we hope this book helps readers start to tap the
power of Mule!
viii Mule 2: A Developer’s Guide to ESB and Integration Platform
Chapter 1: Fundamental Mule
This chapter covers the fundamental concepts within Mule, from the
definition of an Enterprise Service Bus (ESB) to how you can configure
fundamental elements inside Mule to produce a working application.
The Enterprise Service Bus
An Enterprise Service Bus (ESB), sometimes referred to as “messaging
middleware,” is nothing more than a platform that can carry data between
different, disparate applications. Data is carried to and from a series of
stops, known as "endpoints," which must be defined for each application.
The internals of an ESB contain routing mechanisms that know how to
direct specific data from point A to point B.
As you can see from the diagram in Figure 1-1, the ESB is a logical
channel that spans your enterprise and each endpoint, and allows data to be
sent or received from numerous applications via the bus. Data is transferred
to or from each endpoint using a particular protocol—across a TCP
connection or perhaps over HTTP, for instance. However, the ESB is more
than just the protocols or communication channels; it is the messaging
framework.
Mule 2.0 provides this messaging framework rather than the actual
middleware required to transfer messages from one endpoint to another.
Typically, you could use the Java Message Service (JMS) to transfer data,
or perhaps web services, and just use Mule to manage all of this. In fact,
Mule does not limit you to using one messaging middleware over another,
and it supports 25 different protocols out of the box in the current release.
Many more are also available on the community-based MuleForge web site
that MuleSource hosts and runs at http://www.MuleForge.org.
Mule 2: A Developer’s Guide to ESB and Integration Platform 1
Figure 1-1. The ESB
Database
SOAP B2B
request interactions
Existing
Portal Services
applications
Apart from this messaging, Mule has an object broker that can manage
Java objects at runtime. The object broker uses a nonintrusive container
that allows you to reuse existing Java objects without the need for
additional coding. As well as transferring data to and from other
applications, data can also be passed to and from these hosted objects. All
this is performed at runtime using the staged event-driven architecture
(SEDA) threading model, which was developed by Dr. Matt Walsh.
All thread handling is performed internally within Mule and shielded from
the developer. While a lot of items are hidden from view, this is not to
suggest that they are inaccessible; you can easily tweak or change anything
within Mule by taking advantage of its fully extensible development
2 Mule 2: A Developer’s Guide to ESB and Integration Platform