All Classes and Interfaces
Class
Description
This class is going to be instantiated and becomes a static field of
the proxied target class.
Created by hasaadon on 15/02/2018.
Asynchronous iterator
Result object for autoClaim request.
Avro binary codec
Base status listener for Redis PubSub channel status changes
Base Redis nodes API interface
Base status listener for Redis PubSub channel status changes
Configuration for Batch object.
This is not a concurrent map.
Asynchronous interface for JCache
Cache config object used for Spring cache configuration.
Created by jribble on 2/20/17.
Reactive interface for JCache
RxJava2 interface for JCache
Deprecated.
Deprecated.
Redis codec interface.
Redis protocol command decoder
Redis protocol command encoder
Maps Redis command names.
Redis Publish Subscribe protocol decoder
Load Balancer redirects specified commands to the Redis node with specified address.
Interface for conditional object
Conditions factory to search for Live Objects by fields.
Redisson configuration
Redis connection listener
Credentials object with username and password used for Redis connection.
Credentials resolver object which is invoked during connection/reconnection process.
Cron expression object used in
RScheduledExecutorService
.Redisson Object Event listener for deleted event published by Redis.
Arguments object for deque move method.
Arguments object for deque move method.
DNS changes monitor.
Deprecated.
Deprecated.
Eviction scheduler.
Configuration for ExecutorService.
Redisson Object Event listener for expired event published by Redis.
Result object for autoClaim request.
Field index for
RSearch.createIndex(String, IndexOptions, FieldIndex...)
methodOptions object for vector field index which uses FLAT indexing method.
Optional options object for vector field index which uses FLAT indexing method.
Deprecated.
Encapsulates information about Redis functions library.
Function execution mode.
Function result type.
Encapsulates information about currently running
Redis function and available execution engines.
Geo filter for
QueryOptions.filters(QueryFilter...)
methodGeo field index options.
Arguments object for RGeo search method.
HighwayHash algorithm.
Options object for vector field index which uses HNSW indexing method.
Optional options object for vector field index which uses HNSW indexing method.
Maps host of RedisURI object using map defined in
hostsMap
setting.Maps host and port of RedisURI object using map defined in
hostsMap
setting.Identifier generator
Redisson Object Event listener for incrby event published by Redis.
Code parts from Manik Surtani ([email protected])
Amazon Ion codec based on Jackson implementation
https://github.com/FasterXML/jackson-dataformats-binary/tree/master/ion
Jackson Json codec.
JCache implementation
Configuration object for JCache
Cache
Entry event element passed to EventListener of JCache object
Redisson object factory used to register instance in JNDI registry.
Json codec interface.
Json codec based on Jackson implementation.
Json data type
Json data type convertor
Kryo 5 codec
Kryo 4 codec
LFU (least frequently used) cache.
Redisson Object Event listener for rpush event published by Redis.
Redisson Object Event listener for lset event published by Redis.
Redisson Object Event listener for lrem event published by Redis.
Redisson Object Event listener for lset event published by Redis.
Redisson Object Event listener for ltrim event published by Redis.
Configuration for LocalCachedMap object.
Various strategies to avoid stale objects in local cache.
Redisson Object Event listener for local cache invalidation event published by Redis.
Redisson Object Event listener for local cache update event published by Redis.
Configuration for Lock object.
Factory for LockOptions.BackOffPolicy class.
Generator of sleep period values for RedissonSpinLock back off
Back off algorithm, where sleep period is constant and is defined by LockOptions.ConstantBackOff.delay.
Back off algorithm, where sleep period starts with LockOptions.ExponentialBackOff.initialDelay, each time increases
LockOptions.ExponentialBackOff.multiplier times but doesn't exceed LockOptions.ExponentialBackOff.maxDelay
LRU (least recently used) cache.
LZ4 compression codec.
Configuration for RMapCache object.
Map loader used for read-through operations or during
RMap.loadAll(boolean, int)
execution.Map loader used for read-through operations or during
RMap.loadAll(boolean, int)
execution.Configuration for RMap object.
Redisson Object Event listener for hset event published by Redis.
Redisson Object Event listener for hdel event published by Redis.
Map writer used for write-through operations.
Asynchronous Map writer used for write-through operations.
Deprecated.
Connection pool for master node
Connection pool for Publish/Subscribe used with single node
Listener for Redis messages published via RTopic Redisson object
MsgPack binary codec
Maps Redisson object name.
Maps RedisURI object.
This interface allows to create hooks applied
after Netty Bootstrap and Channel object initialization.
Deprecated.
Deprecated.
Deprecated.
Numeric filter for
QueryOptions.filters(QueryFilter...)
methodNumeric field index options.
Redisson Object Event listener for Expired or Deleted event.
Arguments object for RGeo search method.
Listener for Redis messages published via RTopic Redisson object
Listener for Redis PubSub channel status changes
Entry object for pending messages request.
Result object for pending messages request.
Connection pool for Publish / Subscribe
Nikita Koksharov
Query filter for
RSearch.search(String, String, QueryOptions)
methodSearch query options for
RSearch.search(String, String, QueryOptions)
methodRandom identifier
Distributed implementation to the AtomicDouble
Distributed implementation to the AtomicDouble
Reactive interface for AtomicDouble object
Reactive interface for AtomicDouble object
Distributed implementation of
AtomicLong
Distributed async implementation of
AtomicLong
Reactive interface for AtomicLong object
RxJava2 interface for AtomicLong object
Interface for using Redis pipeline feature.
Reactive interface for Redis pipeline feature.
RxJava2 interface for Redis pipeline feature.
Binary stream holder stores a sequence of bytes.
Binary stream holder stores a sequence of bytes.
Binary stream holder stores a sequence of bytes.
Vector of bits that grows as needed.
Vector of bits that grows as needed.
Reactive interface for BitSet object
RxJava2 interface for BitSet object
BlockingDeque
backed by RedisDistributed async implementation of
BlockingDeque
Reactive interface for Redis based BlockingDeque object
RxJava2 interface for Redis based BlockingDeque object
Distributed implementation of
BlockingQueue
Distributed async implementation of
BlockingQueue
Reactive interface for BlockingQueue object
RxJava2 interface for BlockingQueue
Distributed implementation of Bloom filter based on Highway 128-bit hash.
Distributed implementation of bounded
BlockingQueue
Distributed async implementation of bounded
BlockingQueue
Object holder.
Async implementation of object holder.
Reactive implementation of object holder.
Reactive implementation of object holder.
Operations over multiple Bucket objects.
Operations over multiple Bucket objects.
Operations over multiple Bucket objects.
Operations over multiple Bucket objects.
Specifies that the defined cascade types are applied to the object/objects contained in Live Object field.
Live Object cascade type.
Collates result from
RReducer
tasks and produces a single result object.Common async interface for collection object
Mapper task invoked during map phase of MapReduce process and launched across Redisson Nodes.
MapReduce allows to process large amount of data stored in
RSet
, RList
, RSetCache
, RScoredSortedSet
, RSortedSet
and others
using Mapper, Reducer and/or Collator tasks launched across Redisson Nodes.Common reactive interface for collection object
Common RxJava2 interface for collection object
Stores each key/value mapping during map phase of MapReduce process.
Redis based implementation of
CountDownLatch
It has an advantage over CountDownLatch
--
count can be set via RCountDownLatch.trySetCount(long)
method.Async interface of Redis based
CountDownLatch
It has an advantage over CountDownLatch
--
count can be set via RCountDownLatchAsync.trySetCountAsync(long)
method.Reactive interface of Redis based
CountDownLatch
It has an advantage over CountDownLatch
--
count can be set via RCountDownLatchReactive.trySetCount(long)
method.RxJava2 interface of Redis based
CountDownLatch
It has an advantage over CountDownLatch
--
count can be set via RCountDownLatchRx.trySetCount(long)
method.Distributed implementation of delayed queue.
Distributed implementation of
Deque
Distributed async implementation of
Deque
Reactive interface for Deque object
RxJava2 interface for Deque object
All objects that implement this interface
should be destroyed via
RDestroyable.destroy()
method.Distributed implementation of
DoubleAdder
Deprecated.
A thread gate, that uses an
AbstractQueuedSynchronizer
.This error occurs when Redis requires authentication.
This error occurs when Redis server is busy.
Low-level Redis client
Redis Cluster nodes API interface
This error occurs when Redis Cluster is down.
Redis Cluster Master node API interface
Redis Cluster Master node API interface
Base Redis Cluster node API interface
Base Redis Cluster node API interface
Deprecated.
Redis Cluster Salve node API interface
Redis Master node API interface
Redis Master node API interface
Redis Master Slave nodes API interface
Base Redis node API interface
Base Redis node API interface
Deprecated.
This error occurs in case when Redis server free memory exhausted.
Redis Sentinel node API interface
Redis Sentinel node API interface
Redis Sentinel Master Slave nodes API interface
Redis Single node API interface
Redis Slave node API interface
Redis Slave node API interface
Main infrastructure class allows to get access
to all Redisson objects on top of Redis server.
Distributed alternative to the
AtomicLong
Distributed alternative to the
AtomicLong
Base class for implementing distributed locks
Distributed and concurrent implementation of
BlockingDeque
.Distributed and concurrent implementation of
BlockingQueue
.Bloom filter based on Highway 128-bit hash.
Distributed and concurrent implementation of bounded
BlockingQueue
.Main Redisson interface for access
to all redisson objects with sync/async interface.
A
CompletionService
that uses a supplied Executor
to execute tasks.Distributed alternative to the
CountDownLatch
It has a advantage over CountDownLatch
--
count can be reset via RedissonCountDownLatch.trySetCount(long)
.Distributed and concurrent implementation of
Queue
Distributed implementation of
Lock will be removed automatically if client disconnects.
Lock
Implements reentrant lock.Lock will be removed automatically if client disconnects.
Redis based implementation of Fenced Lock with reentrancy support.
Geospatial items holder
Deprecated.
Json data holder
Sorted set contained values of String type
Distributed and concurrent implementation of
List
List based Multimap Cache values holder
Distributed and concurrent implementation of
List
Distributed and concurrent implementation of
List
Distributed implementation of
Lock will be removed automatically if client disconnects.
Lock
Implements reentrant lock.Lock will be removed automatically if client disconnects.
Distributed and concurrent implementation of
ConcurrentMap
and Map
Map-based cache with ability to set TTL for each entry via
RedissonMapCache.put(Object, Object, long, TimeUnit)
or RedissonMapCache.putIfAbsent(Object, Object, long, TimeUnit)
methods.Distributed and concurrent implementation of
ConcurrentMap
and Map
Groups multiple independent locks and manages them as one lock.
Redisson Node configuration
Redisson Node file configuration
Node initializer callback interface.
Base Redisson object
Distributed topic implementation.
Distributed and concurrent implementation of priority blocking deque.
Distributed and concurrent implementation of
PriorityBlockingQueue
.Distributed and concurrent implementation of
Queue
Distributed and concurrent implementation of
Queue
Main infrastructure class allows to get access
to all Redisson objects on top of Redis server.
Main Redisson interface for access
to all redisson objects with Reactive interface.
Lock will be removed automatically if client disconnects.
A
ReadWriteLock
maintains a pair of associated locks
, one for read-only operations and one for writing.RedLock locking algorithm implementation for multiple locks.
Main infrastructure class allows to get access
to all Redisson objects on top of Redis server.
Main Redisson interface for access
to all redisson objects with RxJava2 interface.
Distributed and concurrent implementation of
Semaphore
.Deprecated.
Distributed and concurrent implementation of
Set
Set-based cache with ability to set TTL for each entry via
RSetCache.add(Object, long, TimeUnit)
method.Set based Multimap Cache values holder
Distributed and concurrent implementation of
Set
Distributed and concurrent implementation of
Set
Sharded Topic for Redis Cluster.
Distributed implementation of
Lock will be removed automatically if client disconnects.
Lock
Implements reentrant lock.Lock will be removed automatically if client disconnects.
A
CacheManager
implementation
backed by Redisson instance.Distributed and concurrent implementation of
List
Distributed topic implementation.
Deprecated.
Lock will be removed automatically if client disconnects.
This error occurs when Redis server is busy.
Reducer object for
RSearch.aggregate(String, String, AggregationOptions)
methodCreated by jribble on 2/20/17.
RRemoteService invocation options.
Worker sends this message when it has received a
RemoteServiceRequest
.Rises when remote method executor has not answered
within Ack timeout.
Rises when invocation timeout has been occurred
Specifies that the class is a Live Object.
ConnectionManager
for AWS ElastiCache Replication Groups or Azure Redis Cache.Configuration for an Azure Redis Cache or AWS ElastiCache servers.
Future object for submitted tasks in a batch
Future object for submitted task
Distributed implementation of
ExecutorService
Distributed async implementation of
ExecutorService
Base interface for all Redisson objects
which support expiration or TTL
Base async interface for all Redisson objects
which supports expiration (TTL)
Base interface for all Redisson objects
which support expiration or TTL
Base interface for all Redisson objects
which support expiration or TTL
Redis based implementation of Fenced Lock with reentrancy support.
Async interface for Redis based implementation of Fenced Lock with reentrancy support.
Redis based implementation of Fenced Lock with reentrancy support.
Redis based implementation of Fenced Lock with reentrancy support.
Specifies that the method is a field accessor for Live Object.
Interface for Redis Function feature
Interface for Redis Function feature
Interface for Redis Function feature
Interface for Redis Function feature
Represents the result of an asynchronous computation
Geospatial items holder.
Geospatial items holder.
Geospatial items holder.
Geospatial items holder.
Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
Probabilistic data structure that lets you maintain counts of millions of items with extreme space efficiency.
Specifies that the field is a Live Object's id field.
Id generator of
Long
type numbers.Id generator of
Long
type numbers.Id generator of
Long
type numbers.Id generator of
Long
type numbers.Specifies that the field is used in search index.
Specifies that the field value is filled up with RedissonClient instance.
Redis JSON datatype holder.
Redis JSON datatype interface.
Redis JSON datatype holder.
Redis JSON datatype holder.
Sorted set contained values of String type
Async interface for sorted set contained values of String type.
Reactive interface for sorted set contained values of String type.
RxJava2 interface for sorted set contained values of String type.
Distributed and concurrent implementation of
List
Async list functions
List based Multimap.
List based Multimap.
Reactive interface for
RListMultimapCache
object.Rx-ified version of
RListMultimapCache
.Reactive interface for List based Multimap object
RxJava2 interface for List based Multimap object
list functions
list functions
The pre-registration of each entity class is not necessary.
Map object with local entry cache support.
Map object with local entry cache support.
Map object with local entry cache support.
Redis based implementation of
Lock
Implements re-entrant lock.Async interface for Lock object
Reactive interface for Lock object
RxJava2 interface for Lock object
Distributed implementation of
LongAdder
Redis based implementation of
ConcurrentMap
and Map
Async interface for Redis based implementation
of
ConcurrentMap
and Map
Map-based cache with ability to set TTL for each entry via
RMapCache.put(Object, Object, long, TimeUnit)
or RMapCache.putIfAbsent(Object, Object, long, TimeUnit)
And therefore has an complex lua-scripts inside.Map-based cache with ability to set TTL for each entry via
RMapCache.put(Object, Object, long, TimeUnit)
or RMapCache.putIfAbsent(Object, Object, long, TimeUnit)
And therefore has an complex lua-scripts inside.Map-based cache with ability to set TTL for each entry via
RMapCacheReactive.put(Object, Object, long, TimeUnit)
or RMapCacheReactive.putIfAbsent(Object, Object, long, TimeUnit)
method.Map-based cache with ability to set TTL for each entry via
RMapCacheRx.put(Object, Object, long, TimeUnit)
or RMapCacheRx.putIfAbsent(Object, Object, long, TimeUnit)
method.Mapper task invoked during map phase of MapReduce process and launched across Redisson Nodes.
Reactive interface for Redis based implementation
of
ConcurrentMap
and Map
MapReduce allows to process large amount of data stored in Redis map
using Mapper, Reducer and/or Collator tasks launched across Redisson Nodes.
Contains methods for MapReduce process execution.
RxJava2 interface for Redis based implementation
of
ConcurrentMap
and Map
Base Multimap interface.
Base asynchronous MultiMap interface.
Base Multimap interface.
Base asynchronous Multimap interface.
Reactive interface of
RMultimapCache
object.Rx-ified version of
RMultimapCache
.Base Reactive interface for Multimap object
Base RxJava2 interface for Multimap object
Base interface for all Redisson objects
Base asynchronous interface for all Redisson objects
By default
namingScheme
and/or codec
parameters specified in REntity
are applied for each Live Object field.Base Reactive interface for all Redisson objects
Base RxJava2 interface for all Redisson objects
Pattern based observer for Publish Subscribe object.
Reactive interface for Pattern based observer for Publish Subscribe object.
RxJava2 interface for Pattern based observer for Publish Subscribe object.
Semaphore object with lease time parameter support for each acquired permit.
Asynchronous interface for Semaphore object with lease time parameter support for each acquired permit.
Reactive interface for Semaphore object with lease time parameter support for each acquired permit.
RxJava2 interface for Semaphore object with lease time parameter support for each acquired permit.
RPriorityBlockingDeque backed by Redis
PriorityBlockingQueue backed by Redis
Redis based priority deque.
Redis based priority deque.
Queue
backed by RedisQueue
backed by RedisReactive interface for Queue object
RxJava2 interface for Queue object
Redis based Rate Limiter object.
Asynchronous interface for Redis based Rate Limiter object.
Reactive interface for Redis based Rate Limiter object.
Reactive interface for Redis based Rate Limiter object.
A
ReadWriteLock
maintains a pair of associated locks
, one for read-only operations and one for writing.A
ReadWriteLock
maintains a pair of associated locks
, one for read-only operations and one for writing.A
ReadWriteLock
maintains a pair of associated locks
, one for read-only operations and one for writing.Reduces values mapped by key into single value.
Reliable topic based on Redis Stream object.
Asynchronous interface for Reliable topic based on Redis Stream object.
Reactive interface for Reliable topic based on Redis Stream object.
RxJava2 interface for Reliable topic based on Redis Stream object.
Annotation used to mark interface as asynchronous
client interface for remote service interface.
Annotation used to mark interface as Reactive
client interface for remote service interface.
Annotation used to mark interface as RxJava2
client interface for remote service interface.
Allows to execute object methods remotely between Redisson instances (Server side and Client side instances in terms of remote invocation).
RingBuffer based queue evicts elements from the head if queue capacity became full.
RingBuffer based queue evicts elements from the head if queue capacity became full.
RingBuffer based queue evicts elements from the head if queue capacity became full.
RingBuffer based queue evicts elements from the head if queue capacity became full.
Redis based implementation of
ScheduledExecutorService
Redis based implementation of
ScheduledExecutorService
Set containing elements sorted by score.
Reactive interface for SortedSet object
RxJava2 interface for scored sorted set data structure.
Interface for Redis Script feature
Async interface for Redis Script feature
Reactive interface for Redis Script feature
RxJava2 interface for Redis Script feature
API for RediSearch module
Asynchronous API for RediSearch module
Reactive API for RediSearch module
RxJava3 API for RediSearch module
Redis based implementation of
Semaphore
.Async interface of Redis based
Semaphore
.Reactive interface of Redis based
Semaphore
.RxJava2 interface of Redis based
Semaphore
.Redis based implementation of
Set
Async set functions
Set-based cache with ability to set TTL for each object.
Async set functions
Reactive interface for RSetCache object
RxJava2 interface for RSetCache object
Set based Multimap.
Reactive interface for
RSetMultimapCache
object.Rx-ified version of
RSetMultimapCache
.Reactive interface for Set based Multimap
RxJava2 interface for Set based Multimap
Reactive interface for Redis based implementation of
Set
RxJava2 interface for Redis based implementation of
Set
Sharded Topic for Redis Cluster.
Sharded Topic for Redis Cluster.
Reactive interface for Sharded Topic.
RxJava3 interface for Sharded Topic.
Interface for Redis Stream object.
Async interface for Redis Stream object.
Reactive interface for Redis Stream object.
Reactive interface for Redis Stream object.
Redis based time-series collection.
Async interface for Redis based time-series collection.
Reactive interface for Redis based time-series collection.
Rx interface for Redis based time-series collection.
Distributed topic.
Distributed topic.
Reactive interface for Publish Subscribe object.
RxJava2 interface for Publish Subscribe object.
Transaction object allows to execute transactions over Redisson objects.
Reactive interface for transaction object allows to execute transactions over Redisson objects.
RxJava2 interface for transaction object allows to execute transactions over Redisson objects.
Redis based implementation of
TransferQueue
Async interface for Redis based implementation of
TransferQueue
Reactive interface of Redis based implementation of
TransferQueue
RxJava2 interface of Redis based implementation of
TransferQueue
Redisson Object Event listener for add event published by RScoredSortedSet object.
Redisson Object Event listener for zrem event published by Redis.
Search result object returned by
RSearch.search(String, String, QueryOptions)
methodAddress resolver which allows to control concurrency level of requests to DNS servers.
JDK's serialization codec.
Redisson Object Event listener for sadd event published by Redis.
Redisson Object Event listener for set event published by Redis.
Redisson Object Event listener for srem event published by Redis.
Redisson Object Event listener for spop event published by Redis.
Arguments object for RGeo search method.
Connection pool for slave node
Smile binary codec.
Deprecated.
Google's Snappy compression codec.
Spellcheck options for
RSearch.spellcheck(String, String, SpellcheckOptions)
methodListener for Redis PubSub channel status changes
Created by jribble on 2/20/17.
Arguments object for RStream.add() method.
Object containing details about Stream Consumer
Arguments object for
RStream.createGroup(StreamCreateGroupArgs)
method.Object containing details about Stream Group
Object containing details about Stream
Stream Message ID object
Arguments object for RStream.read() methods.
Arguments object for RStream.readGroup() methods.
Arguments object for RStream.read() methods.
Arguments object for RStream.readGroup() methods.
Arguments object for Stream trim method.
Arguments object for Stream trim method.
Arguments object for Stream trim method.
Tag field index options.
Task listener invoked when task was failed during execution
Task listener invoked when task was finished
Base task listener interface
Executor service runs Callable and Runnable tasks.
Task listener invoked when task was started
Task listener invoked when task was succeeded
Text field index options.
Time-series collection entry
This exception used to report an error during Transaction execution.
Configuration for Transaction.
This exception used to report an error during Transaction execution.
Deprecated.
Json Jackson Type codec.
Weighted Round Robin balancer.
Configuration for RExecutorService workers.
This error occurs when write operation over Redis connection can't be executed.