Redisson - Redis Java client
with features of In-Memory Data Grid

Based on high-performance async and lock-free Java Redis client and Netty framework.
JDK compatibility: 1.8 - 15, 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
RxJava2 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
Spring Framework
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 (Jackson JSON, Avro, Smile, CBOR, MsgPack, Kryo, Amazon Ion, FST, LZ4, Snappy and JDK Serialization)
With over 2000 unit tests

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

Gradle

compile 'org.redisson:redisson:3.14.0'

SBT

libraryDependencies += "org.redisson" % "redisson" % "3.14.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.createReactive(config);

// RxJava2 API
RedissonRxClient redissonRx = Redisson.createRx(config);

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

Consider Redisson PRO version for advanced features and support by SLA.