How to configure Redis TTL with Spring Data Redis?

1. Introduction

In this quick tutorial, we’ll look at how we can configure key expiration in Spring Data Redis.

2. Setup

Let’s create a Spring Boot-based API to manage a Session resource backed by Redis for persistence. We’ll need four main steps to do this. For a more detailed setup, check out our guide on Spring Data Redis.

2.1. Dependencies

Firstly, Let’s add the following dependencies to our pom.xml:

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

The spring-boot-starter-data-redis will transitively add spring-data-redis and lettuce-core.

2.2. Redis Configuration

Secondly, let’s add the RedisTemplate configuration:

@Configuration
public class RedisConfiguration {

    @Bean
    public RedisTemplate<String, Session> getRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Session> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        return redisTemplate;
    }
}

2.3. Model

Thirdly, let’s create our Session model:

@RedisHash
public class Session {
    @Id
    private String id;
    private Long expirationInSeconds;
}

2.4. Redis Repository

And now, finally, let’s create the SessionRepository, which provides interaction with Redis to manage our Session entity:

public interface SessionRepository extends CrudRepository<Session, String> {}

3. Approaches

We’ll take a look at three approaches to setting the TTL.

3.1. Using @RedisHash

Let’s start with the easiest of the bunch. The @RedisHash allows us to provide a value for its timeToLive attribute:

@RedisHash(timeToLive = 60L)
public class Session {
    @Id
    private String id;
    private Long expirationInSeconds;
}

It takes the value in seconds. In the above example, we’ve set the expiration to 60 seconds. This approach is useful when we want to provide a constant value TTL for all Session objects. It can also be useful to specify a default TTL.

3.2. Using @TimeToLive

In the previous approach, we could set the same constant TTL for all Session objects. Our next approach allows for more dynamism. With @TimeToLive, we can annotate any numeric property or a method that returns a numeric value to set the TTL:

@RedisHash(timeToLive = 60L)
public class Session {
    @Id
    private String id;
    @TimeToLive
    private Long expirationInSeconds;
}

This allows us to set the TTL for each Session object dynamically. Just like the previous approach, the TTL is in seconds. The value of @TimeToLive supersedes @RedisHash(timeToLive).

3.3. Using KeyspaceSettings

Moving on to the next approach, KeyspaceSettings sets the TTL. Keyspaces define the prefixes used to create the actual key for the Redis Hash. Let’s now define our KeyspaceSettings for the Session class:

@Configuration
@EnableRedisRepositories(keyspaceConfiguration = RedisConfiguration.MyKeyspaceConfiguration.class)
public class RedisConfiguration {

    // Other configurations omitted

    public static class MyKeyspaceConfiguration extends KeyspaceConfiguration {

        @Override
        protected Iterable<KeyspaceSettings> initialConfiguration() {
            KeyspaceSettings keyspaceSettings = new KeyspaceSettings(Session.class, "session");
            keyspaceSettings.setTimeToLive(60L);
            return Collections.singleton(keyspaceSettings);
        }
    }
}

Just like the previous approaches, we’ve specified the TTL in seconds. This approach is very similar to @RedisHash. Additionally, if we don’t wish to use the @EnableRepositories we can set it more programmatically:

@Configuration
public class RedisConfiguration {

    // Other configurations omitted

    @Bean
    public RedisMappingContext keyValueMappingContext() {
        return new RedisMappingContext(new MappingConfiguration(new IndexConfiguration(), new MyKeyspaceConfiguration()));
    }

    public static class MyKeyspaceConfiguration extends KeyspaceConfiguration {

        @Override
        protected Iterable<KeyspaceSettings> initialConfiguration() {
            KeyspaceSettings keyspaceSettings = new KeyspaceSettings(Session.class, "session");
            keyspaceSettings.setTimeToLive(60L);
            return Collections.singleton(keyspaceSettings);
        }
    }
}

4. Comparison

Finally, let’s compare the three approaches we looked at and decipher when to use which one.

Both @RedisHash and KeyspaceSettings, allow us to set the TTL once and for all the entity instances (Session). On the other hand, @TimeToLive allows us to set TTL for each entity instance dynamically.

KeyspaceSettings provides a way to set the default TTL in one place in the configurations for multiple entities. On the other hand, with both @TimeToLive and @RedisHash this will need to happen in each entity class file.

@TimeToLive has the highest precedence, followed by @RedisHash with KeyspaceSettings at the end.

5. Redis Key Expiration Event

With all these approaches to set the expiration of a key in Redis, one might also be interested in when such events happen. For this, we’ve RedisKeyExpiredEvent. Let’s set up an EventListener to catch the RedisKeyExpiredEvent:

@Configuration
@EnableRedisRepositories(enableKeyspaceEvents = RedisKeyValueAdapter.EnableKeyspaceEvents.ON_STARTUP)
@Slf4j
public class RedisConfiguration {
    // Other configurations omitted

    @Component
    public static class SessionExpiredEventListener {
        @EventListener
        public void handleRedisKeyExpiredEvent(RedisKeyExpiredEvent<Session> event) {
            Session expiredSession = (Session) event.getValue();
            assert expiredSession != null;
            log.info("Session with key={} has expired", expiredSession.getId());
        }
    }
}

We’ll now be able to know when a Session expires and be able to take some action if required:

2023-02-10T15:13:38.626+05:30  INFO 16874 --- [enerContainer-1] c.b.s.config.RedisConfiguration:
  Session with key=edbd98e9-7b50-45d8-9cf4-9c621899e213 has expired

6. Conclusion

In this article, we looked at the various approaches to setting Redis TTL via Spring Data Redis. Finally, we looked at the RedisKeyExpiredEvent and how to handle expiration events.