Aggregating multiple web services behind Camel facade

I've found an interesting problem on Stack Overflow. I've answered the question but want to elaborate it a little bit.

The problem

You got two web services. Service A and Service B. The services are independent from each others. You need to create a REST web service that calls the latter services, aggregates the results and returns them to the client.

Some terminology

What we want to achieve here is an example of simple orchestration i.e. coordination of calling of multiple services on the ESB. Orchestration of the services (not necessarily web ones) has been repeatedly raped by many commercial tools and solutions. One of the most prominent example of orchestration's torturer is BPEL.

When we use ESB as a proxy between services we refer to it as Pure ESB. Pure ESB doesn't contain heavyweight processing logic - it only serves as a mediation router.

ServiceMix and Camel are excellent tools for creating lightweight orchestration based on the pure ESB concept.

Aggregation of two or more services can be referred as Aggregating Service, Facade Service or Proxy Service.


Aggregating web services in Camel

We want to call Service A and Service B in parallel (since they are independent), then aggregate the incoming results into a single answer.

The following Camel route is responsible for collecting results from the sub-services (A and B) and aggregating them into single message.

from("direct:serviceAggregator")
  .multicast(new GroupedExchangeAggregationStrategy()).parallelProcessing()
    .enrich("http://servicea.com").enrich("http://serviceb.com")
  .end();

We use multicast pattern to concurrently call two web services. Then multicast uses message enricher pattern to add data from the external services to the original message. When Camel finally finishes aggregation of the results of A and B services' calls, it attaches the latter results to the original message passed to the direct:serviceFacade endpoint. The messages fetched from the A and B services will be stored as exchange property identified by Exchange.GROUPED_EXCHANGE key.

To expose our facade service F on the ESB we will use Camel's Jetty component.

from("jetty:http://0.0.0.0:8080/myapp/myComplexService").enrich("direct:serviceFacade").setBody(property(Exchange.GROUPED_EXCHANGE));

We use enricher again - this time each message passed to the Jetty HTTP connector will be enriched by our aggregating route (direct:serviceAggregator). In practice that means that all request to the HTTP connector exposed as our service will be injected with two additional messages from A and B services. In this particular example we extract data from the received messages and render them as HTTP response to the client.