The ability to use a standard for the deployment and management of integration components is essential if integration architects, developers and component vendors are not to be tied to the proprietary API's that have existed to date when deploying within an ESB.

However JBI is quite strict in the way Components are installed and services deployed. JBI mandates that each Component must be installed from an archive, containing a well defined XML descriptor file, and that the archive must be unpacked on the local file system and the installation component provided with it's own working directory, if it requires it.

This strict contract does not lend itself well to ease of use, quick development or testing - and negates some deployment scenarios where you would to use an ESB as a lightweight container embedded in an application fragment or library.

Hence ServiceMix has taken the approach that while JBI is a first class citizen (it's a JBI compliant container) and internally all message flows are routed using JBI constructs (like the Normalized Message Service), components can be additionally deployed as POJOs. ServiceMix is also tightly integrated with the Spring framework, allowing Spring to deploy integration components for you if you so wish within a regular Spring context.

Reliable
ServiceMix is designed to easily support simple and automatic distribution of components and message flows. Internally, ServiceMix distributes events using a plug-able message routing architecture, called a Flow.

By default, ServiceMix supports three Flow types for message routing:

• STP - straight-through interactions, components are interacted with directly. This is ideal for embedded or light weight deployment.
• SEDA (Staged Event Driven Architecture) for scalable message routing
• Clustered - Components seamlessly register themselves with other ServiceMix instances in a cluster, allowing for seamless distributed event propagation

Breadth of Connectivity
ServiceMix can handle any JBI standard component; so components from other open source projects such as PXE from FiveSight or components from the Celtix project should just drop right in.

In addition, ServiceMix comes with a whole raft of reusable JBI components

• SAAJ for working with Soap With Attachments providers such as Apache Axis
• WSIF for working with any Web Service Invocation Framework implementation
• ActiveSOAP and XFire support to provide clean integration with new lightweight SOAP stacks
• Scripting support with JSR 223 or Groovy to allow powerful and agile integration
• HTTP, JMS, email and Jabber transports to provide a general message bus
• JCA support for fast and efficient processing of messaging resources like JMS with connection, session and thread pooling as well as efficient parallel processing and transaction & exception handling
• Quartz and JCA WorkManager support for enterprise timer integration
• Caching support with JCache integration to allow any service invocation to be cached among a cluster based on some correlation or request key (using XPath or Java code to extract the key)
• XSLT support to allow transformations to be used in pipelines
• Reflection, Spring and Mule support for clean POJO integration
• SQL support with Oracles XSQL tool to provide CRUD operations inside message flows

JBI Client API
To make it simpler to use ServiceMix for developers, we've created a JBI Client API which makes it easy to work with any JBI container or any available JBI component.

Using the JBI Interfaces
The following ServiceMix methods provide some helper methods for easier use of the JBI APIs

Sending Messages One Way
This example uses a specific service to make an invocation function call:

InOnly exchange = client.createInOnlyExchange();
NormalizedMessage message = exchange.getInMessage();
message.setProperty("name", "James");
message.setContent(new StreamSource(new StringReader
("<hello>world</hello>")));

// lets use a specific service to dispatch to
QName service = new QName("http://servicemix.org/cheese/","receiver");
exchange.setService(service);
client.send(exchange);

In this example, we assume that the JBI container will have setup a default routing connection for our client, so we don't have to worry about specifying the endpoint.

InOnly exchange = client.createInOnlyExchange();

NormalizedMessage message = exchange.getInMessage();
message.setProperty("name", "James");
message.setContent(new StreamSource(new StringReader
("<hello>world</hello>")));

client.send(exchange);

Invoking Services with InOut Exchanges

InOut exchange = client.createInOutExchange();

NormalizedMessage inMessage = exchange.getInMessage();
inMessage.setProperty("name", "James");
inMessage.setContent(new StreamSource(new StringReader
("<hello>world</hello>")));

// optionally specify the endpoint
exchange.setService(service);

client.sendSync(exchange);
NormalizedMessage outMessage = exchange.getOutMessage();

Using the POJO Methods
Following are a few helper POJO-based methods, provided to allow you to use ServiceMix with regular POJOs to hide some of the JBI's XML marshalling details.