Redisson - Easy Redis Java client
and Real-Time Data Platform

Based on high-performance async and lock-free Java Redis client and Netty framework.

Features

Thread-safe implementation
JDK 1.8+ compatible
Android compatible
Redis compatible - from 3.0 up to the latest version
Valkey compatible - from 7.2.5 up to the latest version
Supported deployment types
- Proxy
- Multi-Cluster
- Multi-Sentinel
- Single
- Cluster
- Sentinel
- Replicated
- Master and Slaves
Amazon Web Services compatible
- AWS Elasticache Serverless
- AWS Redis Global Datastore
- AWS ElastiCache
- Amazon MemoryDB
Microsoft Azure compatible
- Azure Redis Cache
- Azure Redis Cache active-passive replication
- Azure Redis Cache active-active replication
Google Cloud Memorystore compatible
- Google Cloud Redis
- Google Cloud Redis High availability
Redis Enterprise compatible
- Redis Enterprise
- Redis Enterprise Active-Active databases
- Redis Enterprise Multiple Active Proxy
IBM Cloud compatible
- IBM Cloud Databases for Redis
Aiven compatible
- Aiven for Redis
Supports auto-reconnection
Supports failed to send command auto-retry
Supports OSGi
Supports SSL
Asynchronous connection pool
Lua scripting
RediSearch
JSON datatype
JSON Store
Reactive Streams API
RxJava3 API
Asynchronous API
Local cache support including Caffeine-based implementation
Distributed Java objects
Object holder, Binary stream holder, Geospatial holder, BitSet, AtomicLong, AtomicDouble, PublishSubscribe, Bloom filter, HyperLogLog
Distributed Java collections
Map, Multimap, Set, List, SortedSet, ScoredSortedSet, LexSortedSet, Queue, Deque, Blocking Queue, Bounded Blocking Queue, Blocking Deque, Delayed Queue, Priority Queue, Priority Deque
Distributed Java locks and synchronizers
Lock, FairLock, MultiLock, RedLock, ReadWriteLock, Semaphore, PermitExpirableSemaphore, CountDownLatch
Distributed services
Remote service, Live Object service, Executor service, Scheduler service, MapReduce service
Helidon integration
Micronaut integration
Quarkus integration
Spring Cache implementation
Spring Cloud Stream implementation
Spring Transaction API implementation
Spring Data Redis implementation
Spring Boot Starter implementation
Hibernate Cache implementation
MyBatis Cache implementation
Transactions API
JCache API (JSR-107) implementation
Tomcat Session Manager implementation
Spring Session implementation
Redis pipelining (command batches)
Supports many popular codecs (Kryo, Jackson JSON, Avro, Smile, CBOR, MsgPack, Amazon Ion, LZ4, Snappy, Protobuf and JDK Serialization)
2000+ unit tests

Comparing solutions

Redisson vs Jedis

Redisson vs Lettuce

Redis vs Apache Ignite

Redis vs Hazelcast

Redis vs Ehcache

Success stories

Moving from Hazelcast to Redis / Datorama

Migrating from Hazelcast to Redis / Halodoc

Distributed Locking with Redis (Migration from Hazelcast) / ContaAzul

Migrating from Coherence to Redis

Quick start

Maven

<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.34.1</version>
</dependency>

Gradle

compile 'org.redisson:redisson:3.34.1'

SBT

libraryDependencies += "org.redisson" % "redisson" % "3.34.1"

Java

// 1. Create config object
Config config = new Config();
config.useClusterServers()
       // use "rediss://" for SSL connection
      .addNodeAddress("redis://127.0.0.1:7181");

// or read config from file
config = Config.fromYAML(new File("config-file.yaml"));

// 2. Create Redisson instance

// Sync and Async API
RedissonClient redisson = Redisson.create(config);

// Reactive API
RedissonReactiveClient redissonReactive = redisson.reactive();

// RxJava3 API
RedissonRxClient redissonRx = redisson.rxJava();

// 3. Get Redis based implementation of java.util.concurrent.ConcurrentMap
RMap<MyKey, MyValue> map = redisson.getMap("myMap");

RMapReactive<MyKey, MyValue> mapReactive = redissonReactive.getMap("myMap");

RMapRx<MyKey, MyValue> mapRx = redissonRx.getMap("myMap");

// 4. Get Redis based implementation of java.util.concurrent.locks.Lock
RLock lock = redisson.getLock("myLock");

RLockReactive lockReactive = redissonReactive.getLock("myLock");

RLockRx lockRx = redissonRx.getLock("myLock");

// 4. Get Redis based implementation of java.util.concurrent.ExecutorService
RExecutorService executor = redisson.getExecutorService("myExecutorService");

// over 50 Redis based Java objects and services ...

Upgrade to Redisson PRO with advanced features.