Spring Data Redis Documentation

The org.springframework.data.redis.support package provides reusable components that use Redis as a backing store while exposing standard JDK interfaces. This allows you to manage Redis keys with minimal API leakage and makes your code decoupled from the underlying storage.

Key features include:

• Atomic Counters: Wrappers for Redis key incrementation.
• Redis Collections: Implementations of standard JDK Collection interfaces.
  • RedisSet: Provides access to Redis set operations like intersection and union.
  • RedisZSet: Provides access to Redis sorted set operations.
  • RedisList: Implements List, Queue, and Deque contracts (including blocking variants). It can be configured as a FIFO, LIFO, or capped collection. Note that RedisList is forward-compatible with Java 21 SequencedCollection.

When calling repository.save() for a new entity, the repository performs several steps to ensure the entity is searchable via its indexed fields:

1. Save the Hash: The entity is saved as a flattened HMSET hash.
2. Keyspace Index: The entity's key is added to a helper set for the entire keyspace (e.g., SADD "people" <id>).
3. Secondary Index: The entity's key is added to a specific index set based on the indexed property value (e.g., SADD "people:firstname:rand" <id>).
4. Index Tracking: The index key is added to a helper structure attached to the entity to track which indexes must be cleaned up if the entity is later deleted or updated (e.g., SADD "people:<id>:idx" "people:firstname:rand").

repository.save(new Person("rand", "al'thor"));

Entities using @GeoIndexed properties utilize Redis Geo commands. Saving a geo-indexed entity involves:

1. GEOADD: Adding the entity's key to a specialized geo index structure (e.g., GEOADD "people:hometown:location" <long> <lat> <id>).
2. Index Tracking: Adding the geo index key to the entity's index tracker set (SADD "people:<id>:idx" "people:hometown:location") to allow for proper cleanup.

Spring Integration

Spring Data Redis applies core Spring concepts to key-value data stores. It provides a template as a high-level abstraction for sending and receiving messages, similar to how JdbcTemplate works in Spring JDBC.

To use advanced features like Repository support, you must configure the library to work with the Spring IoC container. However, the core Redis functionality can be used directly without invoking Spring IoC services.

NoSQL Concepts

Spring Data Redis is designed for NoSQL key-value stores. Users are encouraged to familiarize themselves with Redis-specific patterns and documentation, as the principles differ from traditional RDBMS.

Spring Data Redis provides two primary ways to interact with Redis depending on your programming model:

Imperative Programming

Use org.springframework.data.redis.core.RedisTemplate to perform standard synchronous operations. You create an instance of this template using a org.springframework.data.redis.connection.RedisConnectionFactory.

Reactive Programming

Use org.springframework.data.redis.core.ReactiveRedisTemplate for non-blocking, reactive usage. Like the imperative version, it requires a org.springframework.data.redis.connection.RedisConnectionFactory.

RedisConnectionFactory acts as an abstraction layer over the underlying drivers (Lettuce or Jedis).

When RedisTemplate is participating in a managed transaction (via setEnableTransactionSupport(true)), observe the following behaviors:

1. Writes: Must be performed on the thread-bound connection.
2. Reads: Commands like keys("*") are executed on a separate, non-transaction-aware connection.
3. Visibility: Values set within a transaction are not visible to standard get operations until the transaction is committed.

// must be performed on thread-bound connection
template.opsForValue().set("thing1", "thing2");

// read operation must be run on a free (not transaction-aware) connection
template.keys("*");

// returns null as values set within a transaction are not visible
template.opsForValue().get("thing1");

Redis Repositories require instances of RedisKeyValueAdapter and RedisKeyValueTemplate.

By default, the Spring Data Redis CDI extension will automatically create and manage these beans if they are not found in the CDI container. However, if you need to configure specific properties for these components, you can supply your own custom beans for RedisKeyValueAdapter and RedisKeyValueTemplate in your CDI configuration.

Redis Cluster uses automatic sharding to map keys to one of 16384 slots distributed across nodes. This affects how commands are executed:

• Single Node Scope: A single cluster node only serves a specific set of keys. Commands like KEYS issued to a single node only return keys for that node.
• Cross-Slot Errors: Commands involving multiple keys must ensure all keys map to the same slot to avoid errors. If they don't, the driver must split the command into multiple single-slot requests, which is less performant.
• Keyspace Events: Do not rely on keyspace events in a cluster, as they are not replicated across shards. Pub/Sub subscriptions may only receive events from a single shard.
• Slot Pinning: To ensure multiple keys map to the same slot, use curly bracket syntax (hash tags), e.g., \{my-prefix}.thing1 and \{my-prefix}.thing2.