Vivek Soni

An ESB can be described as a set of components that provide the busisness tier with core integration services. The key advantage of an ESB is that it allows different applications to communicate with each other by acting as transit system for carrying data between applications within your intranet or over the internet.

ESB core components

• Data routing
• Data transformation
• Protocol transformation
• Service naming mapping
• Message processing
• Transaction management
• Coordination of implementation services (“services orchestration”)
• Coordination of business processes (“processes choreography”)
• Security management

During the ESB lab we will learn the benefits of using ESB, how applications that operate using different data types and transport technologies can be easily integrated. We will cover a wide view all the aspects of the ESB using Mule. The student will learn how to create and integrate service components using ESB in simple scenarios.

Installation and Configuration

Mule ESB is a lighweight Enterprise Service Bus and integration framework that allows us to easily and quickly integrate applications and enable them to exchange data. It can handle services and applications using different transport and messaging technologies. A complete list of technologies that are known to work with Mule are listed in: http://www.mulesoft.org/display/MULE2INTRO/Compatible+Technologies

For installing Mule, we can use maven, ant or Mule IDE for Eclipse. For these lessons we will use the Mule IDE for Eclipse.

Follow the steps in the Mule webpage: http://www.mulesoft.org/display/MULE2INTRO/Installing+Mule

Lesson 1 – Hello World

Summary

In this lesson the student will learn to build a hello world ESB Mule application. We will walk through the example in order to understand the basics of the Mule framework, how service components are built and how they communicate with each others. Finally, the student will develop and integrate a service component to the application.

In this lesson we will cover the following aspects:

1. Installation of the ESB Mule framework and plugins for eclipse.
2. Creation of a Mule application
3. Overview of the XML configuration (schema,namespace,global connectors, model, services)
4. Inbound Routers
5. Components
6. Outbound Routers
7. Transformers

Hello World Example

In this example we will create an application in Mule ESB using Mule IDE with Eclipse. The Mule IDE let us quickly create a new project, which can be based on existing examples. In this case we will use the Hello World example that is a simple approach yet cover a lot of aspect in order to get familiar with Mule.

1) Creating and running the Hello World Example

Creating the Application

1. In Eclipse Workbench, choose File > New > Project, expand the Mule folder and select Mule Project, and then click Next.
2. Enter the name HelloApp, ensuring that there is no space in the project name.
3. Click Add sample project content and select the Hello example.
4. Click Next, and then click the Libraries tab and verify that the Java 5 or later library is installed and available on the build path.
   
5. Click Finish to have the Mule IDE generate your project.
   

Running the application

1. In the Package Explorer, expand the conf directory, and right-click the hello-config.xml configuration file.
2. Choose Run As > Mule Server.

Package and Deploy the JAR and Configuration File

1. In Eclipse, right-click the project and choose Export.
2. Expand the Java folder, select JAR file, and then click Next.
3. Make sure Export generated class files and resources is selected and the other options are deselected.
4. Specify a location and name for the JAR file, and then click Finish. Eclipse creates the JAR file.
5. Copy the JAR file to the lib\user directory under your Mule home directory.
6. Copy the configuration file to the conf directory under your Mule home directo

To run the application using the jar, use the following command at the command prompt:

2) Walking through the Hello World Example

The example consist of two service components:

1. Greeter: recieves the name of the person from STDIO, append the word “hello” to the data and send it to the ChitChat service component.
2. ChitChat: recieves the payload and append “How are you?” to the data and it deliver the data to STDIO.

Creating a mule application consist basically on creating a configuration file that points to the java classes that implement any custom logic on the message that come through. Lets open the configuration file of the example (hello-config.xml) and walk through the configuration.

The configuration file consist of:

XML declaration

Namespaces declaration

Each Mule transport or module has its own xml schema and namespace.

Global Connectors

There are different ways to configure a transport. The best practice is to use the <connector> element in order to define global connector configuration. The connector element must be prefixed by the namespace of its transport. In the example is configured the STDIO connector:

Configure the Model and the Services

Services components are contained within models. Therefore, we first define the model element <model> follow by the services.

Inbound

The inbound element is used to configure inbound endpoints and inbound routers. Endpoints are used to receive incoming messages, and inbound routers determine how these messages are routed. Inbound endpoints and routers are configured separately within the <inbound> element. In the ChitChat service is defined an inbound-endpoint which indicates which transport uses (vm), the path/address to receive messages from (path=“chitchatter”), and the current transformer to apply before past the payload to the component. We can define different inbound-endpoint for each service component with different transport such as jms, http, axis, bpm, among others. See available transport for more info.

For more information, see Inbound Routers, and Configuring Endpoints

Transformers

Each service component can expect as input different data types, in that case we need to transform the payload to the corresponding expected data type for the component. To achieve this Mule has defined the notion of transformers, which can be referenced before the message reach to the component (inbound-endpoint) or after being processed. Mule provides a set of standards transformer (http://www.mulesoft.org/display/MULE2USER/Using+Transformers#UsingTransformers-ref) out of the box, but in this example we will see custom implementation of transformers in order to learn how to implement our own transformers. Custom transformer must be declared outside the model element:

Component

The <component> element configures the service component that will be invoked after the inbound message is processed by the inbound routers. If no component is configured, the service acts as a bridge and simply passes messages through to the outbound router. The component contain the business logic for working with the messages passed through Mule ESB. This service component can be any type of object, including POJO, script, Spring bean, web service, or REST call. In the ChitChat service the component is a simple Java Object which implements the business logic. When no entry point is defined, Mule uses an entry point resolver to dynamically choose the method to invoke based on the payload type of the message.

For more information, see Developing Service Components

Outbound

The <outbound> element configures outbound routers and their endpoints. Because outbound routers are used to determine which endpoints to use for dispatching messages after the component has finished processing them, outbound endpoints are configured on the outbound routers, not directly on the <outbound> element. Outbound routers allow the developer to define multiple routing constraints for any given message. In our example the <pass-through-router> is used, which simply sends or dispatches the message via the one endpoint it has configured, which is the system out endpoint, before deliver the message it apply a custom transformer to the payload.

More info: Outbound Routers

Wiring the Components

Now, let see how the first service component Greeter interact with the ChitChat component. The Greeter service component accepts the input the user types at the prompt, calls the Greeter class, and forwards the message to an internal queue called vm://chitchatter on which the ChitChat service component is listening. A transformation is performed before the message payload is delivered to the Greeter component and after the component has finished processing it.

ChitChat service component description

3) Exercise

Now, we are going to add a new service component called “ChitPresenter” to the model. The new service component will be listening the channel that the Greeter component uses to send its message. The new component will add a presentation phrase like “My name is Diego” to the message payload, and send it to another channel where the ChitChat component is listening to.

For Homework

Change the expected data type of the service component you have already developed (if you have not already done) and build your own transformers. Also, add more inbound-endpoint to the Greeter component using different transport protocol such as http, axis, etc.

Lesson 2 – Stock Quote

Summary

In this section we will learn how to define service components using external services, invoking them using SOAP and REST. We will introduce the message filters by specifying conditions that the message should met to be routed to a service. In this lab we will create a new project based on the stock quote example and we will extend it based on the described scenario.

The lesson will cover the following aspect:

1. Custom filter implementation
2. External service invocation (REST and Soap)
3. Chaining routers, synchronous request.

1) The Stock Quote Scenario

The Stock Quote example consists of a service component that receives a company symbol as input and invokes an external service using REST and SOAP to get the stock quote of the company and return it to the user.

Now, lets suppose that we have the following new scenario:

The value provided by the component is not updated, in the sense that the value change very often and the data is only refreshed every 10 minutes. Therefore, we may get an outdated value from that service. Now, let suppose we want to add a new service for the GOLD customers who pay for a real time data. To achieve this we will develop a new service component that will return an updated stock quote value (fake service). Then, we will use the power of filters to dispatch the message to the corresponding channel by checking in the message payload if the user is gold.

We will start by creating a new application based on the stock quote example and learn how to define a component using external services.

Creating the application

Follow the same instruction described in lesson 1 for creating a new project and select the Stock Quotes Example instead.

Open the stdio-config.xml:

The synchronous attribute in the inbound-endpoint element makes the component to recieve the message and the component processes before sending it out on another endpoint. HTTP/S, SSL, TCP, and Servlet endpoint are synchronous by default and do not require to set it.

The chaining-router element is a fast and lightweight configuration for sending message to an endpoint and then sending the result to the next endpoint. In the example the result of the service component that is listening on vm://stockquote will be the input for the next component which is the system out.

Configuring a service component using a REST service.

The following component uses an external REST service as the component of the service. It recieves the payload message containing the company symbol and invoke a REST service. The responseTransformer-refs=”ToString XmlDecoder Xslt XmlToObject” indicates that after procesing the request, the resultant payload should pass through the following transformers:

XmlDecoder: decodes a String or byte[] containing xml entities

XSLT: transform the resultant xml into our desired format.

XmlToObject: map the xml to a java object.

Similar configuration is used to invoke with SOAP using axis, which is detailed in stockquote-soap-config.xml

2) Filters

The filters are used in order to specify conditions that a message must met to be routed to a service. Mule provides standard filters that we can use such as payload, or we can develop our own filter. Here is a brief summary of the filters implemented by Mule:

• Payload Type Filter: check the class type
• Expression Filter: it evaluates the payload using a range of expressions (JXPath, OGNL).
• RegEx: for regular expression pattern.
• Wildcar: it applies a wildcar pattern to the message payload.
• Exception Type Filter: to match with an exception type
• Message Property Filter: based on the property of the message.
• Logic Filters: AND, OR, NOT logic filters.

Here, we develop all the logic of our filter in the class org.mule.example.stockquote.FilterGoldUser, the class simple check if the user is gold returning true or false. If the filter return true, the message will go through channel vm://stockquotegold, otherwise will check the next router and dispatch to the vm://stockquote channel.

The student should create a filter that will check if the message comes from a gold customer. If the message mets the condition, it will be routed to the stock quote service for gold customers, otherwise it will be routed to the standard “free” service.

Hints

Firts, create the new component which uses the same input format as the one in the example. Then, define a new object type for the input data (such as StockQuoteRequest) which contains the name of the person and the symbol. Finally, create the filter and transform the data before send the message.

 
Lesson 3 – Sales Broker (Pub/Sub)

Summary
In this lesson the student will learn how to implement a Mule ESB app using publish/subscribe messaging. In this lesson we will integrate an external JMS broker that is running in the cloud to our ESB application. The student will create the publisher and the subscribers thought the ESB application, and finally he will simulate a scenario by publishing message and adding dynamically subscribers to topics.

Scenario
Many companies notify to their costumers about promotion/discount of their products via pub/sub mechanism. Each company creates a topic on which they send the promotions of their products. The customers that are interested in recieving the promotions subscribe to that topic. The problem is that we are having many companies and the final user must know about them, even more he has to subscribe to each of them.  Now, because we know about this problem and we want to make life easier, we are planning to provide to the end user a easier way to get the bargains. We will create an intermediate service (broker) that will subscribe to the topics of the companies/stores. Then, we will create our “Deals” topic in which we will send all the promotions to the end user in order that they can just subscribe to our service and receive all the promotions. We also want to clean a the data and send only the promotions that are really interesting. Therefore we will apply a filter to the message in order to check the percentage of discount, and if they are above a threshold we send to our topic.

Installing JMS Provider
Mule can work with a lot of JMS providers. In this lesson we learn also how we can easily integrate an external JMS provider (ActiveMQ) into our ESB project.

For this lesson we can either:
1) Use an active broker that i set up in the cloud (see if the proxy allows)
BrokerURL: tcp://ec2-184-73-34-161.compute-1.amazonaws.com:61616

2) Install ActiveMQ locally.
Go to http://activemq.apache.org/download.html and get the latest release of ActiveMQ.
Follow the instructions to quickly setup the jms broker provider.

Lets start..

Create a new Project
For this lesson we will create a new esb project from the scratch. Please follows the steps:
In Eclipse:
1) File->New Project->Mule->Mule Project

2) Create the configuration file inside the conf folder: RightClick->NewFile->mule-config.xml

Add the schema location for the modules and transport (mule/spring/jms/stdio/tcp)

Now, set up the JMS provider (ActiveMQ) adding the following configuration to the file

Now lets proceed to create the service component that will subscribe to the company’s topics. In the inbound router we set up the topics that our service component is subscribe to, using jms as transport protocol. In the outbound router we define our topic on which we will deliver the message after filtering the content. In this way, we put all the subscriptions in the inbound router and the publishing in the outbound.

Example:

If you are using the cloud broker, please append a personal identifier to the topic in order to diferenciate your topic from other students (if you prefer to not share). Example: topic=”mynameMyTopic”

Filter
Create a filter for the promotions base on some criteria. One possible criteria is to assume that the message will have the percentage of disccount, we parse the information y define a threshold that the message should met before send to our “deal” topic. For example. just send promotions that have at least 20% off.

Test your application:
Using ActiveMQ Administrator
You can use the administration web of the ActiveMQ to see your topics and the the current status.
If you are running locally, go to: http://localhost:8161/admin/topics.jsp and you should get something similar to this page. You can use the operations to send messages to any of the topics.

Using Java
You can also test it using java. Find on http://project-icebar.net/bpm/pub-sub/ two java files i have prepared, you can use the Consumer class for subscribing to a topic, and the producer class to publish in a topic. Put the java files into your Mule project in order to have the correct references for the javax.jms implementation.

Exercise
Finally, use the java files and simulate the scenario. You can create some topics and start publishing data (randomly). The service component will consume the messages, filter and publish the messages to our new topic. You can also create other service components in your Mule application.

Click here to download the Script