Distributed Caching with Redis and Spring Boot Microservices

Caching is a critical strategy in modern microservice-based architectures. It helps improve performance, reduce latency, and offload database stress, ensuring a seamless user experience. Redis, a high-performance in-memory data store, is one of the most popular tools for distributed caching due to its simplicity, speed, and versatility.

This blog explores how distributed caching works, what to cache, the cache-aside pattern, integration of Redis with Spring Boot, and strategies for managing cache invalidation effectively.

Table of Contents

1. When and What to Cache
2. Cache Aside Pattern
3. Redis + Spring Boot Integration
4. Cache Invalidation Strategies
5. Summary

When and What to Cache

Understanding When to Use Caching

Caching isn’t a one-size-fits-all solution. It’s most effective when:

• Reads Are Frequent: If certain data is queried repeatedly, caching reduces repetitive database calls.
• Data Rarely Changes: Static or slow-changing data (e.g., user profiles, product catalogs) is ideal for caching.
• Low Latency Is Critical: Applications requiring real-time responses, such as e-commerce or gaming platforms, benefit significantly from caching.
• High Concurrency Exists: Caching helps absorb concurrent requests, reducing the load on backend systems.

However, caching might not be suitable for:

• Highly dynamic data that changes frequently.
• Scenarios where exact real-time synchronization is critical.

What to Cache

Start with data that is either static or expensive to compute. Examples include:

1. Database Query Results: Cache results of time-consuming queries.
2. API Responses: Cache outbound API call responses, especially for third-party services.
3. Session Data: Use caching for efficient session management across microservices.
4. Configurations and Lookups: Store configuration data or lookup tables to avoid repeated fetches.

By carefully selecting when and what to cache, you can strike a balance between performance improvement and data freshness.

Cache Aside Pattern

The cache aside pattern (also called lazy loading) is commonly used in distributed caching models. It ensures caches are populated only when data is first requested, minimizing unnecessary storage and computation.

How the Cache Aside Pattern Works

1. Check the Cache: When requested data arrives, check the cache for availability.
2. Fetch from the Data Source: If the cache miss occurs, fetch the data from the primary data source (e.g., database).
3. Update the Cache: Store the fetched data in the cache for future requests.
4. Return the Data: Serve the data to the requester.

Spring Boot Example of Cache Aside

Implementing this pattern in a Spring Boot microservice is straightforward with Spring Cache and Redis.

Enable Caching with Annotations

Add Spring’s caching dependency to your pom.xml:

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

Enable caching in your Spring Boot application:

@EnableCaching
@SpringBootApplication
public class CacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(CacheApplication.class, args);
    }
}

Define a Cacheable Method

Annotate methods to employ the cache:

@Service
public class ProductService {

    @Cacheable(value = "products", key = "#productId")
    public Product getProductById(String productId) {
        // Simulate a database call
        return productRepository.findById(productId).orElseThrow(() -> new ProductNotFoundException());
    }
}

In this example:

• Cache name (products) stores cached objects.
• If a cache miss occurs, the method fetches the product data from the repository and stores it in Redis.

Redis + Spring Boot Integration

Redis is one of the most used distributed caching tools due to its versatility and high performance. Integrating Redis with Spring Boot enables seamless caching for your microservices.

Setting Up Redis

Install Redis Locally

Run Redis using Docker:

docker run -d -p 6379:6379 redis<br>

Configure Redis in Spring Boot

Update the application.yml with Redis connection details:

spring:
  redis:
    host: localhost
    port: 6379

Use Redis as a Cache Manager

Define Redis as the default cache provider:

@Configuration
public class RedisCacheConfig {

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(10)) // Cache expiry time
            .serializeValuesWith(RedisSerializationContext
                                 .SerializationPair
                                 .fromSerializer(new GenericJackson2JsonRedisSerializer()));
        return RedisCacheManager.builder(redisConnectionFactory)
                                 .cacheDefaults(config)
                                 .build();
    }
}

Why Redis for Distributed Caching?

1. Performance: Redis can handle millions of operations per second.
2. Data Structures: Supports advanced data types (e.g., hashes, sets, sorted lists).
3. Scalability: Can be clustered for large-scale services.

By leveraging Redis, you can significantly enhance the scalability and reliability of your cache strategy.

Cache Invalidation Strategies

One major challenge of caching is cache invalidation. Stale or invalid cache data can lead to inconsistencies and undermine the system’s reliability.

Common Cache Invalidations Strategies

1. Time-to-Live (TTL)

Assign an expiration time for cached entries to ensure they’re invalidated automatically after a set period.

Example: TTL of 10 minutes for product data:

RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(10));

2. Write-Through Cache

Updates the cache at the same time as the underlying data source. This ensures both the cache and the database stay in sync.

@CachePut(value = "products", key = "#product.id")
public Product updateProduct(Product product) {
    return productRepository.save(product);
}

3. Delete or Eviction

Cached data is explicitly removed when the underlying database is updated to ensure freshness.

@CacheEvict(value = "products", key = "#productId")
public void deleteProduct(String productId) {
    productRepository.deleteById(productId);
}

4. Cache Auto-Refreshing

Popular for frequently accessed data, this strategy pre-fetches and updates cache entries before they expire.

Choosing the Right Strategy

Pick an invalidation strategy that balances performance, freshness, and complexity based on the use case:

• Use TTL for read-heavy, semi-dynamic data.
• Opt for write-through for highly dynamic systems requiring real-time accuracy.

Summary

Distributed caching is a core pillar in achieving high performance and scalability in microservices architectures. Here’s a quick recap:

1. When and What to Cache: Cache frequent, static data to reduce database load and latency.
2. Cache Aside Pattern: A simple, lazy-loading model ensures cache is only updated upon demand.
3. Redis Integration with Spring Boot: Redis, combined with Spring’s caching annotations, provides a seamless distributed caching solution.
4. Invalidation Strategies: Employ TTL, explicit evictions, or write-through caching to maintain data consistency.

By implementing these caching strategies, you can significantly enhance the responsiveness of your microservices while elegantly handling scaling challenges. Start leveraging Redis and Spring Boot today for high-performing distributed applications!