Open Source ESBs in Action

An enterprise service bus — or ESB — is a piece of middleware that manages communication between enterprise services and applications. These plug into a software 'bus' that distributes messages between them for a seamless integration. Commercial ESB software can be expensive, but outstanding open source alternatives are becoming popular.

Open Source ESBs in Action makes its subject accessible in a uniquely practical and example-rich way. It introduces two leading open source ESB implementations, Mule and ServiceMix, and uses them to illustrate how to apply ESBs in real life. It shows you how to inmplement well-known enterprise integration patterns such as transformation, routing, and message channels. With precisely crafted code the authors teach you structured techniques to solve important integration problems.

This book is written for Java developers and architects, and requires no previous exposure to ESBs.

• Part One: Understanding ESB Functionality
  1. The world of open source ESBs
     1. Why do you need an ESB?
        • Benefits of an ESB
        • Using an ESB from an application perspective
     2. Explaining the core functionalities of an ESB
        • Location transparency
        • Transport protocol conversion
        • Message transformation
        • Message routing
        • Message enhancement
        • Security
        • Monitoring and management
        • Core functionality overview
     3. Researching the open source ESB market
        • Demystifying the open source ESB
        • Overview of open source ESBs
     4. Why did we choose Mule and ServiceMix?
        • Defining selection criteria
        • Assessing the open source ESBs
     5. Hello world with Mule and ServiceMix
        • Taking a donkey ride with Mule
        • Taking a JBI dive with ServiceMix
     6. Summary
  2. Architecture of Mule and ServiceMix
     1. Mule architecture and components
        • Mule components overview
        • Mule endpoints
        • Transformers
        • Routers
        • Component
        • Mule deployment models
        • Mule wrap-up
     2. JBI, the foundation for ServiceMix
        • Service engines and binding components
        • Services and endpoints
        • Normalized message router
        • Service description, invocation, and message exchanges
        • Service unit and service assembly
        • JBI wrap-up
     3. ServiceMix architecture and components
        • ServiceMix overview
        • Routing and transformations in ServiceMix
        • ServiceMix deployment models
        • ServiceMix wrap-up
     4. Summary
  3. Setting up the Mule and ServiceMix environments
     1. Three technologies enhancing the ESB functionality
        • Using Spring as an object container
        • XML marshaling with JiBX
        • Using JMS with the ActiveMQ broker
     2. Preparing the development environment
        • Setting up ESBs, tools, and required libraries
        • Running examples from Eclipse
     3. Inaugurate the Mule environment
        • Writing and configuring the Mule components
        • Running the Mule examples
     4. Inaugurate the ServiceMix environment
        • Select the necessary JBI components
        • Configuring the ServiceMix example implementation
        • Running the ServiceMix example
     5. Summary
  4. The Foundation of an integration solution
     1. Implementing integration logic with Mule
        • Creating a logging solution with Mule
        • Developing a custom transformer with Mule
        • Integrating Mule and Spring
     2. Implementing integration logic with ServiceMix
        • Creating a logging solution with ServiceMix
        • Developing a custom transformer with ServiceMix
        • Integrating ServiceMix and Spring
     3. Constructing message flows with an ESB
        • What is a message flow?
        • A message flow case study
     4. Implementing a message flow with Mule
        • Implementing the request flow with Mule
        • Implementing the response flow with Mule
     5. Implementing a message flow with ServiceMix
        • Implementing the request flow with ServiceMix
        • Implementing the response flow with ServiceMix
     6. Interlude: Spring Integration
        • A quick example with Spring Integration
     7. Summary
• Part Two: Using ESB Core Functionalities
  5. Working with messages
     1. Routing messages
        • Fixed router
        • Content-based router
     2. Validating messages
        • Validating messages with Mule
        • Validating messages with ServiceMix
        • An alternative way to perform message validation using Synapse
     3. Transforming messages
        • Implementing message transformation in Mule
        • Implementing message transformation in ServiceMix
     4. Summary
  6. Connectivity options
     1. File connectivity
        • Mule File transport
        • ServiceMix file transport
     2. Connecting to JMS
        • Connecting Mule to JMS
        • Connecting ServiceMix to JMS
     3. Connecting to a database using JDBC
        • Connecting Mule to JDBC
        • Connecting ServiceMix to JDBC
     4. Connecting to mail servers
        • Connecting Mule to POP3 and SMTP
        • Connecting ServiceMix to POP3 and SMTP
     5. FTP connectivity
        • FTP and Mule
        • FTP and ServiceMix
     6. Connecting to EJB 3
        • Using EJB 3 from Mule
        • EJB 3 and ServiceMix
     7. Summary
  7. Web services support
     1. Top-down approach web service
        • Java implementation of the web service
        • Implementing a top-down web service using Mule
        • Implementing a top-down web service using ServiceMix
     2. Bottom-up approach
        • Bottom-up approach using Mule
        • Bottom-up approach using ServiceMix
     3. Consuming web services
        • Consuming web services with Mule
        • Consuming web services using ServiceMix
     4. Web service standards
        • WS-Security
        • Using WS-Security with Mule
        • Using WS-Security with ServiceMix
        • WS-Addressing
        • Using WS-Addressing in Mule
        • Using WS-Addressing in ServiceMix
     5. Summary
  8. Implementing enterprise-quality message flows
     1. Handling errors in your message flow
        • Error handling with Mule
        • Error handling in ServiceMix
     2. Securing the ESB environment
        • Authentication and authorization with Mule
        • Authentication and authorization with ServiceMix
     3. Making your message flows transactional
        • Implementing transactional message flows in Mule
        • Implementing transactional message flows in ServiceMix
     4. Summary
• Part Three:ESB Case Studies
  9. Implementing a case study using patterns
     1. Introducing a design approach for integration projects
        • Introducing the Enterprise Integration patterns
        • Analyzing a pattern-based design approach
     2. Introducing a restaurant table reservation case study
     3. Designing the restaurant table reservation solution
        • Designing a publish-subscribe message flow
        • Designing a filtering and routing message flow
     4. Implementing the case study with Mule and ServiceMix
        • The Spring and Hibernate building blocks
        • Implementing the Mule message flow
        • Implementing the ServiceMix message flow
     5. Testing and deploying the integration solution
        • Using JUnit to test the Mule and ServiceMix flows
        • Deploying an integration solution to a production environment
     6. Summary
  10. Managing and monitoring the ESB
      1. System-management Enterprise Integration patterns
         • The Wire Tap pattern
         • The Message Store pattern
         • The Detour pattern
      2.  Monitoring using JMX
         • Using JMX to administer Mule
         • Monitoring Mule using MC4J
         • Mule Galaxy and Mule HQ
         • Using JMX to administer ServiceMix
         • Monitoring ServiceMix using MC4J
      3.  Summary
  11. Implementing a process engine in the ESB
      1. Introducing the process engine
         • The execution environment for processes
         • Designing processes for a process engine
      2.  A process engine case study: booking a day of scuba diving
      3.  Diving into the messages and services
         • Designing the case study message definitions
         • Serializing the case study messages to XML with JiBX
         • Setting the stage for the case study implementation
      4.  Implementing a process engine with jBPM and jPDL
         • Orchestrating services with jPDL
         • Implementing the case study with jBPM and Mule
      5.  Implementing a process engine with Apache ODE and WS-BPEL
         • Orchestrating services with WS-BPEL
         • Implementing the case study with Apache ODE and ServiceMix
      6.  Summary
• Appendix A: ServiceMix 4.0
• Appendix B: Differences between Mule 1.4.x and Mule 2.0.x
• Appendix C: Graphical tool support
• Appendix D: Mule component overview
• Appendix E: ServiceMix component overview
• Appendix F: The Swing test client
• Appendix G: Overview of tools and libraries

If you're thinking about deploying an Enterprise Software Bus, but is a bit unsure what it really is, this is a very good book to have handy. It gives two OSS examples of the ESB and how you can use it (granted, they skip over the controversial part pretty often) and can be used as an introductionary text on ESBs in my opinion.