anchor.diff:  `org.apache.camel.spi.Synchronization` API provides fine grained methods
   for `onCompletion` and `onFailure` for the two situations.
   
  +[source,java]
  +---------------------------------------------------------------------------
  +/**
  + * Our own callback that will gather all the responses.
  + * We extend the SynchronizationAdapter class as we then only need to override the onComplete method.
  + */
  +private static class MyCallback extends SynchronizationAdapter {
  +
  +  // below the String elements are added in the context of different threads so that we should make
  +  // sure that this's done in a thread-safe manner, that's no two threads should call the data.add()
  +  // method below concurrently, so why we use Vector here and not e.g. ArrayList
  +  private final List<String> data = new Vector<>();
  +
  +  @Override
  +  public void onComplete(Exchange exchange) {
  +    // this method is invoked when the exchange was a success and we can get the response
  +    String body = exchange.getOut().getBody(String.class);
  +    data.add(body);
  +
  +    // the latch is used for testing purposes
  +    LATCH.countDown();
  +  }
  +
  +  public List<String> getData() {
  +    return data;
  +  }
  +}
  +---------------------------------------------------------------------------
  +
   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.
  +
  +
  +[source,java]
  +---------------------------------------------------------------------------
  +MyCallback callback = new MyCallback();
  +
  +// Send 3 async request/reply message to the http endpoint
  +// where we let the callback handle gathering the responses
  +String url = "http://localhost:" + getPort() + "/myservice";
  +template.asyncCallbackRequestBody(url, "Claus", callback);
  +template.asyncCallbackRequestBody(url, "Hadrian", callback);
  +template.asyncCallbackRequestBody(url, "Willem", callback);
  +---------------------------------------------------------------------------
   
   [[Async-UsingtheAPIwiththeCamelclassicAPI]]
   Using the Async API with the Camel classic API
  
positive.code: 
  First we define a route in Camel for the <<http-component,HTTP>> service
  where we simulate a slow server as it takes at least 1 second to reply.
  
  Then we define our callback where we gather the responses. As this is
  based on an unit test it just gathers the responses in a list. This is a
  
negative.code: 
  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
  