Redisson

Redisson - Redis Java client with features of In-Memory Data Grid. Over 50 Redis based Java objects and services: Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Publish / Subscribe, Bloom filter, Spring Cache, Tomcat, Scheduler, JCache API, Hibernate, MyBatis, RPC, local cache ...

Description

AWS ElastiCache, Cluster, Sentinel, Single modes

Distributed objects (Geo, Publish/Subscribe, BloomFilter, AtomicLong ...)

Distributed collections (Map, Multimap, Set, SortedSet, List, Blocking Queue, Blocking Deque ...)

Distributed locks and synchronizers (Lock, FairLock, MultiLock, ReadWriteLock, Semaphore, CountDownLatch)

Distributed services (Remote service, Live Object service, Executor service, Scheduled executor service)

SpringCache integration

Hibernate integration

Supports Reactive Streams

Supports many popular codecs (Jackson JSON, Avro, Smile, CBOR, MsgPack, Kryo, FST, LZ4, Snappy and JDK Serialization)

Licensed under the Apache License 2.0.

Code Quality Rank: L1

Programming language: Java

License: Apache License 2.0

Tags: Database     Distributed Applications    

Latest version: v3.16.3

README

Redisson - Redis Java clientwith features of an in-memory data grid

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

Based on high-performance async and lock-free Java Redis client and Netty framework.
JDK compatibility: 1.8 - 17, Android

Features

• Redis Replicated setup (including support of AWS ElastiCache and Azure Redis Cache)
  
• Redis Cluster setup (including support of AWS ElastiCache Cluster and Azure Redis Cache)
  
• Redis Sentinel setup
  
• Redis with Master with Slave only
  
• Redis single (including support of Azure Redis Cache and Google Cloud Memorystore for Redis)
  
• Thread-safe implementation
  
• Reactive Streams API
  
• RxJava3 API
  
• Asynchronous API
  
• Asynchronous connection pool
  
• Lua scripting
  
• 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 Transaction API implementation
• Spring Data Redis integration
• 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 Android platform
  
• Supports auto-reconnection
  
• Supports failed to send command auto-retry
  
• Supports OSGi
  
• Supports SSL
  
• Supports many popular codecs (JBoss Marshalling, Jackson JSON, Avro, Smile, CBOR, MsgPack, Kryo, Amazon Ion, LZ4, Snappy and JDK Serialization)
• With over 2000 unit tests
  <!-- Used by ================================                        
  

               

                   

                   

           

Logos, product names and all other trademarks displayed on this page belong to their respective holders and used for identification purposes only. Use of these trademarks, names and brands does not imply endorsement. -->

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.16.3</version>
</dependency>  

Gradle

compile 'org.redisson:redisson:3.16.3'  

SBT

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

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

Try Redisson PRO with ultra-fast performance and support by SLA.

Downloads

Redisson 3.16.3, Redisson node 3.16.3

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?