{"id":366,"date":"2011-02-16T00:11:00","date_gmt":"2011-02-16T00:11:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/spring-3-1-cache-abstraction-tutorial.html"},"modified":"2012-10-24T14:05:24","modified_gmt":"2012-10-24T14:05:24","slug":"spring-31-cache-abstraction-tutorial","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2011\/02\/spring-31-cache-abstraction-tutorial.html","title":{"rendered":"Spring 3.1 Cache Abstraction Tutorial"},"content":{"rendered":"
One of the new features introduced in the forthcoming Spring 3.1 version<\/a> is the one of cache abstraction<\/a>. <\/p>\n

Spring Framework provides support for transparently adding caching into an existing Spring application. Similar to the transaction<\/a> support, the caching abstraction allows consistent use of various caching solutions with minimal impact on the code.<\/i><\/p>\n

At its core, the abstraction applies caching to Java methods, reducing thus the number of executions based on the information available in the cache. That is, each time a targeted method is invoked, the abstraction will apply a caching behaviour checking whether the method has been already executed for the given arguments. If it has, then the cached result is returned without having to execute the actual method; if it has not, then method is executed, the result cached and returned to the user so that, the next time the method is invoked, the cached result is returned.<\/p>\n

This concept is of course not something new. You can check out Spring, AspectJ, Ehcache Method Caching Aspect<\/a> a very interesting post from Brian Du Preez<\/a>, one of our JCG partners<\/a>, in which Aspect Oriented Programming<\/a> is used.<\/p>\n

As its name implies, Cache Abstraction is not an actual implementation, so it requires the use of an actual storage to store the cache data. As you might have guessed, Ehcache<\/a> support is provided out of the box. There is also an implementation based on JDK’s ConcurrentMap<\/a> and you can actually plug-in different back-end caches<\/a>.<\/p>\n

Now, let’s see some sample code on caching abstraction. For this purpose, I will use the very informative Cache Abstraction in Spring 3.1.0.M1<\/a> post by James Carr<\/a>, another of our JCG partners<\/a>. Make sure to bookmark the Spring Cache package Javadocs<\/a> along the way.<\/p>\n

(NOTE: The original post has been slightly edited to improve readability)<\/p>\n

Another new feature released yesterday came in parallel with me trying out some annotation based caching strategies. Caching Abstraction<\/a> basically takes convention from an existing project<\/a> and makes it part of Spring core.

<\/div> <\/div><\/p>\n

Essentially it introduces a new interface, CacheManager<\/a>, which can be implemented by a specific cache implementation. From there it adds a few new annotations to make methods cacheable. Here\u2019s an example using my previous posts objects<\/a>.<\/p>\n

package com.jamescarr.example;\r\n\r\nimport java.util.Collection;\r\nimport java.util.Map;\r\nimport java.util.concurrent.ConcurrentHashMap;\r\n\r\nimport javax.annotation.PostConstruct;\r\n\r\nimport org.slf4j.Logger;\r\nimport org.slf4j.LoggerFactory;\r\nimport org.springframework.cache.annotation.CacheEvict;\r\nimport org.springframework.cache.annotation.Cacheable;\r\nimport org.springframework.stereotype.Repository;\r\n\r\n@Repository\r\npublic class MemoryMessageRepository implements MessageRepository {\r\n\r\n    private static final Logger LOG =\r\n           LoggerFactory.getLogger(MemoryMessageRepository.class);\r\n\r\n    private final Map<String, Message> messages = \r\n           new ConcurrentHashMap<String, Message>();\r\n\r\n    @Cacheable(\"message\")\r\n    public Message getMessage(String title){\r\n        LOG.info(\"Fetching message\");\r\n        return messages.get(title);\r\n    }\r\n    @CacheEvict(value=\"message\", key=\"message.title\")\r\n    public void save(Message message){\r\n        LOG.info(\"Saving message\");\r\n        messages.put(message.getTitle(), message);\r\n    }\r\n    public Collection<Message> findAll() {\r\n        return messages.values();\r\n    }\r\n    \r\n    @PostConstruct\r\n    public void addSomeDefaultMessages(){\r\n        save(new Message(\"Hello\", \"Hello World\"));\r\n        save(new Message(\"Appointment\", \"Remember the milk!\"));\r\n    }\r\n    \r\n}\r\n<\/pre>\n
Here you\u2019ll notice that the finder method has a @Cachable<\/a> annotation on it with a name that specifies the cache to store to. It can also use additional attributes, for example a key which uses an expression language to determine a key from the arguments that are passed in. The default is the value of all the method arguments. On the save method I use @CacheEvict<\/a> to remove the cached element from the cache if it already exists.<\/p>\n
This of course won\u2019t work on it\u2019s own, so you\u2019ll have to enable it yourself (which is good\u2026 the last thing you need is to discover a production app caching things it shouldn\u2019t be caching). Sadly as of the time of this writing I haven\u2019t discovered how to do this in non-xml, so here is the spring xml file to enable it and use ehcache as the implementation.<\/p>\n
<beans xmlns=\"http:\/\/www.springframework.org\/schema\/beans\"\r\n        xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n        xmlns:cache=\"http:\/\/www.springframework.org\/schema\/cache\"\r\n        xmlns:p=\"http:\/\/www.springframework.org\/schema\/p\"\r\n        xsi:schemaLocation=\"http:\/\/www.springframework.org\/schema\/beans http:\/\/www.springframework.org\/schema\/beans\/spring-beans.xsd\r\n                http:\/\/www.springframework.org\/schema\/cache http:\/\/www.springframework.org\/schema\/cache\/spring-cache.xsd\">\r\n  <cache:annotation-driven \/>\r\n  \r\n        <bean id=\"cacheManager\" class=\"org.springframework.cache.ehcache.EhCacheCacheManager\" p:cache-manager-ref=\"ehcache\"\/>\r\n        <bean id=\"ehcache\" class=\"org.springframework.cache.ehcache.EhCacheManagerFactoryBean\" \r\n                p:config-location=\"classpath:com\/jamescarr\/example\/ehcache.xml\"\/>\r\n <\/beans>\r\n<\/pre>\n
The ehcache configuration:<\/p>\n
<ehcache>\r\n    <diskStore path=\"java.io.tmpdir\"\/>\r\n    <cache name=\"message\"\r\n       maxElementsInMemory=\"100\"\r\n            eternal=\"false\"\r\n            timeToIdleSeconds=\"120\"\r\n            timeToLiveSeconds=\"120\"\r\n            overflowToDisk=\"true\"\r\n            maxElementsOnDisk=\"10000000\"\r\n            diskPersistent=\"false\"\r\n            diskExpiryThreadIntervalSeconds=\"120\"\r\n            memoryStoreEvictionPolicy=\"LRU\"\/>\r\n    \r\n<\/ehcache>\r\n<\/pre>\n
And finally adding this to the AppConfiguration, which includes doing a simple @ImportResource<\/a>.<\/p>\n
package com.jamescarr.configuration;\r\nimport javax.annotation.PostConstruct;\r\n\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\r\nimport org.springframework.context.annotation.ComponentScan;\r\nimport org.springframework.context.annotation.Configuration;\r\nimport org.springframework.context.annotation.ImportResource;\r\n\r\nimport com.jamescarr.example.MessagePrinter;\r\n\r\n@Configuration\r\n@ComponentScan(\"com.jamescarr.example\")\r\n@ImportResource(\"classpath:com\/jamescarr\/example\/cache-context.xml\")\r\npublic class AppConfig {\r\n        @Autowired\r\n        private MessagePrinter messagePrinter;\r\n        @PostConstruct\r\n        public void doSomething(){\r\n                messagePrinter.printMessage(\"Hello\");\r\n                messagePrinter.printMessage(\"Hello\");\r\n                \r\n        }\r\n        public static void main(String[] args) {\r\n                new AnnotationConfigApplicationContext(AppConfig.class);\r\n        }\r\n}\r\n<\/pre>\n
When running this example there should be a log message for the first time the method is hit, then it is not seen the second time (since it is being pulled from the cache. This is definitely pretty awesome for implementing Memoization<\/a> for methods that might just have some CPU intensive computations (but give the exact expected results given a set of of inputs). I\u2019m excited about doing some more work in this area\u2026 I\u2019ve done method level caching before (it\u2019s common) but it is awesome to be able to use it without having to DIY.<\/p>\n
That’s it guys. A straightforward guide to get you started with Spring’s Cache Abstraction<\/a> from James Carr<\/a>. Don’t forget to share!<\/p>\n
Related Articles:<\/strong><\/p>\n