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

Quick start | Documentation | Changelog | Code examples | FAQs | Report an issue

Based on high-performance async and lock-free Java Redis client and Netty framework.
Supported JDK: 1.8 - 21 and Android

Features

• Thread-safe implementation
• Redis 3.0 - 7.2 compatible
• Valkey 7.2.5+ compatible
• 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
• 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.32.0</version>
</dependency>  

Gradle

compile 'org.redisson:redisson:3.32.0'  

SBT

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

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.

Downloads

Redisson 3.32.0, Redisson node 3.32.0

FAQs

Q: What is the cause of RedisTimeoutException?

Q: When do I need to shut down a Redisson instance, at the end of each request or the end of the life of a thread?

Q: In MapCache/SetCache/SpringCache/JCache, I have set an expiry time to an entry, why is it still in Redis when it should be disappeared?

Q: How can I perform Pipelining/Transaction through Redisson?

Q: Is Redisson thread safe? Can I share an instance of it between different threads?

Q: Can I use different encoder/decoders for different tasks?