Jos Dirksen

+ Follow
since Jun 30, 2003
Merit badge: grant badges
For More
Cows and Likes
Total received
In last 30 days
Total given
Total received
Received in last 30 days
Total given
Given in last 30 days
Forums and Threads
Scavenger Hunt
expand Ranch Hand Scavenger Hunt
expand Greenhorn Scavenger Hunt

Recent posts by Jos Dirksen

We didn't do a feature for feature comparison of Mule and ServiceMix in the book. We do however implement all the examples for both these ESBs. So with regards to functionality offered they are pretty much equal.

There are a couple of differences though between these ESBs;
For instance ServiceMix is much more XML focussed and has a more extensive deployment mechanisms and Mule is more lightweight and flexible

Both though are very mature ESBs with lots of functionality.
You're right configuring the integration flows for at least Mule and ServiceMix is done using a couple of simple XML files. For Mule an IDE is being developed which has more graphical support.

Normally though this isn't much of issue. Both ServiceMix and Mule have XSDs which are very finegrained and tell you what is allowed in the configuration.

Personally I like this approach beter then the graphical configuration offered by some of the commercial ESBs, since I can better understand what happens.
It's a bit too soon for external reviews. We're however currently getting things setup for external reviews so you expect those fairly soon.
I think it's a bit in the middle. We explain the concepts of ESBs and show how to apply these concepts (routing, transformation, security, connectivity etc.) in practice using Mule and ServiceMix.

So basically the concepts are explained using concrete examples from Mule and ServiceMix.
Another issue which might influence your choice is the deployment model. When using ServiceMix you have hot-deploy for your services, components and flows. You get the 'overhead' and complexity of JBI but you've got a very mature, standarized deployment model.

Mule is a more lightweight ESB, but doesn't support hot deploy (yet).

As Tijs already mentioned the new version of ServiceMix will be OSGi based which should make deployment even easier. That said Mule also has plans to change it's deployment model to OSGi...
Usually when working with larger systems or creating an enterprise wide service architecture, you'll also have some sort of a service registry where clients can search for services.

With the found information they can then invoke the service using it's definition. An added advantage of this is that it provides a nice point to start with the governance of service. For instance define when a service is available, what service levels are supported, how you're billed for using this service etc.

But SOA governance is a whole other discussion, a very interesting one though.
Since Tijs has problems logging in, I'll post his answer to this question:

It's important to remember that when you want to use transactions with an ESB the ESB handles the transaction management. This means that you can't start a transaction in application 1 and use that one throughout the ESB for the communication with application 2.

ESBs however can be used together with JTA, JMS or JSBC transactions. So if you connect with the applications using these technologies, you can use the ESBs to handle the transactions.

Note though that the ESBs do support XA transactions, but unfortunately not much other products do. So you can use XA transactions together with JMS and JDBC, but usually when you want to use this with other applications your often forced to buy expansive custom adapters for this.
Transporting data is indeed one of the features of an ESB. More important though are an ESB's routing, transformation and connectivity features.

And it's not just between two points, you can also split up messages, send them to multiple targets, aggregate them back. You can do this based on content, type, format etc.

To speak in buzzwords you can use an ESB as the base of your service oriented architecture.
There are lots of popular open source ESBs.

What we see however is that the two most popular at this moment are Mule and ServiceMix.

And new interesting one though which has recently gained a lot of attention is Spring Integration.

Probably the easiest ESB to get started with is Mule. It provides a low entry level, very powerful ESB. If you're interested in a JBI compliant ESB to get started with ServiceMix is probably the easiest.
We focus on ServiceMix and Mule, but also show a couple examples with openESB, Petals and Spring integration.

The book can also be used to get you started with ESBs. We start off slowly by introducing the concepts and setting up an environment in which you can run and play around with the examples.

We've tried to introduce more complex topics gradually in the book, all of course supported with examples. So when you're interested in ESBs, regardless of they are open source or not, I think that we've provided a nice overview of all the different concepts supported with lots of examples.
The book is intended for both beginners but also covers more advanced topics. With the book we start by introducing and explaining what ESBs are and why you'd need them.

After that we slowly introduce the two main ESBs we cover with some basic examples and demos so you can get a feel for these two ESBs. After that we show you how you can setup the environment (nothing more then running an ant script) so you easily play around with the examples we provide.

After the first introduction chapters we slowly introduce more complex concepts which all are supported by examples.

Thanks for the introduction, hope we can answer the questions, and I'll hope the readers here will enjoy the book.

In our book we decided to focus mainly on two ESBs. Mule and ServiceMix. We chose these two since they represent two of the most popular opensource ESBs and also take two different approaches.

ServiceMix takes the JBI approach (such as openESB and petals) and nicely shows how to work with ServiceMix, but also shows in depth how JBI works.

The other ESB we cover intensily is Mule. Since they provide a lightweight approach to enterprise integration.

Although these two ESBs are the main focus of the book, we also mention other ESBs. We show how you can use Petals components and openESB components and also include an example with Spring Integration.

We wanted to make the book as practical as possible so we've stuffed it with examples showing all the different aspects you encounter when using ESBs. We provide a complete environment where you can run the examples for Mule and ServiceMix. The examples for instance show routing, transformation, connectivity, a seperate chapter on webservices, but also integration with BPEL and jBPM.
Working with ESBs isn't really that hard anymore. With ESBs such as Mule and ServiceMix working with ESBs has become really simple. If you want custom functionality both these ESBs support writing services in standard java.

If you've already got lots of legacy systems (opensource) ESBs provide lots of connectivity options (HTTP / JMS / Mail / etc) to connect to those ESBs.

Some ESBs though are easier to work with then others. OpenESB was already mentioned, and this a JBI compliant ESB (just as ServiceMix). JBI is a JCP standard which defines how integration components communicate with each other. But working with JBI based ESBs however does require some knowledge of how JBI works. Mule on the other hand use a more 'pragmatic' or proprietary approach, which makes it very easy to work with.