EhCache Integration with Spring and Hibernate. Step by Step Tutorial

EhCache is a very popular open source caching framework widely used for Java based Caching.

Currently it’s owned by Terracotta.org and 2.5 beta releases is available for download.

In this article I just focused on EhCache Integration with Spring and Hibernate also I just explained few basic concepts which are required to understand Code. For detailed Caching Concepts Please visit http://ehcache.org/

Cache Manager, Caches and Elements are main entities of EhCache

EhCache consists of a CacheManager, which manages Caches. Caches contain Elements, which are essentially name value pairs. Caches are physically implemented either in-memory, or on disk.

Integration with Spring

EhCache integration with Spring is quite simple. You just need to define some properties in spring configuration xml file and its ready to use. Spring is using Annotation to integrate EhCache and by this we can add caching to any method results

EhCache Annotations for Spring is available via maven, simply add the following dependency to your pom.xml  

  <!-- EhCache --> <dependency> <groupId>com.googlecode.ehcache-spring-annotations</groupId> <artifactId>ehcache-spring-annotations</artifactId> <version>1.2.0-M1</version> </dependency> <!—CGLib is also required for EHCache --> <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>2.2.2</version> </dependency>

   

Next Step is to perform changes in your spring Configuration file. Below is my Spring configuration file which contains EhCache configurations

<?xml version="1.0" encoding="UTF-8" standalone="no"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ehcache="http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring http://ehcache-spring-annotations.googlecode.com/svn/schema/ehcache-spring/ehcache-spring-1.1.xsd"> <context:component-scan base-package="com.eiconsulting"/> <mvc:annotation-driven /> <ehcache:annotation-driven cache-manager="cacheManager" /> <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean"> <property name="configLocation" value="/WEB-INF/ehcache.xml" /> </bean> </beans>

Important point to note here is that Cache Manager Name and its Configuration Location. We can use cacheManager in our code to store and retrieve information from Cache.

ehcache.xml file is configuration file for EhCache where we can define configuration details of EhCache. In my case here is content of my ehcache.xml file

<?xml version="1.0" encoding="UTF-8"?> <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"> <defaultCache eternal="true" maxElementsInMemory="100" overflowToDisk="false" /> <cache name="customer" maxElementsInMemory="10" eternal="true" overflowToDisk="false" /> </ehcache>

Here it’s clear that we have created a cache with name Customer, I will use this Cache to store Customer details

Next step is to use it in your code. In my example I created a simple Spring based application where we have Customer Controller which is used to retrieve Customer Information

We have Customer Object with Customer Id, name and address details and related setter getter methods

public class Customer { public String address; public String name; public String id;

Next step is to create Controller. Customer Controller is very simple. I am using Spring Restful Web services to retrieve Customer Information. In my Controller I have no logic related to EhCache. I just have two versions of getCustomer method (one with Annotation and one without Annotation), save Customer and Clear Cache method. Code is simple and self explanatory for any Spring MVC developer.

package com.eiconsulting.web; import net.sf.ehcache.CacheManager; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.ResponseStatus; import com.eiconsulting.beans.Customer; import com.eiconsulting.services.CustomerService; @Controller public class CustomerController { @Autowired @Qualifier("CustomerService") public CustomerService customerService; @RequestMapping(value="/GetCustomer/{customerId}",method={RequestMethod.GET}) @ResponseStatus(HttpStatus.OK) public @ResponseBody String getCustomer(@PathVariable String customerId){ Customer c=customerService.getCustomer(customerId); return c.toString(); } @RequestMapping(value="/GetCachedCustomer/{customerId}",method={RequestMethod.GET}) @ResponseStatus(HttpStatus.OK) public @ResponseBody String getCachedCustomer(@PathVariable String customerId){ Customer c=customerService.getCachedCustomer(customerId); return c.toString(); } @RequestMapping(value="/ClearCache",method={RequestMethod.GET}) @ResponseStatus(HttpStatus.OK) public @ResponseBody String clearCache(){ boolean result=customerService.clearCache(); if(result) return "Sucessfully Cache Cleaned"; else return "Not able to Clean Cache"; } @RequestMapping(value="/SaveCustomer/{customerId}",method={RequestMethod.GET}) @ResponseStatus(HttpStatus.OK) public @ResponseBody String saveCustomer(@PathVariable String customerId){ Customer c=new Customer(); c.setId(customerId); c.setAddress("New Address"); c.setName("New Name"); boolean result=customerService.saveCustomer(c); if(result) return "Sucessfully Saved Customer"; else return "Not able to Save Customer"; } }

If you notice Controller is calling Customer Service. Customer Service is our main class and it’s used to get Customer Information. It can get information from Database using Hibernate or from any backend. Here I just provided basic implementation. Idea is to understand usage of EhCache

Following Service methods are used to retrieve and store information in Cache

@Autowired public CacheManager cacheManager; public boolean saveCustomer(Customer customer){ Cache cache=cacheManager.getCache("customer"); cache.put(new Element(customer.getId(),customer)); return true; } public Customer getCachedCustomer(String customerId){ Cache cache=cacheManager.getCache("customer"); return (Customer)cache.get(customerId).getObjectValue(); }

     

Previously we have defined “cacheManager” object in our Spring.xml file and also we have defined a Cache with name “customer” in ehcache.xml file. Its time to use both these configurations

getCache method is use to retrieve Cache Object and we are storing new Element in this cache. Element requires key, value pair so I am using id filed as a key. Later on we can use same key to retrieve Customer Object from Cache.

Another great way of using EhCache is Spring Annotation

@Cacheable(cacheName="customer") public Customer getCustomer(String customerId){ Customer c=new Customer(); c.setId(customerId); c.setName("Adeel Shafqat"); c.setAddress("Address"); return c; }

   

Add Cacheable Annotation to methods you would like to cache. In our case we are using it for getCustomer method. If we call getCustomer method with customerId 1, first time complete method will be called. If we will call this method again with same customerId then response will be returned from Cache.

To Clear Cache we can just use TriggerRemove Annotation

 @TriggersRemove(cacheName = "customer", when = When.AFTER_METHOD_INVOCATION, removeAll = true) public boolean clearCache(){ return true; }

Complete Source Code is present at following location

https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B0YFdqXJcI3mY2ZiYzA4NWQtNmQ0ZS00ZWM0LTlkMzktMmM3YmJmZjUzNDEy&hl=en_US

Integration with Hibernate as a Second Level Cache

Hibernate uses different type of Caches

·         The first cache type is the session cache. The session cache caches object within the current session.

·         The second cache type is the query Cache. The query cache is responsible for caching queries and their results.

·         The third cache type is the second level cache. The second level cache is responsible for caching objects across sessions.

EhCache is used as second level cache. EhCache integration with Hibernate is quite simple as well. You just need to define some properties in persistence.xml file.

EhCache jars are available via maven, simply add the following dependency to your pom.xml  

  <dependency> <groupId>net.sf.ehcache</groupId> <artifactId>ehcache-core</artifactId> <version>2.4.5</version> </dependency>

   

Next step is to perform changes in persistence.xml  

 <property name="hibernate.cache.region.factory_class" value="net.sf.ehcache.hibernate.EhCacheRegionFactory"/> <property name="hibernate.cache.use_query_cache" value="true"/> <property name="hibernate.cache.use_second_level_cache" value="true"/> <property name="hibernate.cache.provider_class" value="net.sf.ehcache.hibernate.EhCacheProvider" /> <property name="hibernate.cache.provider_configuration_file_resource_path" value="ehcache.xml" />

 Put ehcache.xml at your classpath. It could be in classes or WEB-INF folder

 <?xml version="1.0" encoding="UTF-8"?> <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"> <defaultCache eternal="true" maxElementsInMemory="100" overflowToDisk="false" /> <cache name="messages" maxElementsInMemory="10" eternal="true" overflowToDisk="false" /> </ehcache>

In you Entity just add Annotations related to ehcache and thats it.

 @Entity @Table(name="MESSAGES") @Cache(region = "messages", usage = CacheConcurrencyStrategy.READ_WRITE) public class Message {

Complete Source Code is present at following location

https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0B0YFdqXJcI3mMDJiMDU4MmUtZWFkYy00MTAxLWFjMmYtMWYyMGNhMWY2Mjdj&hl=en_US