Caching with Ehcache and Spring Annotations

I meet hundreds of developers and architects every month and they all have the same issues; performance and ability to scale.  These hard to solve problems can be solved with caching and Ehcache provides the best set of tools to quickly and easily get this done. If you are using Spring, you are well on your way to success.  I will provide you the framework to get started caching with Ehcache and Spring; the rest is up to you. 

Let's get started.  I used the Spring 3.1.0.M1 release to build my application with Ehcache 2.4.2. You can use annotations with an older version of spring. Here is the link, http://code.google.com/p/ehcache-spring-annotations/.

Here is my ehcache.xml file:

1. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd" 
2.  updateCheck="false" monitoring="autodetect" dynamicConfig="true" name="Test">
3.   <diskStore path="java.io.tmpdir"/> 
4. 
   
5. 
   
6.   <defaultCache maxElementsInMemory="10000" 
7.                 eternal="false" 
8.                 timeToIdleSeconds="120" 
9.                 timeToLiveSeconds="120" 
10.                 memoryStoreEvictionPolicy="LRU" />
11. 
    
12. 
    
13.     <cache name="Person"
14.     maxElementsInMemory="100" 
15.   eternal="true" 
16.         maxElementsOnDisk="1000" 
17.   memoryStoreEvictionPolicy="LFU">
18.  </cache> 
19. </ehcache>

Call this ehcache.xml file from your Spring context file.

1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3.  xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
4.  xmlns:tx="http://www.springframework.org/schema/tx" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5.  xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
6.  xmlns:cache="http://www.springframework.org/schema/cache"
7.  xsi:schemaLocation="
8.             http://www.springframework.org/schema/beans
9.             http://www.springframework.org/schema/beans/spring-beans.xsd
10.             http://www.springframework.org/schema/aop
11.             http://www.springframework.org/schema/aop/spring-aop.xsd
12.             http://www.springframework.org/schema/tx
13.             http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
14.             http://www.springframework.org/schema/jdbc
15.             http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
16.             http://www.springframework.org/schema/context
17.             http://www.springframework.org/schema/context/spring-context-3.0.xsd
18.             http://www.springframework.org/schema/cache 
19.             http://www.springframework.org/schema/cache/spring-cache.xsd">
20. 
    
21.   <!-- scans the classpath for annotated components (including @Repostory 
22.   and @Service that will be auto-registered as Spring beans -->
23.  <context:component-scan base-package="com.sample.ehcache" />
24. 
    
25.   <!-- Process cache annotations -->
26.  <cache:annotation-driven />
27. 
    
28.   <!-- Configuration for using Ehcache as the cache manager -->
29.  <bean 
30.   id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager" 
31.   p:cache-manager-ref="ehcache"/> 
32.   <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" 
33.   p:config-location="classpath:ehcache.xml"/> 
34. </beans>

The power of the Spring context file is component-scan, annotation-driven and the Ehache entries. The component-scan tells Spring to scan these directories for beans that will be auto registered. Annotation driven turns on the annotations to use with Ehcache.

Next I create a base object that my data access object implement.

1. public interface BaseDao {
2.  
3. /**
4.   * Using the provided key return
5.   * the associated Object from the data
6.   * repository.
7.   * @param key
8.   * @return object having the associated key or
9.   * null if no associated Object is found with the provided
10.   * key
11.   */
12. Object getObject(String key);
13.  
14. /**
15.   * Clears all objects
16.   */
17. void clearObjects();
18.  
19. /**
20.   * clears object by key
21.   * @param key
22.   */
23. void clearObject(String key);
24. }

I implement the BaseDao in the following class and then add the @Cacheable and @CacheEvict annotations.  It is just this simple.

1. @Repository("baseDao")
2. public class PersonDaoImpl implements BaseDao {
3. 
   
4.  private static final Logger LOGGER = Logger.getLogger(PersonDaoImpl.class.getName());
5. 
   
6.   /**
7.   * The @Cacheable automatically puts the data in the cache
8.   */
9.  @Cacheable("Person", key="#key")
10.  public final Person getObject(String key) {  
11.   
12.   Person person = buildPerson(key);
13.   return person;  
14.  }
15. 
    
16.  //stubbed data building
17.  private static Person buildPerson(String key) {
18.   LOGGER.debug("Building new Person object");
19.   
20.   Person person = new Person();
21.   person.setPersonId(key);
22.   person.setFirstName("Joe");
23.   person.setLastName("Smith");
24.   return person;
25.  }
26. 
    
27.   @CacheEvict(value="Person", allEntries=true)
28.  public void clearObjects() {
29.   LOGGER.debug("Person cache evicted...."); 
30.  }
31. 
    
32.  @CacheEvict(value="Person", key="#key")
33.  public void clearObject(String key) {
34.   LOGGER.debug("Person cache evicted...."); 
35.  }
36. }

That is it! Now your data objects are cached on retrieval (doesn't matter where you get the data from) and your application performance will soar to new heights (and so will your status with your peers).  Simple caching is just the beginning. There are loads of great features in Ehcache like Search, JTA, Write-Behind, and many more. Check out the Ehcache web site, www.ehcache.org,  to get the full list of features.