I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE COURSE

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:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

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:

@Bean
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 ReactiveRedisTemplate that we’ve provided a String serialization context:

@Bean
public ReactiveRedisTemplate<String, String> reactiveRedisTemplateString
  (ReactiveRedisConnectionFactory connectionFactory) {
    return new ReactiveRedisTemplate<>(connectionFactory, RedisSerializationContext.string());
}

And from the String template we just created, we can obtain an instance of ReactiveListOperations:

@Autowired
private ReactiveRedisTemplate<String, String> redisTemplate;

private ReactiveListOperations<String, String> reactiveListOps;

@Before
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:

@Test
public void givenListAndValues_whenLeftPushAndLeftPop_thenLeftPushAndLeftPop() {
    Mono<Long> lPush = reactiveListOps.leftPushAll(LIST_NAME, "first", "second")
      .log("Pushed");

    StepVerifier.create(lPush)
      .expectNext(2L)
      .verifyComplete();

    Mono<String> lPop = reactiveListOps.leftPop(LIST_NAME)
      .log("Popped");

    StepVerifier.create(lPop)
      .expectNext("second")
      .verifyComplete();
}

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:

@Bean
public ReactiveRedisTemplate<String, Employee> reactiveRedisTemplate(
  ReactiveRedisConnectionFactory factory) {

    StringRedisSerializer keySerializer = new StringRedisSerializer();
    Jackson2JsonRedisSerializer<Employee> valueSerializer =
      new Jackson2JsonRedisSerializer<>(Employee.class);
    RedisSerializationContext.RedisSerializationContextBuilder<String, Employee> builder =
      RedisSerializationContext.newSerializationContext(keySerializer);
    RedisSerializationContext<String, Employee> context = 
      builder.value(valueSerializer).build();

    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:

@Autowired
private ReactiveRedisTemplate<String, Employee> redisTemplate;

private ReactiveValueOperations<String, Employee> reactiveValueOps;

@Before
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:

@Test
public void givenEmployee_whenSet_thenSet() {

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

    StepVerifier.create(result)
      .expectNext(true)
      .verifyComplete();
}

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

@Test
public void givenEmployeeId_whenGet_thenReturnsEmployee() {

    Mono<Employee> fetchedEmployee = reactiveValueOps.get("123");

    StepVerifier.create(fetchedEmployee)
      .expectNext(new Employee("123", "Bill", "Accounts"))
      .verifyComplete();
}

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:

@Test
public void givenEmployee_whenSetWithExpiry_thenSetsWithExpiryTime() 
  throws InterruptedException {

    Mono<Boolean> result = reactiveValueOps.set("129", 
      new Employee("129", "John", "Programming"), 
      Duration.ofSeconds(1));

    StepVerifier.create(result)
      .expectNext(true)
      .verifyComplete();

    Thread.sleep(2000L); 

    Mono<Employee> fetchedEmployee = reactiveValueOps.get("129");
    StepVerifier.create(fetchedEmployee)
      .expectNextCount(0L)
      .verifyComplete();
}

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:

@Bean
public ReactiveKeyCommands keyCommands(ReactiveRedisConnectionFactory 
  reactiveRedisConnectionFactory) {
    return reactiveRedisConnectionFactory.getReactiveConnection().keyCommands();
}

@Bean
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:

@Test
public void givenFluxOfKeys_whenPerformOperations_thenPerformOperations() {
    Flux<SetCommand> keys = Flux.just("key1", "key2", "key3", "key4");
      .map(String::getBytes)
      .map(ByteBuffer::wrap)
      .map(key -> SetCommand.set(key).value(key));

    StepVerifier.create(stringCommands.set(keys))
      .expectNextCount(4L)
      .verifyComplete();

    Mono<Long> keyCount = keyCommands.keys(ByteBuffer.wrap("key*".getBytes()))
      .flatMapMany(Flux::fromIterable)
      .count();

    StepVerifier.create(keyCount)
      .expectNext(4L)
      .verifyComplete();
}

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.

I just announced the new Spring Boot 2 material, coming in REST With Spring:

>> CHECK OUT THE LESSONS

Leave a Reply

avatar
  Subscribe  
Notify of