Redisson

Language: Java

Caching/Distributed Data

Redisson was created to simplify the integration of Redis into Java applications, offering a rich set of distributed Java objects and utilities. It supports reactive, asynchronous, and synchronous APIs and is widely used for caching, distributed locking, pub/sub messaging, and managing high-concurrency applications.

Redisson is a Java client for Redis that provides a high-level, distributed Java data structures framework. It allows Java applications to interact with Redis using objects, collections, locks, atomic variables, and other advanced features in a thread-safe and cluster-aware manner.

Installation

maven:

Add dependency in pom.xml:
<dependency>
  <groupId>org.redisson</groupId>
  <artifactId>redisson</artifactId>
  <version>3.21.7</version>
</dependency>

gradle:

Add dependency in build.gradle:
implementation 'org.redisson:redisson:3.21.7'

Usage

Redisson provides distributed implementations of Java objects like Map, Set, List, Queue, Lock, AtomicLong, and Semaphore. It supports cluster mode, replication, reactive programming, and transaction-like features over Redis.

Connecting to Redis

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

Config config = new Config();
config.useSingleServer().setAddress("redis://127.0.0.1:6379");
RedissonClient redisson = Redisson.create(config);

Sets up a Redisson client to connect to a local Redis instance.

Using a distributed map

import org.redisson.api.RMap;
RMap<String, String> map = redisson.getMap("myMap");
map.put("key", "value");
System.out.println(map.get("key"));

Demonstrates storing and retrieving values from a distributed map backed by Redis.

Distributed lock

import org.redisson.api.RLock;
RLock lock = redisson.getLock("myLock");
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();
}

Uses Redisson to implement a distributed lock ensuring thread-safe access across multiple JVMs.

Distributed atomic long

import org.redisson.api.RAtomicLong;
RAtomicLong atomicLong = redisson.getAtomicLong("counter");
atomicLong.incrementAndGet();
System.out.println(atomicLong.get());

Provides a distributed atomic counter across different processes.

Pub/Sub messaging

import org.redisson.api.RTopic;
RTopic topic = redisson.getTopic("myTopic");
topic.addListener(String.class, (channel, msg) -> System.out.println("Received: " + msg));
topic.publish("Hello Redisson!");

Demonstrates publish/subscribe messaging using Redis channels.

Reactive API example

import org.redisson.api.RMapReactive;
RMapReactive<String, String> reactiveMap = redisson.getMap("reactiveMap");
reactiveMap.put("key", "value").subscribe();

Shows asynchronous, non-blocking operations using Redisson's reactive API.

Error Handling

RedisConnectionException: Occurs when Redisson cannot connect to the Redis server. Check host, port, and network connectivity.

RedisTimeoutException: Occurs when a Redis operation exceeds the timeout. Adjust timeout settings or optimize Redis commands.

IllegalStateException: Occurs if the client is shut down or configuration is invalid. Ensure proper client lifecycle management.

Best Practices

Use distributed locks and atomic objects for multi-instance applications to avoid race conditions.

Prefer asynchronous or reactive APIs for high-concurrency scenarios to improve performance.

Keep Redis data structures optimized to reduce memory usage and latency.

Use appropriate TTL (time-to-live) settings for cache entries.

Monitor Redis cluster and Redisson metrics for resource utilization and scaling.

Official Docs Github