Open-Source ESBs In Action

Description

Most modern business systems include independent applications that exchange information with each other-a technique usually called enterprise integration. An architectural approach called the Enterprise Service Bus (ESB) offers developers a way to handle the messages between those independent applications without creating a lot of custom code. While commercial ESB solutions can be quite expensive to implement and maintain, a set of high-quality open source ESB tools offer the same functionality at a substantially lower cost.

 Open Source ESBs in Action shows you how to implement and use two open source ESB implementations: Mule and ServiceMix. The authors introduce you to these freely-available ESB tools and present practical examples of how to use them in real-world scenarios. You will learn how the various features of an ESB such as transformation, routing, security, connectivity and more can be implemented using Mule and ServiceMix. You will also learn how to solve common enterprise integration problems using a structured approach.

 Beyond simply learning how Mule and Service Mix work, you'll learn the core techniques of ESB implementation such as Process Choreography, or the implementation of complex business processes through an ESB, and Service Orchestration, or exposing a set of services as a single service. The book shows you the fundamentals of ESB-based event processing and Quality of Service concerns like security, reliable delivery, and transaction management.

 Working in integration projects is exciting, with new technologies and paradigms arriving every day. Open Source technologies like Mule and ServiceMix both offer lower-cost solutions and a higher degree of innovation than commercial ESB implementations. Open Source ESBs in Action will help you master ESB-driven integration techniques quickly and will provide you with knowledge you need to work effectively with Mule and ServiceMix.

CONTENTS:

Part 1 Understanding ESB functionality

1 The world of open source ESBs

    1.1 Why do you need an ESB?

    Benefits of an ESB

    Using an ESB from an application perspective

    1.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

    1.3 Researching the open source ESB market

    Demystifying the open source ESB

    Overview of open source ESBs

    1.4 Why did we choose Mule and ServiceMix?

    Defining selection criteria

    Assessing the open source ESBs

    1.5 Hello world with Mule and ServiceMix

    Taking a donkey ride with Mule

    Taking a JBI dive with ServiceMix

    1.6 Summary

2 Architecture of Mule and

    2.1 Mule architecture and components

    Mule components overview

    Mule endpoints

    Transformers

    Routers

    Component

    Mule deployment models

    Mule wrap-up

    2.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

    2.3 ServiceMix architecture and components

    ServiceMix overview

    Routing and transformations in ServiceMix

    ServiceMix deployment models

    ServiceMix wrap-up

    2.4 Summary

3 Setting up the Mule and ServiceMix

    3.1 Three technologies enhancing the ESB functionality

    Using Spring as an object container

    XML marshaling with JiBX

    Using JMS with the ActiveMQ broker

    3.2 Preparing the development environment

    Setting up ESBs, tools, and required libraries

    Running examples from Eclipse

    3.3 Inaugurate the Mule environment

    Writing and configuring the Mule components

    Running the Mule example

    3.4 Inaugurate the ServiceMix environment

    Select the necessary JBI components

    Configuring the ServiceMix example implementation

    Running the ServiceMix example

    3.5 Summary

4 The foundation of an integration solution

    4.1 Implementing integration logic with Mule

    Creating a logging solution with Mule

    Developing a custom transformer with Mule

    Integrating Mule and Spring

    4.2 Implementing integration logic with ServiceMix

    Creating a logging service assembly for ServiceMix

    Creating service units and a service assembly

    Integrating ServiceMix and Spring

    4.3 Constructing message flows with an ESB

    What is a message flow?

    A message flow case study

    4.4 Implementing a message flow with Mule

    Implementing the request flow with Mule

    Implementing the response flow with Mule

    4.5 Implementing a message flow with ServiceMix

    Implementing the request flow with ServiceMix

    Implementing the response flow with ServiceMix

    4.6 Interlude: Spring Integration

    A quick example with Spring Integration

    4.7 Summary

Part 2 Using ESB core functionalities

5 Working with messages

    5.1 Routing messages

    Fixed router

    Content-based router

    5.2 Validating messages

    Validating messages with Mule

    Validating messages with ServiceMix

    An alternative way to perform message validation using Synapse

    5.3 Transforming messages

    Implementing message transformation in Mule

    Implementing message transformation in ServiceMix

    5.4 Summary

6 Connectivity options

    6.1 File connectivity

    Mule File transport

    ServiceMix file transport

    6.2 Connecting to JMS

    Connecting Mule to JMS

    Connecting ServiceMix to JMS

    6.3 Connecting to a database using JDBC

    Connecting Mule to JDBC

    Connecting ServiceMix to JDBC

    6.4 Connecting to mail servers

    Connecting Mule to POP3 and SMTP

    Connecting ServiceMix to POP3 and SMTP

    6.5 FTP connectivity

    FTP and Mule

    FTP and ServiceMix

    6.6 Connecting to EJB 3

    Using EJB 3 from Mule

    EJB 3 and ServiceMix

    6.7 Summary

7 Web services support

    7.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

    7.2 Bottom-up approach

    Bottom-up approach using Mule

    Bottom-up approach using ServiceMix

    7.3 Consuming web services

    Consuming web services with Mule

    Consuming web services using ServiceMix

    7.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

    7.5 Summary

8 Implementing enterprise-quality message flows

    8.1 Handling errors in your message flow

    Error handling with Mule

    Error handling in ServiceMix

    8.2 Securing the ESB environment

    Authentication and authorization with Mule

    Authentication and authorization with ServiceMix

    8.3 Making your message flows transactional

    Implementing transactional message flows in Mule

    Implementing transactional message flows in ServiceMix

    8.4 Summary

Part 3 ESB case studies

9 Implementing a case study using

    9.1 Introducing a design approach for integration projects

    Introducing the Enterprise Integration patterns

    Analyzing a pattern-based design approach

    9.2 Introducing a restaurant table reservation case study

    9.3 Designing the restaurant table reservation solution

    Designing a publish-subscribe message flow

    Designing a filtering and routing message flow

    9.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

    9.5 Testing and deploying the integration solution

    Using JUnit to test the Mule and ServiceMix flows

    Deploying an integration solution to a production environment

    9.6 Summary

10 Managing and monitoring the ESB

    10.1 System-management Enterprise Integration patterns

    The Wire Tap pattern

    The Message Store pattern

    The Detour pattern

    10.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

    10.3 Summary

11 Implementing a process engine in the ESB

    11.1 Introducing the process engine

    The execution environment for processes

    Designing processes for a process engine

    11.2 A process engine case study: booking a day of scuba diving

    11.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

    11.4 Implementing a process engine with jBPM and jPDL

    Orchestrating services with jPDL

    Implementing the case study with jBPM and Mule

    11.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

    11.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