Foreword
I was one of the original founders of both Apache ActiveMQ (an open source high-performance message broker) and ServiceMix (an open source ESB based on JBI and OSGi). I found that Enterprise Integration Patterns were becoming increasingly central to what we were doing on these projects and how we were using them; the only difference was the context and technologies with which we were using the patterns.
There have been many libraries and frameworks over the years to help with integration. But frequently the concepts behind the Enterprise Integration Patterns get transformed into some complex class hierarchies or objects that need to be wired together just so, and the original intentions and patterns are often lost. The developer is forced from then on to focus on the low-level detail and some complex class library API, losing the bigger picture and patterns.
Integration is hard and once you start down the path of integrating things together the code can very easily mushroom; being able to easily comprehend, communicate, adapt, and maintain integration solutions is vital to be able to solve integration problems efficiently in an agile way.
So we decided it was time for a new integration framework that put the EIPs at its core and tried to raise the abstraction level so that developers could describe declaratively in very concise terms what Enterprise Integration Patterns they wanted to use in a simple domain-specific language. Using a convention over configuration approach, developers would declaratively describe what they wanted to do, using the Enterprise Integration Pattern language; it would be both quick and easy to get things done and also very easy for any developer on a team (including the developer himself months after writing the code!) to understand and adapt the code.
There are many different places we wanted to use the EIPs; whether in a standalone application, a web services stack, an enterprise message broker like Apache ActiveMQ, or inside a full-blown ESB like Apache ServiceMix, so we wanted a lightweight framework that was middleware agnostic that users could embed anywhere they wanted it. We also wanted developers to focus on the Enterprise Integration Patterns first and foremost and not to get lost in the weeds of different middleware APIs and technologies.
We also wanted developers to be able to use whatever DSL flavor they wished (whether Java, XML, Groovy, Ruby, Scala, or whatever) and yet, at runtime, still be able to introspect the framework and understand all of the EIPs that were being used. They would be able to visualize the core patterns to the team at any point in the project lifecycle, auto-document the patterns, or even support things like graphical editing of the Enterprise Integration Patterns at design time or runtime.
So Apache Camel was born, and since then we’ve seen the codebase, community, and number of components, technologies, and data formats grow massively as more and more developers have found Apache Camel an ideal way to design, implement, and maintain the Enterprise Integration Patterns.
In this book Claus and Jon describe the Enterprise Integration Patterns and the concepts which underlie Apache Camel. Then they walk you through how to take the concepts and apply them to many real-life scenarios to provide scalable and efficient solutions that are easy to understand and quick to adapt to your integration needs. I hope you’ll enjoy reading this book as much as I did!
JAMES STRACHAN
CO-FOUNDER OF APACHE ACTIVEMQ
CAMEL, AND SERVICEMIX
TECHNICAL DIRECTOR FUSESOURCE.COM