Hybrid Cache Strategy in Spring Boot: A Guide to Redisson and Caffeine Integration

Mahmoud Nawwar — Sat, 25 Jan 2025 20:00:26 +0000

Introduction: The Need for Hybrid Caching

In modern application development, performance and scalability are critical factors that determine the success of a system. Caching plays a pivotal role in improving these aspects by reducing database load, minimizing latency, and ensuring a seamless user experience. However, no single caching solution is perfect for every scenario.

Local caches, like Caffeine, provide extremely fast data retrieval because they operate in memory and are close to the application. These are ideal for reducing response times for frequently accessed data. On the other hand, distributed caches, such as those powered by Redisson with Redis, offer scalability and consistency across multiple instances of an application. Distributed caches ensure all nodes in a distributed system access the same up-to-date data, which is crucial in multi-node environments.

However, relying solely on either local or distributed caching comes with challenges:

Local caches can become inconsistent in distributed environments as data updates are not synchronized across nodes.
Distributed caches introduce slight network latency, which may not be suitable for ultra-low-latency scenarios.

This is where hybrid caching becomes an effective solution. By combining the strengths of both local and distributed caches using Caffeine and Redisson, you can achieve high performance with the speed of local caching while maintaining consistency and scalability using distributed caching.

This article explores how to implement hybrid caching in a Spring Boot application, ensuring optimal performance and data consistency.

Implementation

Step 1: Add Dependencies

To begin, add the necessary dependencies to your pom.xml:

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.ben-manes.caffeine</groupId>
            <artifactId>caffeine</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.43.0</version>
        </dependency>

Step 2: Configure the Cache

Here is the cache configuration:

@Configuration
@EnableCaching
public class CacheConfig implements CachingConfigurer {

  @Value("${cache.server.address}")
  private String cacheAddress;

  @Value("${cache.server.password}")
  private String cachePassword;

  @Value("${cache.server.expirationTime:60}")
  private Long cacheExpirationTime;

  @Bean(destroyMethod = "shutdown")
  RedissonClient redisson() {
    Config config = new Config();
    config.useSingleServer().setAddress(cacheAddress).setPassword(cachePassword.trim());
    config.setLazyInitialization(true);
    return Redisson.create(config);
  }

  @Bean
  @Override
  public CacheManager cacheManager() {
    CaffeineCacheManager cacheManager = new CaffeineCacheManager();
    cacheManager.setCaffeine(
        Caffeine.newBuilder().expireAfterWrite(cacheExpirationTime, TimeUnit.MINUTES));
    return cacheManager;
  }

  @Bean
  public CacheEntryRemovedListener cacheEntryRemovedListener() {
    return new CacheEntryRemovedListener(cacheManager());
  }

  @Bean
  @Override
  public CacheResolver cacheResolver() {
    return new LocalCacheResolver(cacheManager(), redisson(), cacheEntryRemovedListener());
  }
}

Step 3: Use the Spring cache abstraction annotations in your code


    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // Simulates an expensive database call
        return productRepository.findById(id);
    }

    @CacheEvict(value = "products", key = "#id")
    public void deleteProductById(Long id) {
        productRepository.deleteById(id);
    }

Explaining the Key Components

1. Cache Manager

The CacheManager is responsible for managing the lifecycle of caches and providing access to the appropriate cache implementation (e.g., local or distributed). In this case, we use CaffeineCacheManager to enable in-memory caching with an expiration policy configured via Caffeine.

2. Cache Resolver

The CacheResolver determines which cache(s) to use for a specific operation dynamically. Here, the LocalCacheResolver bridges the local (Caffeine) and distributed (Redisson) caches, ensuring that the hybrid strategy is applied effectively.

@Component
public class LocalCacheResolver implements CacheResolver {

  private final CacheManager cacheManager;
  private final RedissonClient redisson;
  private final CacheEntryRemovedListener cacheEntryRemovedListener;

  @Value("${cache.server.expirationTime:60}")
  private Long expirationTime;

  private final Map<String, LocalCache> cacheMap = new ConcurrentHashMap<>();

  public LocalCacheResolver(
      CacheManager cacheManager,
      RedissonClient redisson,
      CacheEntryRemovedListener cacheEntryRemovedListener) {
    this.cacheManager = cacheManager;
    this.redisson = redisson;
    this.cacheEntryRemovedListener = cacheEntryRemovedListener;
  }

  @Override
  @Nonnull
  public Collection<? extends Cache> resolveCaches(
      @Nonnull CacheOperationInvocationContext<?> context) {
    Collection<Cache> caches = getCaches(cacheManager, context);
    return caches.stream().map(this::getOrCreateLocalCache).toList();
  }

  private Collection<Cache> getCaches(
      CacheManager cacheManager, CacheOperationInvocationContext<?> context) {
    return context.getOperation().getCacheNames().stream()
        .map(cacheManager::getCache)
        .filter(Objects::nonNull)
        .toList();
  }

  private LocalCache getOrCreateLocalCache(Cache cache) {
    return cacheMap.computeIfAbsent(
        cache.getName(),
        cacheName -> new LocalCache(cache, redisson, expirationTime, cacheEntryRemovedListener));
  }
}

public class LocalCache implements Cache {

  private final Cache cache;
  private final Long expirationTime;
  private final RMapCache<Object, Object> distributedCache;

  public LocalCache(
      Cache cache,
      RedissonClient redisson,
      Long expirationTime,
      CacheEntryRemovedListener cacheEntryRemovedListener) {
    this.cache = cache;
    this.expirationTime = expirationTime;
    this.distributedCache = redisson.getMapCache(getName());
    this.distributedCache.addListener(cacheEntryRemovedListener);
  }

  @Override
  @Nonnull
  public String getName() {
    return cache.getName();
  }

  @Override
  @Nonnull
  public Object getNativeCache() {
    return cache.getNativeCache();
  }

  @Override
  public ValueWrapper get(@Nonnull Object key) {
    Object value = cache.get(key);

    if (value == null && (value = distributedCache.get(key)) != null) {
      cache.put(key, value);
    }

    return toValueWrapper(value);
  }

  private ValueWrapper toValueWrapper(Object value) {
    if (value == null) return null;
    return value instanceof ValueWrapper ? (ValueWrapper) value : new SimpleValueWrapper(value);
  }

  @Override
  public <T> T get(@Nonnull Object key, Class<T> type) {
    return cache.get(key, type);
  }

  @Override
  public <T> T get(@Nonnull Object key, @Nonnull Callable<T> valueLoader) {
    return cache.get(key, valueLoader);
  }

  @Override
  public void put(@Nonnull Object key, Object value) {
    distributedCache.put(key, value, expirationTime, TimeUnit.MINUTES);
    cache.put(key, value);
  }

  @Override
  public void evict(@Nonnull Object key) {
    distributedCache.remove(key);
  }

  @Override
  public void clear() {
    cache.clear();
  }
}

3. Cache Entry Removed Listener

The CacheEntryRemovedListener listens for entries removed from the distributed cache (Redis) and ensures they are also removed from the local caches across nodes, maintaining consistency.

@RequiredArgsConstructor
@Component
public class CacheEntryRemovedListener implements EntryRemovedListener<Object, Object> {

  private final CacheManager cacheManager;

  @Override
  public void onRemoved(EntryEvent event) {
    Cache cache = cacheManager.getCache(event.getSource().getName());
    if (cache != null) {
      cache.evict(event.getKey());
    }
  }
}

Hybrid Caching Workflow

Cache Entry Put

When a method annotated with @Cacheable is executed, the put method is invoked. This stores the data in both the local cache (Caffeine) and the distributed cache (Redis):

javaCopyEdit@Override
public void put(@Nonnull Object key, Object value) {
    distributedCache.put(key, value, expirationTime, TimeUnit.MINUTES);
    cache.put(key, value);
}

Cache Entry Get

To retrieve data, the system first checks the local cache for the key. If the key is not found, it queries the distributed cache. If the value exists in the distributed cache, it is also added to the local cache for faster subsequent access:

@Override
public ValueWrapper get(@Nonnull Object key) {
    Object value = cache.get(key);

    if (value == null && (value = distributedCache.get(key)) != null) {
      cache.put(key, value);
    }

    return toValueWrapper(value);
}

Cache Entry Eviction

When a cache eviction occurs (e.g., through a @CacheEvict annotation), the key is removed from the distributed cache. Other nodes' local caches are notified via the CacheEntryRemovedListener to remove the same key:

@Override
public void evict(@Nonnull Object key) {
    distributedCache.remove(key);
}

Conclusion

Hybrid caching combines the speed of local in-memory caches with the scalability and consistency of distributed caches. This approach addresses the limitations of using either local or distributed caching alone. By integrating Caffeine and Redisson in a Spring Boot application, you can achieve significant performance improvements while ensuring consistent data across application nodes.

Using the CacheEntryRemovedListener and CacheResolver ensures that cache entries stay synchronized across all cache layers, providing an efficient and reliable caching strategy for modern, scalable applications. This hybrid approach is especially valuable in distributed systems where both performance and consistency are paramount.

DEV Community: Mahmoud Nawwar