anchor.diff:      .bean(OrderService.class,"findOrderById(${header.orderId})");
   ----------------------------
   
  -## Special scenarios and error handling
  +## Camel XML DSL examples
  +
  +### Use JCachePolicy in an XML route
  +
  +In Camel XML DSL we need a named reference to the JCachePolicy instance (registered in CamelContext or simply in Spring).
  + We have to wrap the route between <policy>...</policy> tags after <from>.
  +
  +[source,xml]
  +----------------------------
  +<camelContext xmlns="http://camel.apache.org/schema/spring">
  +    <route>
  +        <from uri="direct:get-order"/>
  +        <policy ref="jCachePolicy" >
  +            <setBody>
  +                <method ref="orderService" method="findOrderById(${body})"/>
  +            </setBody>
  +        </policy>
  +    </route>
  +</camelContext>
  +----------------------------
  +
  +See this example when only a part of the route is wrapped:
  +
  +[source,xml]
  +----------------------------
  +<camelContext xmlns="http://camel.apache.org/schema/spring">
  +    <route>
  +        <from uri="direct:get-order"/>
  +        <log message="Start - This is always called. body:${body}"/>
  +        <policy ref="jCachePolicy" >
  +            <log message="Executing route, not found in cache. body:${body}"/>
  +            <setBody>
  +                <method ref="orderService" method="findOrderById(${body})"/>
  +            </setBody>
  +        </policy>
  +        <log message="End - This is always called. body:${body}"/>
  +    </route>
  +</camelContext>
  +----------------------------
  +
  +
  +### Define CachePolicy in Spring
  +
  +It's more convenient to create a JCachePolicy in Java especially within a RouteBuilder using the Camel DSL expressions,
  + but see this example to define it in a Spring XML:
  +
  +[source,xml]
  +----------------------------
  +<bean id="jCachePolicy" class="org.apache.camel.component.jcache.policy.JCachePolicy">
  +    <property name="cacheName" value="spring"/>
  +    <property name="keyExpression">
  +        <bean class="org.apache.camel.model.language.SimpleExpression">
  +            <property name="expression" value="${header.mykey}"/>
  +        </bean>
  +    </property>
  +</bean>
  +----------------------------
  +
  +### Create Cache from XML
  +
  +It's not strictly speaking related to Camel XML DLS, but JCache providers usually have a way to configure the cache in an XML file.
  + For example with Hazelcast you can add a _hazelcast.xml_ to classpath to configure the cache "spring" used in the example above.
  +
  +[source,xml]
  +----------------------------
  +<?xml version="1.0" encoding="UTF-8"?>
  +<hazelcast xmlns="http://www.hazelcast.com/schema/config"
  +           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  +           xsi:schemaLocation="http://www.hazelcast.com/schema/config hazelcast-config-3.11.xsd" >
  +
  +    <cache name="spring">
  +        <key-type class-name="java.lang.String"/>
  +        <value-type class-name="java.lang.String"/>
  +        <expiry-policy-factory>
  +            <timed-expiry-policy-factory expiry-policy-type="CREATED" duration-amount="60" time-unit="MINUTES"/>
  +        </expiry-policy-factory>
  +    </cache>
  +
  +</hazelcast>
  +----------------------------
  +
  +
  +=== Special scenarios and error handling
   
   If the Cache used by the policy is closed (can be done dynamically), the whole caching functionality is skipped,
    the route will be executed every time.
  
positive.code: 
  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 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.
  
  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.
  
negative.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.
  
  