Efficient Caching Strategy: Hybrid Caching in Spring Boot Applications

In modern application development, performance and scalability are key factors that determine the success or failure of the system. Caching plays a key role in improving these by reducing database load, reducing latency and ensuring a seamless user experience. However, no single caching solution is perfect for all scenarios.

Local caches (such as Caffeine) provide blazing fast speeds because they run in memory and close to the application. They are great for reducing response times for frequently accessed data. Distributed caches (such as Redisson's Redisson), on the other hand, provide scalability and consistency across multiple instances of an application. Distributed caching ensures that all nodes in a distributed system have access to the same latest data, which is critical in a multi-node environment. However, relying solely on local or distributed caching can bring challenges:

Local cache
• can become inconsistent in a distributed environment because data updates are not synchronized between nodes.
Distributed cache
• will 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 advantages of local and distributed caching using Caffeine and Redisson, you get the high performance of local caching speeds while maintaining consistency and scalability with distributed caching sex. This article explores how to implement hybrid caching in Spring Boot applications to ensure optimal performance and data consistency.

Implementation steps

Step 1: Add dependencies

First, add the necessary dependencies to your

file:

pom.xml

Step 2: Configure cache

<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>

The following is the cache configuration:

Detailed explanation of key components

@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());
    }
}

1. Cache Manager (CacheManager)

is responsible for managing the cache lifecycle and providing access to appropriate cache implementations (e.g. local or distributed). In this example, we use

to enable in-memory caching and configure the expiration policy via CacheManager. CaffeineCacheManager Caffeine2. CacheResolver

Dynamically determine which cache to use for a specific operation. Here,

connects local (Caffeine) and distributed (Redisson) caches to ensure that the hybrid strategy is effectively applied. CacheResolver LocalCacheResolver

@Component
public class LocalCacheResolver implements CacheResolver {
    // ... (代碼與原文相同) ...
}

3. Cache Entry Removed Listener (CacheEntryRemovedListener)

public class LocalCache implements Cache {
    // ... (代碼與原文相同) ...
}

Listens for entries being removed from the distributed cache (Redis) and ensures that they are also removed from the local cache of each node, thus maintaining consistency.

<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>

Hybrid Caching Workflow

Cache entry added

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

@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());
    }
}

Cache entry acquisition

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

@Component
public class LocalCacheResolver implements CacheResolver {
    // ... (代碼與原文相同) ...
}

Cache Entry Eviction

When a cache eviction occurs (for example, via the @CacheEvict annotation), the key will be removed from the distributed cache. Local caches of other nodes will be notified via CacheEntryRemovedListener to remove the same key:

public class LocalCache implements Cache {
    // ... (代碼與原文相同) ...
}

---

Summary

Hybrid cache combines the speed of local memory cache with the scalability and consistency of distributed cache. This approach addresses the limitations of using only local or distributed caches. By integrating Caffeine and Redisson in your Spring Boot application, you can achieve significant performance improvements while ensuring data consistency between application nodes.

Using CacheEntryRemovedListener and CacheResolver ensures that cache entries are kept in sync across all caching tiers, 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 critical.

The above is the detailed content of Hybrid Cache Strategy in Spring Boot: A Guide to Redisson and Caffeine Integration. For more information, please follow other related articles on the PHP Chinese website!