anchor.diff:  
   The JCachePolicy is an interceptor around a route that caches the "result of the route" - the message body - after the route is completed.
     If next time the route is called with a "similar" Exchange, the cached value is used on the Exchange instead of executing the route.
  -  The policy uses the JSR107/JCache API of a cache implementation.
  +  The policy uses the JSR107/JCache API of a cache implementation, so it's required to add one (e.g. Hazelcast, Ehcache) to the classpath.
   
   The policy takes a _key_ value from the received Exchange to get or store values in the cache. By default the _key_ is the message body.
     For example if the route - having a JCachePolicy - receives an Exchange with a String body "fruit" and the body at the
     end of the route is "apple", it stores a _key/value_ pair "fruit=apple" in the cache. If next time another Exchange arrives
     with a body "fruit", the value "apple" is taken from the cache instead of letting the route process the Exchange.
   
  -So by default the message body at the beginning of the route is the cache _key_ and the body at the end is the stored _value_. It's possible to use something else as _key_ by setting a Camel Expression via _.setKeyExpression()_
  -that will be used to determine the key.
  +So by default the message body at the beginning of the route is the cache _key_ and the body at the end is the stored _value_.
  +  It's possible to use something else as _key_ by setting a Camel Expression via _.setKeyExpression()_
  +  that will be used to determine the key.
   
   The policy needs a JCache Cache. It can be set directly by _.setCache()_ or the policy will try to get or create the Cache
     based on the other parameters set.
  
positive.code: In case of an exception during the route, the error handled is called as always. If the exception gets _handled()_,
   the policy stores the Exchange body, otherwise nothing is added to the cache.
   If an exception happens during evaluating the keyExpression, the routing fails, the error handler is called as normally.
  
negative.code:     .bean(OrderService.class,"findOrderById(${body})");
  ----------------------------
  
  ### Partially wrapped route
  
  In the examples above the whole route was executed or skipped. A policy can be used to wrap only a segment of the route instead of all processors.
  
  [source,java]
  ----------------------------
  from("direct:get-orders")
      .log("Order requested: ${body}")
      .policy(new JCachePolicy())
          .log("Getting order with id: ${body}")
          .bean(OrderService.class,"findOrderById(${body})")
      .end()
      .log("Order found: ${body}");
  ----------------------------
  
  The _.log()_ at the beginning and at the end of the route is always called, but the section inside _.policy()_ and _.end()_ is executed based on the cache.
  
  ## KeyExpression
  
  By default the policy uses the received Exchange body as _key_, so the default expression is like _simple("${body})_.
  