Call us: +1-415-738-4000

Using Spring and BigMemory Go


BigMemory Go's Ehcache supports Spring integration. Spring 3.1 includes an Ehcache implementation. See the Spring 3.1 JavaDoc.

Spring 3.1

Spring Framework 3.1 has a generic cache abstraction for transparently applying caching to Spring applications. It has caching support for classes and methods using two annotations:


Cache a method call. In the following example, the value is the return type, a Manual. The key is extracted from the ISBN argument using the id.

@Cacheable(value="manual", key="")
public Manual findManual(ISBN isbn, boolean checkWarehouse)


Clears the cache when called.

@CacheEvict(value = "manuals", allEntries=true)
public void loadManuals(InputStream batch)

Spring 2.5 - 3.1: Annotations For Spring

This open source, led by Eric Dalquist, predates the Spring 3.1 project. You can use it with earlier versions of Spring, or you can use it with 3.1.


As with Spring 3.1 it uses an @Cacheable annotation to cache a method. In this example, calls to findMessage are stored in a cache named "messageCache". The values are of type Message. The id for each entry is the id argument given.

@Cacheable(cacheName = "messageCache")
public Message findMessage(long id)


For cache invalidation, there is the @TriggersRemove annotation. In this example, cache.removeAll() is called after the method is invoked.

@TriggersRemove(cacheName = "messagesCache",
when = When.AFTER_METHOD_INVOCATION, removeAll = true)
public void addMessage(Message message)

For a blog post explaining its use and providing further links, see .

The Annotations for Spring Project

To dynamically configure caching of method return values, use the Ehcache Annotations for Spring project at This project allows you to configure caching of method calls dynamically. The parameter values of the method are used as a composite key into the cache, caching the return value of the method.

For example, suppose you have a method: Dog getDog(String name).

If caching is added to this method, all calls to the method are cached using the "name" parameter as a key.

So, assume at time t0 the application calls this method with the name equal to "fido". Because "fido" doesn't exist, the method is allowed to run, generating the "fido" Dog object and returning it. This object is then put into the cache using the key "fido".

Then assume at time t1 the application calls this method with the name equal to "spot". The same process is repeated, and the cache is now populated with the Dog object named "spot".

Finally, at time t2 the application again calls the method with the name "fido". Since "fido" exists in the cache, the "fido" Dog object is returned from the cache instead of calling the method.

To implement this in your application:

Step 1:

Add the jars to your application as listed on the Ehcache Annotations for Spring project site.

Step 2:

Add the Annotation to methods you would like to cache. We assume you are using the Dog getDog(String name) method from above:

Dog getDog(String name)

Step 3:

Configure Spring. Add the following to your Spring configuration file in the beans declaration section:

<ehcache:annotation-driven cache-manager="ehCacheManager" />

More details can be found at: