This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/master by this push:
new fe3f2ab Regen
fe3f2ab is described below
commit fe3f2ab609bada281352719eea2aa11b05b319ef
Author: Claus Ibsen <claus.ib...@gmail.com>
AuthorDate: Wed Feb 20 08:55:19 2019 +0100
Regen
---
docs/components/modules/ROOT/nav.adoc | 1 -
.../modules/ROOT/pages/jcache-component.adoc | 234 ++++++++++++++++++++
.../modules/ROOT/pages/jcache-policy.adoc | 235 ---------------------
3 files changed, 234 insertions(+), 236 deletions(-)
diff --git a/docs/components/modules/ROOT/nav.adoc
b/docs/components/modules/ROOT/nav.adoc
index 5b6f698..e8f8c46 100644
--- a/docs/components/modules/ROOT/nav.adoc
+++ b/docs/components/modules/ROOT/nav.adoc
@@ -163,7 +163,6 @@
* xref:jaxb-dataformat.adoc[JAXB DataFormat]
* xref:jbpm-component.adoc[JBPM Component]
* xref:jcache-component.adoc[JCache Component]
-* xref:jcache-policy.adoc[JCache Policy]
* xref:jclouds-component.adoc[JClouds Component]
* xref:jcr-component.adoc[JCR Component]
* xref:jdbc-component.adoc[JDBC Component]
diff --git a/docs/components/modules/ROOT/pages/jcache-component.adoc
b/docs/components/modules/ROOT/pages/jcache-component.adoc
index 8bd9cc5..4543447 100644
--- a/docs/components/modules/ROOT/pages/jcache-component.adoc
+++ b/docs/components/modules/ROOT/pages/jcache-component.adoc
@@ -106,3 +106,237 @@ The JCache component supports 5 options, which are listed
below.
| *resolveProperty Placeholders* (advanced) | Whether the component should
resolve property placeholders on itself when starting. Only properties which
are of String type can use property placeholders. | true | boolean
|===
// component options: END
+
+== JCache Policy
+
+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, 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.
+
+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.
+
+Similar caching solution is available for example in Spring using the
@Cacheable annotation.
+
+=== JCachePolicy Fields
+
+
+[width="100%",cols="2,5,3,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *cache* | The Cache to use to store the cached values. If this value is set,
_cacheManager_, _cacheName_ and _cacheConfiguration_ is ignored. | | Cache
+| *cacheManager* | The CacheManager to use to lookup or create the Cache. Used
only if _cache_ is not set. | Try to find a CacheManager in CamelContext
registry or calls the standard JCache
_Caching.getCachingProvider().getCacheManager()_. | CacheManager
+| *cacheName* | Name of the cache. Get the Cache from cacheManager or create a
new one if it doesn't exist. | RouteId of the route. | String
+| *cacheConfiguration* | JCache cache configuration to use if a new Cache is
created | Default new _MutableConfiguration_ object. | CacheConfiguration
+| *keyExpression* | An Expression to evaluate to determine the cache key. |
Exchange body | Expression
+| *enabled* | If policy is not enabled, no wrapper processor is added to the
route. It has impact only during startup, not during runtime. For example it
can be used to disable caching from properties. | true | boolean
+|===
+
+## How to determine cache to use?
+
+
+### Set cache
+
+The cache used by the policy can be set directly. This means you have to
configure the cache yourself and get a JCache Cache object,
+ but this gives the most flexibility. For example it can be setup in the
config xml of the cache provider (Hazelcast, EhCache, ...)
+ and used here. Or it's possible to use the standard Caching API as below:
+
+
+[source,java]
+----------------------------
+MutableConfiguration configuration = new MutableConfiguration<>();
+configuration.setTypes(String.class, Object.class);
+configuration.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new
Duration(TimeUnit.MINUTES, 60)));
+CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();
+Cache cache = cacheManager.createCache("orders",configuration);
+
+JCachePolicy jcachePolicy = new JCachePolicy();
+jcachePolicy.setCache(cache);
+
+from("direct:get-orders")
+ .policy(jcachePolicy)
+ .log("Getting order with id: ${body}")
+ .bean(OrderService.class,"findOrderById(${body})");
+----------------------------
+
+### Set cacheManager
+
+If the _cache_ is not set, the policy will try to lookup or create the cache
automatically.
+ If the _cacheManager_ is set on the policy, it will try to get cache with the
set _cacheName_ (routeId by default) from the CacheManager.
+ Is the cache does not exist it will create a new one using the
_cacheConfiguration_ (new MutableConfiguration by default).
+
+[source,java]
+----------------------------
+//In a Spring environment for example the CacheManager may already exist as a
bean
+@Autowire
+CacheManager cacheManager;
+...
+
+//Cache "items" is used or created if not exists
+JCachePolicy jcachePolicy = new JCachePolicy();
+jcachePolicy.setCacheManager(cacheManager);
+jcachePolicy.setCacheName("items")
+----------------------------
+
+### Find cacheManager
+
+If _cacheManager_ (and the _cache_) is not set, the policy will try to find a
JCache CacheManager object:
+
+* Lookup a CacheManager in Camel registry - that falls back on JNDI or Spring
context based on the environment
+* Use the standard api _Caching.getCachingProvider().getCacheManager()_
+
+[source,java]
+----------------------------
+//A Cache "getorders" will be used (or created) from the found CacheManager
+from("direct:get-orders").routeId("getorders")
+ .policy(new JCachePolicy())
+ .log("Getting order with id: ${body}")
+ .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})_.
+ We can set a different Camel Expression as _keyExpression_ which will be
evaluated to determine the key.
+ For example if we try to find an _order_ by an _orderId_ which is in the
message headers,
+ set _header("orderId")_ (or _simple("${header.orderId})_ as _keyExpression_.
+
+The expression is evaluated only once at the beginning of the route to
determine the _key_. If nothing was found in cache,
+ this _key_ is used to store the _value_ in cache at the end of the route.
+
+[source,java]
+----------------------------
+MutableConfiguration configuration = new MutableConfiguration<>();
+configuration.setTypes(String.class, Order.class);
+configuration.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new
Duration(TimeUnit.MINUTES, 10)));
+
+JCachePolicy jcachePolicy = new JCachePolicy();
+jcachePolicy.setCacheConfiguration(configuration);
+jcachePolicy.setCacheName("orders")
+jcachePolicy.setKeyExpression(simple("${header.orderId}))
+
+//The cache key is taken from "orderId" header.
+from("direct:get-orders")
+ .policy(jcachePolicy)
+ .log("Getting order with id: ${header.orderId}")
+ .bean(OrderService.class,"findOrderById(${header.orderId})");
+----------------------------
+
+## 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.
+
+If the determined _key_ is _null_, nothing is looked up or stored in cache.
+
+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.
diff --git a/docs/components/modules/ROOT/pages/jcache-policy.adoc
b/docs/components/modules/ROOT/pages/jcache-policy.adoc
deleted file mode 100644
index ea24b2e..0000000
--- a/docs/components/modules/ROOT/pages/jcache-policy.adoc
+++ /dev/null
@@ -1,235 +0,0 @@
-[[jcache-policy]]
-== JCache Policy
-
-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, 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.
-
-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.
-
-Similar caching solution is available for example in Spring using the
@Cacheable annotation.
-
-=== JCachePolicy Fields
-
-
-[width="100%",cols="2,5,3,2",options="header"]
-|===
-| Name | Description | Default | Type
-| *cache* | The Cache to use to store the cached values. If this value is set,
_cacheManager_, _cacheName_ and _cacheConfiguration_ is ignored. | | Cache
-| *cacheManager* | The CacheManager to use to lookup or create the Cache. Used
only if _cache_ is not set. | Try to find a CacheManager in CamelContext
registry or calls the standard JCache
_Caching.getCachingProvider().getCacheManager()_. | CacheManager
-| *cacheName* | Name of the cache. Get the Cache from cacheManager or create a
new one if it doesn't exist. | RouteId of the route. | String
-| *cacheConfiguration* | JCache cache configuration to use if a new Cache is
created | Default new _MutableConfiguration_ object. | CacheConfiguration
-| *keyExpression* | An Expression to evaluate to determine the cache key. |
Exchange body | Expression
-| *enabled* | If policy is not enabled, no wrapper processor is added to the
route. It has impact only during startup, not during runtime. For example it
can be used to disable caching from properties. | true | boolean
-|===
-
-## How to determine cache to use?
-
-
-### Set cache
-
-The cache used by the policy can be set directly. This means you have to
configure the cache yourself and get a JCache Cache object,
- but this gives the most flexibility. For example it can be setup in the
config xml of the cache provider (Hazelcast, EhCache, ...)
- and used here. Or it's possible to use the standard Caching API as below:
-
-
-[source,java]
-----------------------------
-MutableConfiguration configuration = new MutableConfiguration<>();
-configuration.setTypes(String.class, Object.class);
-configuration.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new
Duration(TimeUnit.MINUTES, 60)));
-CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();
-Cache cache = cacheManager.createCache("orders",configuration);
-
-JCachePolicy jcachePolicy = new JCachePolicy();
-jcachePolicy.setCache(cache);
-
-from("direct:get-orders")
- .policy(jcachePolicy)
- .log("Getting order with id: ${body}")
- .bean(OrderService.class,"findOrderById(${body})");
-----------------------------
-
-### Set cacheManager
-
-If the _cache_ is not set, the policy will try to lookup or create the cache
automatically.
- If the _cacheManager_ is set on the policy, it will try to get cache with the
set _cacheName_ (routeId by default) from the CacheManager.
- Is the cache does not exist it will create a new one using the
_cacheConfiguration_ (new MutableConfiguration by default).
-
-[source,java]
-----------------------------
-//In a Spring environment for example the CacheManager may already exist as a
bean
-@Autowire
-CacheManager cacheManager;
-...
-
-//Cache "items" is used or created if not exists
-JCachePolicy jcachePolicy = new JCachePolicy();
-jcachePolicy.setCacheManager(cacheManager);
-jcachePolicy.setCacheName("items")
-----------------------------
-
-### Find cacheManager
-
-If _cacheManager_ (and the _cache_) is not set, the policy will try to find a
JCache CacheManager object:
-
-* Lookup a CacheManager in Camel registry - that falls back on JNDI or Spring
context based on the environment
-* Use the standard api _Caching.getCachingProvider().getCacheManager()_
-
-[source,java]
-----------------------------
-//A Cache "getorders" will be used (or created) from the found CacheManager
-from("direct:get-orders").routeId("getorders")
- .policy(new JCachePolicy())
- .log("Getting order with id: ${body}")
- .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})_.
- We can set a different Camel Expression as _keyExpression_ which will be
evaluated to determine the key.
- For example if we try to find an _order_ by an _orderId_ which is in the
message headers,
- set _header("orderId")_ (or _simple("${header.orderId})_ as _keyExpression_.
-
-The expression is evaluated only once at the beginning of the route to
determine the _key_. If nothing was found in cache,
- this _key_ is used to store the _value_ in cache at the end of the route.
-
-[source,java]
-----------------------------
-MutableConfiguration configuration = new MutableConfiguration<>();
-configuration.setTypes(String.class, Order.class);
-configuration.setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(new
Duration(TimeUnit.MINUTES, 10)));
-
-JCachePolicy jcachePolicy = new JCachePolicy();
-jcachePolicy.setCacheConfiguration(configuration);
-jcachePolicy.setCacheName("orders")
-jcachePolicy.setKeyExpression(simple("${header.orderId}))
-
-//The cache key is taken from "orderId" header.
-from("direct:get-orders")
- .policy(jcachePolicy)
- .log("Getting order with id: ${header.orderId}")
- .bean(OrderService.class,"findOrderById(${header.orderId})");
-----------------------------
-
-## 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.
-
-If the determined _key_ is _null_, nothing is looked up or stored in cache.
-
-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.
-
