DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports Events Over 2 million developers have joined DZone. Join Today! Thanks for visiting DZone today,
Edit Profile Manage Email Subscriptions Moderation Admin Console How to Post to DZone Article Submission Guidelines
View Profile
Sign Out
Refcards
Trend Reports
Events
Zones
Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Partner Zones AWS Cloud
by AWS Developer Relations
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Partner Zones
AWS Cloud
by AWS Developer Relations
The Latest "Software Integration: The Intersection of APIs, Microservices, and Cloud-Based Systems" Trend Report
Get the report
  1. DZone
  2. Data Engineering
  3. Data
  4. Spring Data with Redis

Spring Data with Redis

Sebastian  Pietrowski user avatar by
Sebastian Pietrowski
·
Feb. 03, 11 · Interview
Like (0)
Save
Tweet
Share
28.79K Views

Join the DZone community and get the full member experience.

Join For Free

The Spring Data project provides a solution for accessing data stored in new emerging technologies like NoSQL databases and cloud based services. When we look into the SpringSource git repository we see a lot of spring-data sub-projects:

  • spring-data-commons: common interfaces and utility class for other spring-data projects.
  • spring-data-column: support for column based databases. It has not started yet, but there will be support for Cassandra and HBase
  • spring-data-document: support for document databases. Currently MongoDB and CouchDB are supported.
  • spring-data-graph: support for graph based databases. Currently Neo4j is supported.
  • spring-data-keyvalue: support for key-value databases. Currently Redis and Riak are supported and probably Membase will be supported in future.
  • spring-data-jdbc-ext: JDBC extensions, as example Oracle RAC connection failover is implemented.
  • spring-data-jpa: simplifies JPA based data access layer.

I would like to share with you how you can use Redis. The first step is to download it from the redis.io web page. try.redis-db.com is a useful site where we can run Redis commands. It also provides a step by step tutorial. This tutorial shows us all structures that Redis supports (list, set, sorted set and hashes) and some useful commands. A lot of reputable sites use Redis today.

After download and unpacking we should compile Redis (version 2.2, the release candidate is the preferable one to use since some commands do not work in version 2.0.4).

make

sudo make install

Once we run these commands we are all set to run the following five commands:

  • redis-benchmark - for benchmarking Redis server
  • redis-check-aof - check the AOF (Aggregate Objective Function), and it can repair that.
  • redis-check-dump - check rdb files for unprocessable opcodes.
  • redis-cli - Redis client.
  • redis-server - Redis server.

We can test Redis server.

redis-server

[1055] 06 Jan 18:19:15 # Warning: no config file specified, using the default config. In order to specify a config file use 'redis-server /path/to/redis.conf'

[1055] 06 Jan 18:19:15 * Server started, Redis version 2.0.4

[1055] 06 Jan 18:19:15 * The server is now ready to accept connections on port 6379

[1055] 06 Jan 18:19:15 - 0 clients connected (0 slaves), 1074272 bytes in use

and Redis client.

 redis-cli

redis> set my-super-key "my-super-value"

OK

Now we create a simple Java project in order to show how simple a spring-data-redis module really is.

mvn archetype:create -DgroupId=info.pietrowski -DpackageName=info.pietrowski.redis 
-DartifactId=spring-data-redis -Dpackage=jar

Next we have to add in pom.xml milestone spring repository, and add spring-data-redis as a dependency. After that all required dependencies will be fetched.

Next we create a resources folder under the main folder, and create application.xml which will have all the configuration.

We can configure the JedisConnectionFactory, in two different ways, One - we can provide a JedisShardInfo object in shardInfo property. Two - we can provide host (default localhost), port (default 6379), password (default empty) and timeout (default 2000) properties. One thing to keep in mind is that the JedisShardInfo object has precedence and allows to setup weight, but only allows constructor injection.

We can setup the factory to use connection pooling by setting the value of the pooling property to 'true' (default).

See application.xml comments to see three different way of configuration.

Note: There are two different libraries supported: Jedis and JRedis. They have very similar names and both have the same factory name. See the difference:

  • org.springframework.data.keyvalue.redis.connection.jedis.JedisConnectionFactory
  • org.springframework.data.keyvalue.redis.connection.jredis.JredisConnectionFactory

Similar to what we do in Spring, we configure the template object by providing it with a connection factory. We will perform all the operations through this template object. By default we need to provide only Connection Factory, but there are more properties we can provide:

  • exposeConnection (default false) - if we return real connection or proxy object.
  • keySerializer, hashKeySerializer, valueSerializer, hashValueSerializer (default JdkSerializationRedisSerializer) which delegates serialization to Java serialization mechanism.
  • stringSerializer (default StringRedisSerializer) which is simple String to byte[] (and back) serializer with UTF8 encoding.

We are ready to execute some code which will be cooperating with the Redis instance. Spring-Data provides us with two ways of interaction, First is by using the execute method and providing a RedisCallback object. Second is by using *Operations helpers (these will be explained later)

When we are using RedisCallback we have access to low level Redis commands, see this list of interfaces (I won't put all the methods here because it is huge list):

  • RedisConnection - gathers all Redis commands plus connection management.
  • RedisCommands - gathers all Redis commands (listed beloved).
  • RedisHashCommands - Hash-specific Redis commands.
  • RedisListCommands - List-specific Redis commands.
  • RedisSetCommands - Set-specific Redis commands.
  • RedisStringCommands - key/value specific Redis commands.
  • RedisTxCommands - Transaction/Batch specific Redis commands.
  • RedisZSetCommands - Sorted Set-specific Redis commands.

Check RedisCallbackExample class, this was the hard way and the problem is we have to convert our objects into byte arrays in both directions, the second way is easier. Spring Data provides for us with Operations objects, so we have much more simpler API and all byte<->object conversion is made by serializer we setup (or the default one). Higher level API (you will easily recognize *Operation *Commands equivalents):

  • HashOperations - Redis hash operations.
  • ListOperations - Redis list operations.
  • SetOperations - Redis set operations.
  • ValueOperations - Redis 'string' operations.
  • ZSetOperations - Redis sorted set operations.

Most of methods get key as first parameters so we have an even better API for multiple operations on the same key:

  • BoundHashOperations - Redis hash operations for specific key.
  • BoundListOperations - Redis list operations for specific key.
  • BoundSetOperations - Redis set operations for specific key.
  • BoundValueOperations - Redis 'string' operations for specific key.
  • BoundZSetOperations - Redis sorted set operations for specific key.

Check RedisCallbackExample class to see some easy examples of *Operations usage. One important thing to mention is that you should use stringSerializers for keys, otherwise you will have problems from other clients, because standard serialization adds class information. Otherwise you end up keys such as:

  1. "\xac\xed\x00\x05t\x00\x05atInt"
  2. "\xac\xed\x00\x05t\x00\nmySuperKey"
  3. "\xac\xed\x00\x05t\x00\bsuperKey"

Up until now we have just checked the API for Redis, but Spring Data offers more for us. All the cool stuff is in org.springframework.data.keyvalue.redis.support package and all sub-packages. We have:

  • RedisAtomicInteger - Atomic integer (CAS operation) backed by Redis.
  • RedisAtomicLong - Same as previous for Long.
  • RedisList - Redis extension for List, Queue, Deque, BlockingDeque and BlockingQueue with two additional methods List range(start, end) and RedisList trim(start, end).
  • RedisSet - Redis extension for Set with additional methods: diff, diffAndStore, intersect, intersectAndStore, union, unionAndStore.
  • RedisZSet - Redis extension for SortedSet. Note that Comparator is not applicable here so this interface extends normal Set and provide proper methods similar to SortedSet.
  • RedisMap - Redis extension for Map with additional Long increment(key, delta) method

Every interface currently has one Default implementation. Check application-support.xml for examples of configuration and RedisSupportClassesExample for examples of use. There is lot of useful information in the comments as well.

Summary

The library is a first milestone release so there are minor bugs, the documentation isn't as perfect as we used to and the current version needs no stable Redis server. But this is definitely a great library which allows us to use all this cool NoSQL stuff in a "standard" Spring Data Access manner.

Awesome job!

This post is only useful if you checkout the code: from bitbucket , for the lazy ones here is spring-data-redis zip file as well.

This post is originally from http://pietrowski.info/2011/01/spring-data-redis-tutorial/
Redis (company) Spring Data Data (computing) Spring Framework

Opinions expressed by DZone contributors are their own.

Popular on DZone

  • OpenVPN With Radius and Multi-Factor Authentication
  • Journey to Event Driven, Part 1: Why Event-First Programming Changes Everything
  • Create a CLI Chatbot With the ChatGPT API and Node.js
  • How Elasticsearch Works

Comments

Partner Resources

X

ABOUT US

  • About DZone
  • Send feedback
  • Careers
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 600 Park Offices Drive
  • Suite 300
  • Durham, NC 27709
  • support@dzone.com
  • +1 (919) 678-0300

Let's be friends: