A Guide to Using Redis in Spring Boot: Custom CacheManager
Tags: redis, springboot, java, caching
Published: 2023-09-26 03:11:47

## Working With Redis
 
- [1. Caching Strategies for High-Performance Java Applications with Redis
](https://dev.to/jackynote/caching-strategies-for-high-performance-java-applications-with-redis-3ahj) 
- 2. A Guide to Using Redis in Spring Boot: Custom CacheManager 

As a junior developer, you've likely heard about Redis and Spring Boot, two powerful technologies that can supercharge your applications. Redis is an in-memory data store known for its speed and versatility, while Spring Boot simplifies Java application development. In this guide, we'll explore how to integrate Redis into Spring Boot and create a custom CacheManager with Time-To-Live (TTL) functionality for prefix keys. We'll also delve into the various types of values you can store in Redis and the use cases for each.

## Prerequisites
Before we dive into Redis and Spring Boot integration, make sure you have the following tools and knowledge:

Java and Spring Boot Knowledge: Familiarity with Java and Spring Boot is essential. If you're new to Spring Boot, consider going through some introductory tutorials first.

Maven or Gradle: A basic understanding of build tools like Maven or Gradle is helpful for managing dependencies.

Redis: Install and configure a Redis server on your local machine or use a cloud-based Redis service. You can find installation instructions for Redis on the [official website](https://redis.io/download/).

Spring Boot: Have a Spring Boot application set up. If you don't have one, you can quickly generate a Spring Boot project using Spring [Initializr](https://start.spring.io/).

## Integrating Redis with Spring Boot
To use Redis as a caching mechanism in your Spring Boot application, you need to include the Spring Data Redis library as a dependency in your project. If you're using Maven, add the following dependency to your pom.xml:

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

If you're using Gradle, add this to your build.gradle:

```
implementation 'org.springframework.boot:spring-boot-starter-data-redis'
```
Next, configure your Redis connection in `application.properties` or `application.yml`:

```properties
spring.redis.host=localhost
spring.redis.port=6379
```
Now, you're ready to create a custom CacheManager with TTL functionality.

## Custom CacheManager with TTL
In a Spring Boot application, caching is typically managed using the @Cacheable annotation. To add TTL functionality to cached items, you can create a custom CacheManager that supports TTL per prefix key.

Here's a step-by-step guide to creating a custom CacheManager:
### 1. Create a RedisCacheConfiguration Bean:

```Java
import org.springframework.boot.autoconfigure.cache.RedisCacheManagerBuilderCustomizer;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        return RedisCacheManagerBuilder
            .fromConnectionFactory(connectionFactory)
            .withCacheConfiguration("myCache",
                RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofMinutes(10)) // TTL set to 10 minutes
            )
            .build();
    }

    @Bean
    public RedisCacheManagerBuilderCustomizer redisCacheManagerBuilderCustomizer() {
        return (builder) -> builder
            .withCacheConfiguration("customCache",
                RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofMinutes(5)) // TTL set to 5 minutes
            );
    }
}
```
### 2. Add Caching Annotations to Your Service Methods:

```Java
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Cacheable(value = "myCache", key = "'user_' + #id")
    public User getUserById(Long id) {
        // Retrieve user data from a database or external source
        return userRepository.findById(id).orElse(null);
    }
}
```
In this example, we're caching user objects with a custom TTL for each prefix key.

## Types of Values to Store in Redis
Redis is versatile and can store various types of data. Here are some common data types and their use cases:

- **Strings**: Use for simple key-value storage, such as caching, configuration, or counters.

- **Lists**: Ideal for storing ordered collections of data, like logs, notifications, and queues.

- **Sets**: Store unique, unordered values. Use cases include tracking tags, followers, and likes.

- **Hashes**: Great for storing objects or structured data. Useful in scenarios like user profiles and storing JSON data.

- **Sorted Sets**: Similar to sets but with an associated score. Suitable for leaderboards, rankings, and time-based data.

- **Bitmaps**: Efficient for tracking binary data or flags, like user activity or online status.

- **Geospatial Data**: Store and query geographical information, such as locations of restaurants or points of interest.

## Use Cases for Different Value Types
Now, let's explore some common use cases for each Redis data type:

- **Strings**: Caching frequently accessed data, storing session information, or managing feature toggles.
- **Lists**: Logging and audit trails, message queues for background processing, and managing user activity streams.
- **Sets**: Implementing social features like followers and likes, tracking tags in a content management system, or managing access control lists (ACLs).
- **Hashes**: Storing user profiles, managing configuration settings, or caching complex objects.
- **Sorted Sets**: Creating leaderboards, rankings, and implementing features that require sorting by score.
- **Bitmaps**: Tracking user activity patterns, online/offline status, or implementing recommendations based on user behavior.
- **Geospatial** Data: Building location-based features like location-aware search, geofencing, and proximity alerts.

**In conclusion**, integrating Redis with Spring Boot can significantly enhance your application's performance and functionality. By creating a custom CacheManager with TTL for prefix keys and leveraging the various Redis data types, you can optimize data storage and retrieval for different use cases. Redis is a versatile tool that, when used effectively, can elevate your application's capabilities and responsiveness. Happy coding!