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.

DevNexus 2011 Atlanta

I am speaking at DevNexus this year about Enterprise Ehcache and how it helps you increase performance and enables you to scale your Java applications easily.  I will walk you through setting up Ehcache and how to distribute to the Terracotta Server Array.  I will also give you a sneak peek at our new Search API and walk you through our visibility tools.

Terracotta will be hosting a booth if you want to stop by for a conversation about Ehcache or anything else.

Look forward to seeing you there!

Eric

Scale your Java applications without ripping up your code

I spend a majority of my day talking to system architects and developers who are trying to scale their applications to keep up with demand.  I recently had someone say to me, "Users want it now...they don't know what they want...but they want it now". He was referring to his web site that receives 10 million plus hits per day where users search for data and if the response is slow, they go elsewhere. When users go elsewhere, he loses revenue and now he is charged with finding a solution.
How can we solve complex scaling and performance problems without refactoring or rewriting our code? One of the best solutions is caching and the best caching solution is Ehcache. Ehcache is the de facto caching solution for the Java community and is embedded in many popular frameworks like Hiberate, Spring, Grails and ColdFusion. Caching brings data closer to your application reducing repetitive calls to your DB, web services, etc. This increases application performance by increasing throughput and reducing latency.
The best part is that 70% of the Java community is using Ehcache so you know it is battle tested. In a recent survey about Ehcache, it was discovered that companies all around the world of every size are solving their scale and performance issues with Ehcache. Take a few minutes and review this whitepaper about Ehcache, http://terracotta.org/resources/whitepapers/ehcache-user-survey-whitepaper. I think you will see that solving complex scale and performance problems can be achieved by simply snapping in Ehcache. To get started using Ehcache, visit http://www.ehcache.org.