Redis 中文文档

Redisson - Easy 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.Supported JDK:   1.8 ... 20 and AndroidSupported Redis: 3.0 ... 7.0

Features


Thread-safe implementation
Supports Redis Replicated, Redis Cluster, Redis Sentinel, Redis Master and Slaves, Redis Single setup
Amazon Web Services compatible
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
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 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 many popular codecs (JBoss Marshalling, Jackson JSON, Avro, Smile, CBOR, MsgPack, Kryo, Amazon Ion, LZ4, Snappy and JDK Serialization)
Over 1800 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


  1. ``` sh
  2. <dependency>
  3.    <groupId>org.redisson</groupId>
  4.    <artifactId>redisson</artifactId>
  5.    <version>3.20.1</version>
  6. </dependency>  

  8. ```

Gradle


  1. ``` sh
  2. compile 'org.redisson:redisson:3.20.1'  

  4. ```

SBT


  1. ``` sh
  2. libraryDependencies += "org.redisson" % "redisson" % "3.20.1"

  4. ```

Java


  1. ``` java
  2. // 1. Create config object
  3. Config config = new Config();
  4. config.useClusterServers()
  5.        // use "rediss://" for SSL connection
  6.       .addNodeAddress("redis://127.0.0.1:7181");

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

  1. ``` java
  2. // 2. Create Redisson instance

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

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

  10. // RxJava3 API
  11. RedissonRxClient redissonRx = redisson.rxJava();
  12. ```

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

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

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

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

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

  7. RLockRx lockRx = redissonRx.getLock("myLock");
  8. ```

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

  5. // over 50 Redis based Java objects and services ...
  6. ```

Upgrade to Redisson PRO with advanced features.

Downloads


Redisson 3.20.1, Redisson node 3.20.1

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?