Using Redisson for Distributed Caching in Java Applications

Why use caching in Java distributed applications? Every millisecond matters for speed and performance; users abandon sites that load slowly.

Caching accelerates distributed apps by keeping frequently accessed data close to the CPU; memory caches are far faster than RAM, disk, or network.

Distributed caches reduce latency, improve concurrency and scalability across multiple machines.

Redis, an open‑source in‑memory data store, can serve as a database, cache, or message broker, offering faster data access than many traditional databases.

Managing Redis as a distributed cache is challenging, especially handling local cache invalidation and synchronizing updates across all nodes.

Frameworks like Redisson simplify building distributed caches; this article examines three key Redisson implementations: Maps, Spring Cache, and JCache.

1. Redisson Distributed Cache

Redisson provides a Java wrapper for Redis, offering distributed objects, services, locks, synchronizers, and collections, some of which support both distributed and local caching.

2. Map

Redisson’s RMap implements Java’s Map interface with optional local caching; using RMapCache for generic distributed caching or RLocalCachedMap for local caching can boost read speed dramatically.

Example code to create and use an RMapCache :

RMapCache
map = redisson.getMapCache("anyMap");
map.put("key1", new SomeObject(), 10, TimeUnit.MINUTES, 10, TimeUnit.SECONDS);
...
map.destroy();

3. Spring Cache

Redisson integrates with Spring’s caching abstraction via RedissonSpringCacheManager and RedissonSpringLocalCachedCacheManager , the latter supporting local caching.

Typical configuration example:

@Configuration
@ComponentScan
@EnableCaching
public static class Application {
    @Bean(destroyMethod="shutdown")
    RedissonClient redisson() throws IOException {
        Config config = new Config();
        config.useClusterServers()
              .addNodeAddress("127.0.0.1:7004", "127.0.0.1:7001");
        return Redisson.create(config);
    }

    @Bean
    CacheManager cacheManager(RedissonClient redissonClient) {
        Map
config = new HashMap<>();
        // new "testMap" cache: ttl=24min, maxIdleTime=12min
        config.put("testMap", new CacheConfig(24*60*1000, 12*60*1000));
        return new RedissonSpringCacheManager(redissonClient, config);
    }
}

TTL and maxIdleTime control entry lifetime; if unset, data persists indefinitely.

4. JCache

Redisson also implements the JCache (JSR‑107) API, allowing standard cache operations.

Basic usage example:

MutableConfiguration
config = new MutableConfiguration<>();
CacheManager manager = Caching.getCachingProvider().getCacheManager();
Cache
cache = manager.createCache("namedCache", config);

Custom configurations can be supplied via Redisson’s own config objects.

Redisson’s JCache implementation passes all JCache TCK tests, confirming compliance.

Enjoy using caches!