= Ehcache Component
:doctitle: Ehcache
:shortname: ehcache
:artifactid: camel-ehcache
:description: Perform caching operations using Ehcache.
:since: 2.18
:supportlevel: Stable
:component-header: Both producer and consumer are supported
//Manually maintained attributes
:camel-spring-boot-name: ehcache

*Since Camel {since}*

*{component-header}*

The Ehcache component enables you to perform caching operations using
Ehcache 3 as the Cache Implementation.

The Cache consumer is an event based consumer and can be used to listen
and respond to specific cache activities. 

Maven users will need to add the following dependency to
their `pom.xml` for this component:

[source,xml]
------------------------------------------------------------
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-ehcache</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
------------------------------------------------------------

== URI format

-----------------------------
ehcache://cacheName[?options]
-----------------------------

// component-configure options: START

// component-configure options: END

// component options: START
include::partial$component-configure-options.adoc[]
include::partial$component-endpoint-options.adoc[]
// component options: END

// endpoint options: START

// endpoint options: END



=== Message Headers Camel 

 
[width="100%",cols="10%,10%,80%",options="header",]
|=======================================================================
|Header |Type |Description

|CamelEhcacheAction |`String` |The operation to be perfomed on the cache, valid options are:

* CLEAR
* PUT
* PUT_ALL
* PUT_IF_ABSENT
* GET
* GET_ALL
* REMOVE
* REMOVE_ALL
* REPLACE

|CamelEhcacheActionHasResult |Boolean |Set to true if the action has a result

|CamelEhcacheActionSucceeded |`Boolean` |Set to true if the actionsuccedded

|CamelEhcacheKey |Object |The cache key used for an action

|CamelEhcacheKeys |Set<Object> |A list of keys, used in

* PUT_ALL
* GET_ALL
* REMOVE_ALL

|CamelEhcacheValue |Object |The value to put in the cache or the result of an operation

|CamelEhcacheOldValue |Object |The old value associated to a key for actions like PUT_IF_ABSENT or the
Object used for comparison for actions like REPLACE

|CamelEhcacheEventType |EventType |The type of event received
|=======================================================================

== Ehcache based idempotent repository example:

[source,java]
------------------------------------------------------------------------------------------------
CacheManager manager = CacheManagerBuilder.newCacheManager(new XmlConfiguration("ehcache.xml"));
EhcacheIdempotentRepository repo = new EhcacheIdempotentRepository(manager, "idempotent-cache");
 
from("direct:in")
    .idempotentConsumer(header("messageId"), idempotentRepo)
    .to("mock:out");
------------------------------------------------------------------------------------------------

 

== Ehcache based aggregation repository example:

[source,java]
---------------------------------------------------------------------------------------------------------------------------------
public class EhcacheAggregationRepositoryRoutesTest extends CamelTestSupport {
    private static final String ENDPOINT_MOCK = "mock:result";
    private static final String ENDPOINT_DIRECT = "direct:one";
    private static final int[] VALUES = generateRandomArrayOfInt(10, 0, 30);
    private static final int SUM = IntStream.of(VALUES).reduce(0, (a, b) -> a + b);
    private static final String CORRELATOR = "CORRELATOR";

    @EndpointInject(ENDPOINT_MOCK)
    private MockEndpoint mock;

    @Produce(uri = ENDPOINT_DIRECT)
    private ProducerTemplate producer;

    @Test
    public void checkAggregationFromOneRoute() throws Exception {
        mock.expectedMessageCount(VALUES.length);
        mock.expectedBodiesReceived(SUM);

        IntStream.of(VALUES).forEach(
            i -> producer.sendBodyAndHeader(i, CORRELATOR, CORRELATOR)
        );

        mock.assertIsSatisfied();
    }

    private Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
        if (oldExchange == null) {
            return newExchange;
        } else {
            Integer n = newExchange.getIn().getBody(Integer.class);
            Integer o = oldExchange.getIn().getBody(Integer.class);
            Integer v = (o == null ? 0 : o) + (n == null ? 0 : n);

            oldExchange.getIn().setBody(v, Integer.class);

            return oldExchange;
        }
    }

    @Override
    protected RoutesBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            @Override
            public void configure() throws Exception {
                from(ENDPOINT_DIRECT)
                    .routeId("AggregatingRouteOne")
                    .aggregate(header(CORRELATOR))
                    .aggregationRepository(createAggregateRepository())
                    .aggregationStrategy(EhcacheAggregationRepositoryRoutesTest.this::aggregate)
                    .completionSize(VALUES.length)
                        .to("log:org.apache.camel.component.ehcache.processor.aggregate.level=INFO&showAll=true&mulltiline=true")
                        .to(ENDPOINT_MOCK);
            }
        };
    }

    protected EhcacheAggregationRepository createAggregateRepository() throws Exception {
        CacheManager cacheManager = CacheManagerBuilder.newCacheManager(new XmlConfiguration("ehcache.xml"));
        cacheManager.init();

        EhcacheAggregationRepository repository = new EhcacheAggregationRepository();
        repository.setCacheManager(cacheManager);
        repository.setCacheName("aggregate");

        return repository;
    }
}
---------------------------------------------------------------------------------------------------------------------------------


include::spring-boot:partial$starter.adoc[]
