anchor.diff:  
   The route is the same, so its just how the client initiate and send the
   messages that differs:
  +
  +[source,java]
  +---------------------------------------------------------------------------
  +MockEndpoint mock = getMockEndpoint("mock:result");
  +// We expect the http job to complete before the name job
  +mock.expectedBodiesReceived("Bye World", "Claus");
  +
  +// Send a sync request/reply message to the http endpoint
  +String response = template.requestBody("http://0.0.0.0:" + getPort() + "/myservice", "Hello World", String.class);
  +assertEquals("Bye World", response);
  +
  +// Send a sync request/reply message to the direct endpoint
  +String name = template.requestBody("direct:name", "Give me a name", String.class);
  +assertEquals("Claus", name);
  +
  +assertMockEndpointsSatisfied();
  +---------------------------------------------------------------------------
   
   [[Async-UsingtheAPIwithcallbacks]]
   Using the Async API with callbacks
  
positive.code: `org.apache.camel.spi.Synchronization` API provides fine grained methods
  for `onCompletion` and `onFailure` for the two situations.
  
  And then we have the client API where we call the <<http-component,HTTP>>
  service using `asyncCallback` 3 times with different input. As the
  invocation is Async the client will send 3 requests
  right after each other, so we have 3 concurrent exchanges in progress.
  The response is gathered by our callback so we do not have to care how
  to get the response.
  
  [[Async-UsingtheAPIwiththeCamelclassicAPI]]
  Using the Async API with the Camel classic API
  
negative.code: <<http-component,HTTP>> service is on route. This allows you to be able to
  process the two routes simultaneously:
  
  [source,java]
  ---------------------------------------------------------------------------
  // Some other service to return a name, this is invoked synchronously
  from("direct:name")
    .transform(constant("Claus"))
    .to("mock:result");
  	
  // Simulate a slow http service (delaying 1 sec) we want to invoke async
  from("jetty:http://0.0.0.0:%s/myservice", getPort())
    .delay(1000)
    .transform(constant("Bye World"))
    .to("mock:result");
  ---------------------------------------------------------------------------
  
  And then we have the client API where we call the two routes and we can
  get the responses from both of them. As the code is based on unit test
  there is a bit of mock in there as well:
  
  [source,java]
  ---------------------------------------------------------------------------
  MockEndpoint mock = getMockEndpoint("mock:result");
  // We expect the name job to be faster than the async job even though the async job
  // was started first
  mock.expectedBodiesReceived("Claus", "Bye World");
  	
  // Send a async request/reply message to the http endpoint
  Future<Object> future = template.asyncRequestBody("http://0.0.0.0:" + getPort() + "/myservice", "Hello World");
  	
  // We got the future so in the meantime we can do other stuff, as this is Camel
  // so lets invoke another request/reply route but this time is synchronous
  String name = template.requestBody("direct:name", "Give me a name", String.class);
  assertEquals("Claus", name);
  	
  // Okay we got a name and we have done some other work at the same time
  // the async route is running, but now its about time to wait and get
  // get the response from the async task
  
  // We use the extract future body to get the response from the future
  // (waiting if needed) and then return a string body response.
  // This allows us to do this in a single code line instead of using the
  // JDK Future API to get hold of it, but you can also use that if you want
  // Adding the (String) To make the CS happy
  String response = template.extractFutureBody(future, String.class);
  assertEquals("Bye World", response);
  
  assertMockEndpointsSatisfied();
  ---------------------------------------------------------------------------
  
  All together it should give you the basic idea how to use this
  Async API and what it can do.
  
  