How to Integrate Apache ActiveMQ with Mule ESB?

9

From the technical center of excellence of Massil Technologies, our technology leader Srini makes it easy to understand the complex situations you come across in Mule ESB from the experience of Massil Technologies to have countered them in their experience of working on client projects in real time. This blog addresses how to integrate Apache ActiveMQ with Mule ESB. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

What is ActiveMQ?

Apache ActiveMQ is the most reputed and powerful messaging and integration patterns server in opensource. The best part of ActiveMQ is that it is lightning fast, supports multiple languages, clients and protocols. It comes with easy to use Enterprise Integration Patterns and vast gamete of advanced features that completely supports JMS 1.1 and J2EE 1.4.

Key Features of ActiveMQ:

Source: http://activemq.apache.org/

  • Supports a variety of Cross Language Clients and Protocols from Java, C, C++, C#, Ruby, Perl, Python, PHP
  • OpenWire for high-performance clients in Java, C, C++, C#
  • Stomp support so that clients can be written easily in C, Ruby, Perl, Python, PHP, ActionScript/Flash, Smalltalk to talk to ActiveMQ as well as any other popular Message Broker
  • AMQP v1.0 support
  • MQTT v3.1 support allowing for connections in an IoT environment.
  • Full support for the Enterprise Integration Patterns both in the JMS client and the Message Broker
  • Supports many advanced features such as Message Groups, Virtual Destinations, Wildcards and Composite Destinations
  • Fully supports JMS 1.1 and J2EE 1.4 with support for transient, persistent, transactional and XA messaging
  • Spring Support so that ActiveMQ can be easily embedded into Spring applications and configured using Spring’s XML configuration mechanism
  • Tested inside popular J2EE servers such as TomEE, Geronimo, JBoss, GlassFish and WebLogic
  • Includes JCA 1.5 resource adaptors for inbound & outbound messaging so that ActiveMQ should auto-deploy in any J2EE 1.4 compliant server
  • Supports pluggable transport protocols such as in-VM, TCP, SSL, NIO, UDP, multicast, JGroups and JXTA transports
  • Supports very fast persistence using JDBC along with a high-performance journal
  • Designed for high-performance clustering, client-server, peer-based communication
  • REST API to provide technology agnostic and language-neutral web-based API to messaging
  • Ajax to support web streaming support for web browsers using pure DHTML, allowing web browsers to be part of the messaging fabric
  • CXF and Axis Support so that ActiveMQ can be easily dropped into either of these web service stacks to provide reliable messaging
  • Can be used as an in-memory JMS provider, ideal for unit testing JMS

Integrating ActiveMQ in Mule ESB:

Run ActiveMQ in your system by downloading ActiveMQ from the following link

http://activemq.apache.org/activemq-5150-release.html

Download the package that is most suitable for your system. Extract the file and run batch file of ActiveMQ. It will be located in the bin folder of ActiveMQ.

Example C:\apache-ActiveMQ-5.15.0\bin

To run the batch file use this command in your command prompt ” ActiveMQ start”. Then it will run on your system at port no: 8161

You will find your admin portal at “http://localhost:8161/admin”

When you log in to your admin panel, it will prompt you with a dialogue box where you need to enter the username and password details as “admin” and “admin” as the default username and password for ActiveMQ.

You will see that there are two channels available to send a message to JMS:

  • Queue
  • Topic

The above image is explained with an example. In this example, we are going to create a topic called “Test”.

In Mule ESB, AnyPoint Studio, we follow the following steps:

Step-1: Create a new project

Step-2: Add HTTP connector from Mule pallet and configure it.

Step-3: Add JMS connector. Configure it as shown below

  • Select topic in under Basic Settings

  • Add connector configuration it will ask username and password which were used to login to your admin portal of ActiveMQ.

  • Add an ActiveMQ .jar file to the project. if you don’t find activeMQ.jar file go to ActiveMQ package downloader you can find activeMQ.jar.

Step-4: In this example to see the output we are adding a logger to the flow and writing a MEL expression #[payload]

Step-5: Run the Project

Step-6:

After successful running of the project go to the postman and send a message and hit send. Check the log for output.

Hope this article from Massil Technologies was useful for you. If you have any further queries on this topic, please reach out to info@massil.tech.

 

MuleESB Array list Initialization

8

From the technical center of excellence of Massil Technologies, our technology leaders make it easy to understand the complex situations you come across in Mule ESB from the experience of Massil Technologies to have countered them in their experience of working on client projects in real time. This blog talks about initiating array list in Mule ESB. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

We will look at a scenario where we have set few different array lists in Mule ESB. Lets try with an example of initializing five various array list variable at a place mention below:

<set-variable variableName=”customerIds” value=”#[[]]” doc:name=”customerIds”/>

Let us look at the multiple steps involved in this.

Step 1:- Create a project and find http listener in Mule ESB Palette and transform it to the message flow and configure as follows

Step 2:- Accumulate the data in flexible which is now in Payload (i.e data which is approaching from post man) as follows

Step 3:- Make a new multiple Array List with help of Message Properties Transformer. The configurations for creating empty numerous Array List as follows:

 

Step 4:- Move a expression connector from Mule ESB Palette to contain message flow following the variable and we will enhance the data which we are transferring from postman into unoccupied multiple Array List as follows

Step 5:-Drag the set payload and we have to write the code for print the data present in Array Lists as output

Step 6:- Complete flow is appearance here.

Step 7:-Run the project and hit some data from postman to display the results

Hence, we have gone through the step by step process to depict the way Massil Technologies team has addressed the client need. Hope this article from Massil Technologies was useful for you. If you have any further queries on this topic, please reach out to info@massil.tech.

How to replace the value in the json payload in Mule ESB?

7

From the technical center of excellence of Massil Technologies, our technology leaders make it easy to understand the complex situations you come across in Mule ESB from the experience of Massil Technologies to have countered them in their experience of working on client projects in real time. This blog introduces how to replace the value in the json payload in Mule ESB. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

From many situations we have seen in Mule ESB, we think replacing the value for binarycontent element with some string where the input and output are in JSON is worthy a discussion. Replacing this with some simple string “file content” for logging purpose as the binary content will take multiple pages to print. Lets consider an example where input and desired output are as follows:

Input: { “userId”: 1234, “userEmail”: “test@xyz.com”, “name”: “Test”, “documents”: [ { “binaryContent”: “VGVzdGluZyBEb2NNYW4gUkVTVCBBUEk=”, “comments”: “Hello Request”, “fileName”: “hello.pdf”, “documentType”: “General”, “attributes”: [ { “id”: 1, “name”: “Date Created”, “value”: “12/31/2020” }, { “id”: 2, “name”: “Version”, “value”: “V1” }] } ] }

Desired output: { “userId”: 1234, “userEmail”: “test@xyz.com”, “name”: “Test”, “documents”: [ { “binaryContent”: “file content”, “comments”: “Hello Request”, “fileName”: “hello.pdf”, “documentType”: “General”, “attributes”: [ { “id”: 1, “name”: “Date Created”, “value”: “12/31/2020” }, { “id”: 2, “name”: “Version”, “value”: “V1” }] } ] }

Here are the steps listed below:

Step 1:-Create a project and search http listener in Mule Palette and drag it to the message flow and configure as follows:

Step 2:- Keep the JSON to Object Transformer After the Http To convert JSON to object.

Step 3 : Drag an expression connector from mule Palette to message flow after the logger for looping the incoming json data.

Step 4:-Keep an expression in for each and write a Mule expression to replace the value in incoming Json.

Step 5:-Drag the Object to JSON transformer to print the JSON data to the output.

Step 6:- Complete flow is here.

Step 7:-Run the project and after successful deployment hit some data from postman to see the results

Hence, we have gone through the step by step process to depict the way Massil Technologies team has addressed the client need. Hope this article from Massil Technologies was useful for you. If you have any further queries on this topic, please reach out to info@massil.tech.

Scatter-Gather In Mule

6

From the technical center of excellence of Massil Technologies, our technology leaders make it easy to understand the complex situations you come across in Mule ESB from the experience of Massil Technologies to have countered them in their experience of working on client projects in real time. This blog introduces the role of Scatter-Gather In Mule. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

Scatter-Gather:-

The routing information processor Scatter-Gather transfer a request message to several destinations simultaneously. It got the responses from all routes and summation them into a particular message.

Massil Technologies are providing some references to get total idea about Scatter-Gather in Mule ESB.

Step 1: Initially, create a project and search File connector in Mule ESB Palette and move it to the Message flow and configure as follows

Step 2:- Use the same transformers after succeeding the File connector to convert coming format of the file based on requirement as displayed below

Scatter-Gather In Mule02-massiltechnologies
Scatter-Gather In Mule02

Step 3:- Change the Scatter-Gather connector from Mule ESB Palette message flow later the transformer String to Byte Array as given.

Step 4:- Then, Use the file connectors in scatter-gather, with help of that the incoming file will divided into several and store in the multiple targets.

Step 5:-Maintain the step 4 to keep the file connectors as you expect as shown:

Step 6:- Complete flow is shown below.

Step 7:- Continue the project and later successful deployment, keep a file in the contained source folder and verify whether the targeted folder is packed with incoming files.

Hence, we have gone through the step by step process to depict the way Massil Technologies team has addressed the client need. Hope this article from Massil Technologies was useful for you. If you have any further queries on this topic, please reach out to info@massil.tech.

SonarQube in Mule ESB

5

From the technical center of excellence of Massil Technologies, our technology leaders make it easy to understand the complex situations you come across in Mule ESB from the experience of Massil Technologies to have countered them in their experience of working on client projects in real time. This blog introduces the role of SonarQube. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

Download  the sonarQube by using the below link:

https://www.sonarqube.org/

later extract the contain Zip folder and run the start sonar batch file which is accessible in the bin folder of sonarqube.

Following entry into the browser with path localhost:9000

If the batch file executes correctly then the following screen should appear in the browser.

SonarQube in Mule ESB01-massiltechnologies
SonarQube in Mule ESB01

Analysing the project  with the sonarQube:

Install the sonar-runner with help of the given link:

http://repo1.maven.org/maven2/org/codehaus/sonar/runner/sonar-runner-dist/2.4/sonar-runner-dist-2.4.zip

Extract the zip file.

Make a configuration file within the root directory of the project: sonar-project.properties

# must be genuine in a provided SonarQube instance

sonar.projectKey=my: project

# name should be appearance like in the SonarQube UI

sonar.projectName=My project

sonar.projectVersion=1.0

# Path is similar to the sonar-project.properties file. Replace “\” by “/” on Windows.

# Since SonarQube 4.2, this property is ur wish optional if sonar.modules is properly set.

# If not happen, SonarQube initially began searching for source code from the directory containing

# the sonar-project.properties file.

sonar.sources=.

# Encoding of the source code. Default is default system encoding

#sonar.sourceEncoding=UTF-8

Run the subsequent command based the project base directory to organize the analysis: sonar-runner

SonarQube in Mule ESB02-massiltechnologies
SonarQube in Mule ESB02
SonarQube in Mule ESB03-massiltechnologies
SonarQube in Mule ESB03

 

SonarQube in Mule ESB04-massiltechnologies
SonarQube in Mule ESB04
SonarQube in Mule ESB05-massiltechnologies
SonarQube in Mule ESB05

 

SonarQube in Mule ESB06-massiltechnologies
SonarQube in Mule ESB06
SonarQube in Mule ESB07-massiltechnologies
SonarQube in Mule ESB07

 

Hence, we have gone through the step by step process to depict the way Massil Technologies team has addressed the client need. Hope this article from Massil Technologies was useful for you. If you have any further queries on this topic, please reach out to info@massil.tech.

Custom Filter in Mule ESB

4

From the technical center of excellence of Massil Technologies, our technology leaders make it easy to understand the complex situations you come across in Mule ESB from the experience of Massil Technologies to have countered them in their experience of working on client projects in real time. This blog talks about applying custom filering logic in Mule ESB. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

We have come across an interesting aspect with one of our clients while working on Mule ESB. The use case talks about applying custom filter logic in Mule ESB. While applying standard filters in Mule ESB, we can also generate a custom filter with exact set of conditions that needs to fulfilled before executing a flow. We have explained this use case with an example below:

 

Consider an example of a user-implemented custom filter. The minimum configuration needed is related to the particular class where filter is being implemented. With Use of a Custom filter to reference a user-applied filter. Note that the reference is to a class implementing the Filter interface. The Filter Class is essential if this has been a global filter.

Step 1:-Make a project and find HTTP listener in Mule Palette and move it to the Message flow and configure as given below

Step 2:- Look for Object to String Transformer in Mule Palette and transform it to the Message flow afterward the Http listner

Step 3:- Generate a java class in src/main/java for custom filtering as shown

PayloadFilter.java :

package com.filter;

import org.mule.api.MuleMessage;

import org.mule.api.routing.filter.Filter;

public class PayloadFilter implements Filter {

/**

* This class implements a custom Mule filter.

*/

@Override

public boolean accept(MuleMessage input) {

boolean msgValidated = false;

try {

String payloadStr = input.getPayloadAsString();

if (payloadStr != null && (payloadStr.trim().length() > 0)) {

if (payloadStr.contains(“@”)) {

msgValidated = true;

} else

return false;

} else {

return false;

}

} catch (Exception e) {

e.printStackTrace();

msgValidated = false;

}

return msgValidated;

}

}

Step 4:- Currently, Search for message filter in Mule Palette and change it to the Message flow & configure as follows

Step 5:- Put the set payload to print the success message if the filtering is done.

Step 6:- Total flow is depicted as follows:

Step 7: Run the project and on successful deployment hit certain data which covers “@”, “.” from postman to understand the results

INPUT1 : krishna.p@massil.tech

 

INPUT2 : Krishna massil

Hence, we have gone through the step by step process to depict the way Massil Technologies team has addressed the client need. Hope this article from Massil Technologies was useful for you. If you have any further queries on this topic, please reach out to info@massil.tech.

Converting list hashmap into Array using Dataweave in Mule ESB

3

From the technical center of excellence of Massil Technologies, our technology leaders make it easy to understand the complex situations you come across in Mule ESB from the experience of Massil Technologies to have countered them in their experience of working on client projects in real time. This blog talks about converting list hashmap into Array using Dataweave in Mule ESB. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

Converting list hashmap into Array using Dataweave in Mule ESB:

The Given list can be transformed to array as shown below

List is like : [{customerId=”123″},{customerId=”456″},{customerId=”786″}]

Converted Array is like : [123,456,786]

Step 1:

Create a Mule ESB Project and add HTTP listener connector to Mule Flow and connect a set payload to the flow as shown below:

Step 2:

Add JSON to object earlier the setpayload to transform the JSON payload to object format in json to object Return class as java.lang.Object.

Step 3:

Attach an object to JSON subsequently the payload and add Transform Message to the flow to convert the hash map list to an array. Write in transform message to convert list to array is as below:

—————————————————————————————————————–

%dw 1.0

%output application/java

payload.customerId map $ as :number


Step 4:

Enhance setpayload and write in payload as #[payload] and add an object to json at the conclusion of the flow and run the project

Output:

Given input as: [{“customerId”:”123″},{“customerId”:”456″},{“customerId”:”786″}]

OutPut: [123, 456, 786]

Hence, we have gone through the step by step process to depict the way Massil Technologies team has addressed the client need. Hope this article from Massil Technologies was useful for you. If you have any further queries on this topic, please reach out to info@massil.tech.

How to iterate array inside an array in Mule ESB?

2

From the technical center of excellence of Massil Technologies, our technology leaders make it easy to understand the complex situations you come across in Mule ESB from the experience of Massil Technologies to have countered them in their experience of working on client projects in real time. This blog talks about how to Iterate array inside an array in Mule ESB. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

While working on a project, we had to work on to repeat an array inside a different array and attempting to generate an array list.

We have the list input below:

  1. <flow name=”test”>
  2. <set-variable variableName=”A” value=”#[[‘1′,’2’]]” doc:name=”Variable” />
  3. <set-variable variableName=”B” value=”#[[‘1′,’2′,’3’]]” doc:name=”Variable” />
  4. <dw:transform-message doc:name=”Transform Message”>
  5. <dw:set-payload><![CDATA[%dw 1.0
  6. %output application/java
  7. A map   ((a,aIndex) -> {
  8. (flowVars.B map ((b,bIndex) ->{
  9. aIndex: aIndex,
  10. bIndex: bIndex
  11. }))
  12. })]]></dw:set-payload>
  13. </dw:transform-message>
  14. <logger level=”INFO” message=”#[payload]”></logger>
  15. </flow>

The expected output is shown below:

  1. [
  2. {aIndex=0, bIndex=0},
  3. {aIndex=0, bIndex=1},
  4. {aIndex=0, bIndex=2},
  5. {aIndex=1, bIndex=0},
  6. {aIndex=1, bIndex=1},
  7. {aIndex=1, bIndex=2}
  8. ]

Despite of running in Data-weave , the output is as following:

  1. [{aIndex=0, bIndex=2}, {aIndex=1, bIndex=2}]

The above output appears as Data-weave is substituting the inner array value with other value.  The solution is depicted below:

Use the below Xml Flow:

<?xml version=“1.0” encoding=“UTF-8”?>

<mule xmlns:json=“http://www.mulesoft.org/schema/mule/json” xmlns:http=“http://www.mulesoft.org/schema/mule/http” xmlns:dw=“http://www.mulesoft.org/schema/mule/ee/dw”

xmlns=“http://www.mulesoft.org/schema/mule/core” xmlns:doc=“http://www.mulesoft.org/schema/mule/documentation”

xmlns:spring=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xsi:schemaLocation=“http://www.mulesoft.org/schema/mule/ee/dw http://www.mulesoft.org/schema/mule/ee/dw/current/dw.xsd

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-current.xsd

http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/current/mule.xsd

http://www.mulesoft.org/schema/mule/http http://www.mulesoft.org/schema/mule/http/current/mule-http.xsd

http://www.mulesoft.org/schema/mule/json http://www.mulesoft.org/schema/mule/json/current/mule-json.xsd”>

<http:listener-config name=“HTTP_Listener_Configuration” host=“0.0.0.0” port=“8081” doc:name=“HTTP Listener Configuration”/>

<flow name=“test”>

<http:listener config-ref=“HTTP_Listener_Configuration” path=“/arraylist” allowedMethods=“GET” doc:name=“HTTP”/>

<set-variable variableName=“A” value=“#[[‘1′,’2’]]” doc:name=“Variable” />

<set-variable variableName=“B” value=“#[[‘1′,’2′,’3’]]” doc:name=“Variable” />

<dw:transform-message doc:name=“Transform Message”>

<dw:set-payload><![CDATA[   %dw 1.0

%output application/java

flatten (flowVars.A map ((a, aIndex) ->

flowVars.B map ((b, bIndex) -> {

aIndex: aIndex,

bIndex: bIndex

})

))

]]></dw:set-payload>

</dw:transform-message>

<logger level=“INFO” message=“#[payload]” doc:name=“Logger”></logger>

<json:object-to-json-transformer doc:name=“Object to JSON”/></flow>

</mule>

Dataweave script:

%dw 1.0

%output application/java

flatten (flowVars.A map ((a, aIndex) ->

flowVars.B map ((b, bIndex) -> {

aIndex: aIndex,

bIndex: bIndex

})

))

 

Expected output:

  1. [
  1. {aIndex=0, bIndex=0},
  2. {aIndex=0, bIndex=1},
  3. {aIndex=0, bIndex=2},
  4. {aIndex=1, bIndex=0},
  5. {aIndex=1, bIndex=1},
  6. {aIndex=1, bIndex=2}
  7. ]

 

RESULT:

[

{

“aIndex”: 0,

“bIndex”: 0

},

{

“aIndex”: 0,

“bIndex”: 1

},

{

“aIndex”: 0,

“bIndex”: 2

},

{

“aIndex”: 1,

“bIndex”: 0

},

{

“aIndex”: 1,

“bIndex”: 1

},

{

“aIndex”: 1,

“bIndex”: 2

}

]

Hope this article from Massil Technologies was useful for you. If you have any further queries on this topic, please reach out to info@massil.tech.

All you need to know about Mule ESB at a glance

1

From the technical center of excellence of Massil Technologies, our technology leader Srini makes it easy to understand MuleSoft ESB at a glance. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

On their website, MuleSoft defines Mule ESB as “Mule, the runtime engine of Anypoint Platform is a lightweight Java-based enterprise service bus (ESB) and integration platform that allows developers to connect applications quickly and easily, enabling them to exchange data. It enables easy integration of existing systems, regardless of the different technologies that the applications use, including JMS, Web Services, JDBC, HTTP, and more. The ESB can be deployed anywhere, can integrate and orchestrate events in real time or batch, and has universal connectivity.”

Usually, Enterprise Service Bus (ESB) allows multiple applications to connect with each other by acting as a technology interface for carrying data between applications over an intranet or across the world wide web. Mule ESB has luxurious features such as service creation and hosting, service management, message routing based on rules defined and data transformation across different formats and predefined protocols. These features make Mule ESB the most flexible ESB in the open source community.

Why Mule ESB?

Light Weight Open Source Platform
Highly Scalable
Manages communications among applications and components effectively
Ability to transparently communicate with the server or over the internet or any other transport protocol.
Highly Flexible to adopt
Being Open Source, it is vendor neutral – It gels along with any application from any vendor
Supports data transformation in multiple formats across multiple frameworks
Cost Effective and highly reliable.
Key Details:

It supports Desktops, Laptops and Android, iOS devices.
It is suitable for Small, Medium and Large Enterprises given its scalability feature.
Most Mule ESB implementations have been done in the markets of Asia, India, Australia, Canada, China, Europe, Germany, Japan, Latin America, Middle-East and Africa, United Kingdom and the United States.
It only supports the English language.
The different pricing options available are: Free Trail, Freemium, Open Source and Subscription (Mule ESB Enterprise)
Mule ESB Features:

Easy User Interface with drag and drop design
Transparent data mapping, defining business logic and data transformation
It is a Collection of hundreds of prebuilt and verified connectors.
Easy to deploy in cloud or on-premise
High-end enterprise security features
High availability and reliability of right grouping
Mainstream Java development tool framework
Connector Development Kit for Enhanced Scalability
Complete Monitoring and Control through Mule ESB management console
Application Deployment with repository
Total Application Control – Start/Stop/Restart
Intelligence based monitoring and alert mechanisms
Real-time performance configuration
Privileges as per user role
Secure connectivity for Cloud/On-Premise
API management
Service Repository and Logs
Advantages Over Competition:

Licensed ESB solutions sit over a framework that is associated with a vendor, and there would be some limitations in functionality and connectivity with other vendor applications. Being an opensource Mule ESB is no vendor-centric, which means it can easily connect and communicate with any application in any environment or framework.

The components in Mule ESB can be defined in any way you like. It can easily integrate a primary java object to another component in a different framework.
Mule ESB keeps business logic entirely aside from messaging logic, unlike other frameworks.
Mule ESB allows significant component reuse.
Messages and data can be in any format without causing any design constraints.
Mule ESB helps decrease time to market and increase productivity with its highly scalable and high-security features.
Mule ESB architecture is capable of handling billions of transactions per day across thousands of servers in a highly distributed environment.
We have outlined the definition of Mule ESB, Key Details, Features and the advantage of Mule ESB over the competition. Though Massil Technologies works on other licensed ESB solutions or a combination of tools based on requirement, our expertise says about 75% of integration requirements we work, and Mule ESB fits into place without any complexity. To know more about our use cases with Mule ESB, please reach us at info@massil.tech

How to choose an efficient Middleware to suite your system integration needs?

m8

From the technical center of excellence of Massil Technologies, our technology leader Srini writes on how you can choose an efficient Middleware for your integration needs based on our expertise of having integrated complex IT scenarios. This blog is a part of series of blogs being authored and published by Massil Technologies for the benefit of the IT community globally.

The dependability on applications is increasing day by day, which makes it essential to ensure that your Middleware is very much in place. Middleware is a software that is placed and operates between an operating system and the application that runs on it. It is a hidden translation layer that facilitates communication and data management for various applications, which is also referred to as plumbing. Middleware’s job is to establish contact between two applications so that data and databases can be exchanged. In a way, middleware helps users to execute requests on the web browser or any dynamic web pages.

Some examples of middleware comprise database middleware, application server middleware, web middleware, and transaction-processing monitors. It also enables security authentication, transaction management, queuing the messages, and managing the directories. It can be further used for distributed processing that takes place in real time.

What is an ESB?

Referred to as Enterprise Service Bus (ESB) is primarily an architecture with a set of rules that enable integration of various application across an infrastructure that resembles a bus. Fundamentally, ESB products help users to build these kinds of architecture with the multiple capabilities that they bring. ESB architecture functions in a way to enable each application to communicate with the bus. This disintegrates systems from one another and allows them to communicate without many interdependencies.

Choosing an ESB platform/tool   

There are Proprietary as well as Open Source tools in the market for ESB implementation. However, the tool should be considered based on Usability, Maintainability, Community support, Enterprise support, Functionality, Flexibility, Scalability, and cost. Many organizations prefer Open Source tools for its intrinsic benefits. A case in point is Mule, the runtime engine of any point Platform, which is known for being a lightweight Java-based enterprise service bus (ESB) and an integration platform enables developers to integrate applications together and exchange data in a much faster and seamless manner.

Irrespective of the various technologies leveraged by an application, Mule enables easy connection. It can be deployed anywhere and can connect and coordinate events on a real-time basis. Some of the key features of MuleSoft are:

  • It is Lightweight

Mule is a lightweight integration platform that is loaded with distribution weighing at 40MB with a modular design to reduce the footprint. It’s not only about the size; it is light regarding costs that enable changes to the current integrations and the heavy lifting that is needed for making changes. It further offers modularization and super-speed hot deployment with a configuration model that enables easy to re-order and added functionalities.

  • Accessibility and easy learning

As with any Open Source tool, Mule can be easily comprehended by Java developers or any developer with experience in Maven, Eclipse, JUnit, and Spring. It uses an XML configuration model for defining logic and custom code that can be written in various languages such as Java, Groovy, JavaScript, Ruby or Python. The MuleStudio can further enable new developers to accelerate their efforts in a graphical development environment.

  • Massive Scalability

It is exciting and resourceful to know that Mule has been designed for horizontal scaling on commodity hardware. Its runtime can efficiently be embedded into an application with application servers such as Tomcat, JBoss or WAS or directly in your application. This a massive feature, as it implies that you can create recurring unit tests for integration on a developer’s laptop on a continuous basis.

  • It is built for the Cloud

CloudHub is an integration Platform as a Service (iPaaS) that helps you to get up and running in very less time. It is a multi-loaded and scalable platform with as many as 150+ SaaS connectivity points, Social Media and infrastructure services with ability to connect to on-premise applications. Moreover, there is no need to build any new capabilities to operate on this platform. This makes it developer-friendly.

In Conclusion:

While we speak at length about open source ESB tools such as Mule, there is a very strong reason why enterprises are choosing Open Source over Proprietary tools. Though Licensed tools offer ease and reliability, Open Source enables more experimentation and innovation which is Community-driven. It’s not just a product you can choose and implement, but it is a product/tool that enables more experimentation. In this case, MuleSoft is being leveraged by enterprises, as it understands the ESB architecture and brings value to the overall process. At the end it is the business value that counts while choosing a tool for a kind of implementation.