{"id":8232,"date":"2013-02-07T19:00:58","date_gmt":"2013-02-07T17:00:58","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=8232"},"modified":"2014-11-08T14:17:55","modified_gmt":"2014-11-08T12:17:55","slug":"caching-with-spring-data-redis","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2013\/02\/caching-with-spring-data-redis.html","title":{"rendered":"Caching with Spring Data Redis"},"content":{"rendered":"

In the example below, I\u2019ll show you how to use the Spring Data \u2013 Redis<\/a> project as a caching provider for the Spring Cache Abstraction that was introduced<\/a> in Spring 3.1. I get a lot of questions about how to use Spring\u2019s Java based configuration so I\u2019ll provide both XML and Java based configurations for your review.<\/p>\n

Dependencies<\/h2>\n

The following dependencies were used in this example:
\n 
\n 
\n <\/p>\n

<?xml version='1.0' encoding='UTF-8'?>\r\n<project xmlns='http:\/\/maven.apache.org\/POM\/4.0.0'\r\n    xsi:schemaLocation='http:\/\/maven.apache.org\/POM\/4.0.0 http:\/\/maven.apache.org\/maven-v4_0_0.xsd'\r\n    xmlns:xsi='http:\/\/www.w3.org\/2001\/XMLSchema-instance'>\r\n    <modelVersion>4.0.0<\/modelVersion>\r\n    <groupId>com.joshuawhite.example<\/groupId>\r\n    <artifactId>spring-redis-example<\/artifactId>\r\n    <version>1.0<\/version>\r\n    <packaging>jar<\/packaging>\r\n    <name>Spring Redis Example<\/name>\r\n    <dependencies>\r\n        <dependency>\r\n            <groupId>org.springframework.data<\/groupId>\r\n            <artifactId>spring-data-redis<\/artifactId>\r\n            <version>1.0.2.RELEASE<\/version>\r\n        <\/dependency>        \r\n        <!-- required for @Configuration annotation -->\r\n        <dependency>\r\n            <groupId>cglib<\/groupId>\r\n            <artifactId>cglib<\/artifactId>\r\n            <version>2.2.2<\/version>\r\n        <\/dependency>\r\n        <dependency>\r\n            <groupId>redis.clients<\/groupId>\r\n            <artifactId>jedis<\/artifactId>\r\n            <version>2.0.0<\/version>\r\n            <type>jar<\/type>\r\n            <scope>compile<\/scope>\r\n        <\/dependency>\r\n        <dependency>\r\n            <groupId>log4j<\/groupId>\r\n            <artifactId>log4j<\/artifactId>\r\n            <version>1.2.14<\/version>\r\n        <\/dependency>\r\n    <\/dependencies>\r\n    <build>\r\n        <plugins>\r\n            <plugin>\r\n                <groupId>org.apache.maven.plugins<\/groupId>\r\n                <artifactId>maven-compiler-plugin<\/artifactId>\r\n                <configuration>\r\n                    <source>1.6<\/source>\r\n                    <target>1.6<\/target>\r\n                <\/configuration>\r\n            <\/plugin>\r\n        <\/plugins>\r\n    <\/build>\r\n<\/project><\/pre>\n
Code and Configuration<\/strong><\/p>\n
The HelloService<\/code> example below is very simple. As you will see in the implementation, it simply returns a String with \u201cHello\u201d prepended to the name that is passed in.<\/p>\n
package com.joshuawhite.example.service;\r\n\r\npublic interface HelloService {\r\n\r\n    String getMessage(String name);\r\n\r\n}<\/pre>\n
Looking at the HelloServiceImpl<\/code> class (below), you can see that I am leveraging Spring\u2019s @Cacheable annotation to add caching capabilities to the getMessage<\/code> method. For more details on the capabilities of this annotation, take a look at the Cache Abstraction documentation<\/a>. For fun, I am using the Spring Expression Language (SpEL)<\/a> to define a condition. In this example, the methods response will only be cached when the name passed in is \u201cJoshua\u201d.<\/p>\n
package com.joshuawhite.example.service;\r\n\r\nimport org.springframework.cache.annotation.Cacheable;\r\nimport org.springframework.stereotype.Service;\r\n\r\n@Service('helloService')\r\npublic class HelloServiceImpl implements HelloService {\r\n\r\n    \/**\r\n     * Using SpEL for conditional caching - only cache method executions when\r\n     * the name is equal to 'Joshua'\r\n     *\/\r\n    @Cacheable(value='messageCache', condition=''Joshua'.equals(#name)')\r\n    public String getMessage(String name) {\r\n        System.out.println('Executing HelloServiceImpl' +\r\n                        '.getHelloMessage(\\'' + name + '\\')');\r\n\r\n        return 'Hello ' + name + '!';\r\n    }\r\n\r\n}<\/pre>\n
The App<\/code> class below contains our main<\/code> method and is used to select between XML and Java based configurations. Each of the System.out.println<\/code>\u2018s are used to demonstrate when caching is taking place. As a reminder, we only expect method executions passing in \u201cJoshua\u201d to be cached. This will be more clear when we look at the programs output later.<\/p>\n
package com.joshuawhite.example;\r\n\r\nimport org.springframework.cache.Cache;\r\nimport org.springframework.cache.CacheManager;\r\nimport org.springframework.context.ApplicationContext;\r\nimport org.springframework.context.annotation.AnnotationConfigApplicationContext;\r\nimport org.springframework.context.support.GenericXmlApplicationContext;\r\n\r\nimport com.joshuawhite.example.config.AppConfig;\r\nimport com.joshuawhite.example.service.HelloService;\r\n\r\npublic class App {\r\n\r\n    public static void main(String[] args) {\r\n\r\n        boolean useJavaConfig  = true;\r\n        ApplicationContext ctx = null;\r\n\r\n        \/\/Showing examples of both Xml and Java based configuration\r\n        if (useJavaConfig ) {\r\n                ctx = new AnnotationConfigApplicationContext(AppConfig.class);\r\n        }\r\n        else {\r\n                ctx = new GenericXmlApplicationContext('\/META-INF\/spring\/app-context.xml');\r\n        }\r\n\r\n        HelloService helloService = ctx.getBean('helloService', HelloService.class);\r\n\r\n        \/\/First method execution using key='Josh', not cached\r\n        System.out.println('message: ' + helloService.getMessage('Josh'));\r\n\r\n        \/\/Second method execution using key='Josh', still not cached\r\n        System.out.println('message: ' + helloService.getMessage('Josh'));\r\n\r\n        \/\/First method execution using key='Joshua', not cached\r\n        System.out.println('message: ' + helloService.getMessage('Joshua'));\r\n\r\n        \/\/Second method execution using key='Joshua', cached\r\n        System.out.println('message: ' + helloService.getMessage('Joshua'));\r\n\r\n        System.out.println('Done.');\r\n    }\r\n\r\n}<\/pre>\n
Notice that component scanning is still used when using the XML based configuration. You can see that I am using the @Service<\/code> annotation on line 6 of HelloServiceImpl.java<\/code> above. Next we will take a look at how to configure a jedisConnectionFactory<\/code>, redisTemplate<\/code> and cacheManager<\/code>.
 
<\/div> <\/div><\/p>\n
Configuring the JedisConnectionFactory<\/h2>\n
For this example, I chose to use Jedis<\/a> as our Java client of choice because it is listed on the Redis site as being the \u201crecommended\u201d<\/a> client library for Java. As you can see, the setup is very straight forward. While I am explicitly setting use-pool=true, it the source code indicates that this is the default. The JedisConnectionFactory also provides the following defaults when not explicitly set:<\/p>\n