Generic Top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:


1. Introduction

In this tutorial, we're going to learn how to configure and implement Redis operations using Spring Data's ReactiveRedisTemplate. 

We'll go over the basic usages of the ReactiveRedisTemplate like how to store and retrieve objects in Redis. And we'll take a look at how to execute Redis commands using the ReactiveRedisConnection.

To cover the basics, check out our Introduction to Spring Data Redis.

2. Setup

To use ReactiveRedisTemplate in our code, first, we need to add the dependency for Spring Boot's Redis Reactive module:


3. Configuration

Thenwe need to establish a connection with our Redis server. We do not need to add any code for configuration if want to connect to a Redis server at localhost:6379.

But, if our server were remote or were on a different port, we could supply the hostname and port in the LettuceConnectionFactory constructor:

public ReactiveRedisConnectionFactory reactiveRedisConnectionFactory() {
    return new LettuceConnectionFactory(host, port);

4. List Operations

Redis Lists are lists of Strings sorted by insertion order. We can add or remove the elements from the List by pushing or popping them from the left or right.

4.1. String Template

To work with Lists, we'll need an instance of ReactiveStringRedisTemplate to obtain a reference to RedisListOperations:

private ReactiveStringRedisTemplate redisTemplate;
private ReactiveListOperations<String, String> reactiveListOps;
public void setup() {
    reactiveListOps = redisTemplate.opsForList();

4.2. LPUSH and LPOP

Now that we have an instance of ReactiveListOperations, let's do an LPUSH operation for a list with demo_list as the list's identifier.

After that, we'll do an LPOP on the list and then verify the element popped:

public void givenListAndValues_whenLeftPushAndLeftPop_thenLeftPushAndLeftPop() {
    Mono<Long> lPush = reactiveListOps.leftPushAll(LIST_NAME, "first", "second")
    Mono<String> lPop = reactiveListOps.leftPop(LIST_NAME)

Note that when testing reactive components, we can use StepVerifier to block for the completion of the task.

5. Value Operations

We may want to use custom objects as well, and not just Strings.

So, let's do some similar operations on an Employee object to demonstrate our operations on a POJO:

public class Employee implements Serializable {
    private String id;
    private String name;
    private String department;
    // ... getters and setters
    // ... hashCode and equals

5.1. Employee Template

We'll need to create a second instance of ReactiveRedisTemplate. We'll still use String for our key, but this time the value will be Employee:

public ReactiveRedisTemplate<String, Employee> reactiveRedisTemplate(
  ReactiveRedisConnectionFactory factory) {
    StringRedisSerializer keySerializer = new StringRedisSerializer();
    Jackson2JsonRedisSerializer<Employee> valueSerializer =
      new Jackson2JsonRedisSerializer<>(Employee.class);
    RedisSerializationContext.RedisSerializationContextBuilder<String, Employee> builder =
    RedisSerializationContext<String, Employee> context = 
    return new ReactiveRedisTemplate<>(factory, context);

In order to correctly serialize a custom object, we need to instruct Spring on how to do it. Here, we told the template to use the Jackson library by configuring a Jackson2JsonRedisSerializer for the value. Since the key is just a String, we can use the StringRedisSerializer for that.

We then take this serialization context and our connection factory to create a template as before.

Next, we'll create an instance of ReactiveValueOperations just like we did earlier with ReactiveListOperations:

private ReactiveRedisTemplate<String, Employee> redisTemplate;
private ReactiveValueOperations<String, Employee> reactiveValueOps;
public void setup() {
    reactiveValueOps = redisTemplate.opsForValue();

5.2. Save and Retrieve Operations

Now that we have an instance of ReactiveValueOperations, let's use it to store an instance of Employee:

public void givenEmployee_whenSet_thenSet() {
    Mono<Boolean> result = reactiveValueOps.set("123", 
      new Employee("123", "Bill", "Accounts"));

And then we can get the same object back from Redis:

public void givenEmployeeId_whenGet_thenReturnsEmployee() {
    Mono<Employee> fetchedEmployee = reactiveValueOps.get("123");
      .expectNext(new Employee("123", "Bill", "Accounts"))

5.3. Operations With Expiry Time

We often want to put values in a cache that will naturally expire, and we can do this with the same set operation:

public void givenEmployee_whenSetWithExpiry_thenSetsWithExpiryTime() 
  throws InterruptedException {
    Mono<Boolean> result = reactiveValueOps.set("129", 
      new Employee("129", "John", "Programming"), 
    Mono<Employee> fetchedEmployee = reactiveValueOps.get("129");

Note that this test does some of its own blocking to wait for the cache key to expire.

6. Redis Commands

Redis Commands are basically methods that a Redis client can invoke on a server. And Redis supports dozens of commands, some of which we have already seen, like LPUSH and LPOP.

The Operations API is a higher-level abstraction around Redis's set of commands.

However, if we want to use the Redis command primitives more directly, then Spring Data Redis Reactive also gives us a Commands API.

So, let's take a look at the String and Key commands through the lens of the Commands API.

6.1. String and Key Commands

To perform Redis command operations we'll obtain instances of ReactiveKeyCommands and ReactiveStringCommands.

We can get them both from our ReactiveRedisConnectionFactory instance:

public ReactiveKeyCommands keyCommands(ReactiveRedisConnectionFactory 
  reactiveRedisConnectionFactory) {
    return reactiveRedisConnectionFactory.getReactiveConnection().keyCommands();
public ReactiveStringCommands stringCommands(ReactiveRedisConnectionFactory 
  reactiveRedisConnectionFactory) {
    return reactiveRedisConnectionFactory.getReactiveConnection().stringCommands();

6.2. Set and Get Operations

We can use ReactiveStringCommands to store multiple keys with a single invocation, basically invoking the SET command multiple times.

And then, we can retrieve those keys through ReactiveKeyCommands, invoking the KEYS command:

public void givenFluxOfKeys_whenPerformOperations_thenPerformOperations() {
    Flux<SetCommand> keys = Flux.just("key1", "key2", "key3", "key4");
      .map(key -> SetCommand.set(key).value(key));
    Mono<Long> keyCount = keyCommands.keys(ByteBuffer.wrap("key*".getBytes()))

Note that, as stated earlier, this API is much more low-level. For example, instead of dealing with high-level objects, we are sending a stream of bytes, using ByteBuffer. Also, we use more of the Redis primitives like SET and SCAN.

Finally, String and Key Commands are just two among many command interfaces that Spring Data Redis exposes reactively.

7. Conclusion

In this tutorial, we've covered the basics of using Spring Data's Reactive Redis Template and the various ways in which we can integrate it with our application.

The full source code for the examples is available over on GitHub.

Generic bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

Newest Most Voted
Inline Feedbacks
View all comments
1 year ago

Thank you. Nice article again. Could you give us an example, what should be avoided?
Note that using state in the java.util.function / lambdas used within Flux operators should be avoided, as these may be shared between several Subscribers.

Loredana Crusoveanu
1 year ago
Reply to  Ombre

Hi Ombre,
The example is available in here:


1 year ago

I have checkout the code. I’m in spring-data-redis. Started with ‘mvn spring-boot:run’. Now what should be the url? I am new to Spring Boot

Loredana Crusoveanu
1 year ago
Reply to  hidayath


This module doesn’t have controllers so it can’t be accessed from a url. You can test the functionality by running the JUnit tests once you start up the Redis server. If you’re looking for an intro to Spring Boot, I suggest this article:

Comments are closed on this article!