RedissonMapCache (Redisson 3.12.0 API)

java.lang.Object
- org.redisson.RedissonObject
- - org.redisson.RedissonMap<K,V>
  - - org.redisson.RedissonMapCache<K,V>

Type Parameters:

K - key

V - value

All Implemented Interfaces:

ConcurrentMap<K,V>, Map<K,V>, RDestroyable, RExpirable, RExpirableAsync, RMap<K,V>, RMapAsync<K,V>, RMapCache<K,V>, RMapCacheAsync<K,V>, RObject, RObjectAsync

Direct Known Subclasses:

RedissonTransactionalMapCache
```
public class RedissonMapCache<K,V>
extends RedissonMap<K,V>
implements RMapCache<K,V>
```
Map-based cache with ability to set TTL for each entry via put(Object, Object, long, TimeUnit) or putIfAbsent(Object, Object, long, TimeUnit) methods. And therefore has an complex lua-scripts inside.

Current redis implementation doesnt have map entry eviction functionality. Thus entries are checked for TTL expiration during any key/value/entry read operation. If key/value/entry expired then it doesn't returns and clean task runs asynchronous. Clean task deletes removes 100 expired entries at once. In addition there is EvictionScheduler. This scheduler deletes expired entries in time interval between 5 seconds to 2 hours.

If eviction is not required then it's better to use RedissonMap object.

Author:

Nikita Koksharov

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Field Summary
- Fields inherited from class org.redisson.RedissonObject
  codec, commandExecutor, name

Constructor Summary

Constructors
Constructor and Description
`RedissonMapCache(Codec codec, EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K,V> options, WriteBehindService writeBehindService)`
`RedissonMapCache(EvictionScheduler evictionScheduler, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K,V> options, WriteBehindService writeBehindService)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`V`	`addAndGet(K key, Number value)` Atomically adds the given `delta` to the current value by mapped `key`.
`protected RFuture<V>`	`addAndGetOperationAsync(K key, Number value)`
`int`	`addListener(MapEntryListener listener)` Adds map entry listener
`boolean`	`clearExpire()` Clear an expire timeout or expire date for object.
`RFuture<Boolean>`	`clearExpireAsync()` Clear an expire timeout or expire date for object in async mode.
`RFuture<Boolean>`	`containsKeyAsync(Object key)`
`RFuture<Boolean>`	`containsValueAsync(Object value)`
`RFuture<Boolean>`	`deleteAsync()` Delete object in async mode
`void`	`destroy()` Destroys object when it's not necessary anymore.
`boolean`	`expire(long timeToLive, TimeUnit timeUnit)` Set a timeout for object.
`RFuture<Boolean>`	`expireAsync(long timeToLive, TimeUnit timeUnit)` Set a timeout for object in async mode.
`boolean`	`expireAt(Date timestamp)` Set an expire date for object.
`boolean`	`expireAt(long timestamp)` Set an expire date for object.
`RFuture<Boolean>`	`expireAtAsync(Date timestamp)` Set an expire date for object in async mode.
`RFuture<Boolean>`	`expireAtAsync(long timestamp)` Set an expire date for object in async mode.
`boolean`	`fastPut(K key, V value, long ttl, TimeUnit ttlUnit)` Stores value mapped by key with specified time to live.
`boolean`	`fastPut(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)` Stores value mapped by key with specified time to live and max idle time.
`RFuture<Boolean>`	`fastPutAsync(K key, V value, long ttl, TimeUnit ttlUnit)` Stores value mapped by key with specified time to live.
`RFuture<Boolean>`	`fastPutAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)` Stores value mapped by key with specified time to live and max idle time.
`boolean`	`fastPutIfAbsent(K key, V value, long ttl, TimeUnit ttlUnit)` If the specified key is not already associated with a value, associate it with the given value.
`boolean`	`fastPutIfAbsent(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)` If the specified key is not already associated with a value, associate it with the given value.
`RFuture<Boolean>`	`fastPutIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)` If the specified key is not already associated with a value, associate it with the given value.
`protected RFuture<Boolean>`	`fastPutIfAbsentOperationAsync(K key, V value)`
`protected RFuture<Boolean>`	`fastPutOperationAsync(K key, V value)`
`protected RFuture<Boolean>`	`fastPutOperationAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)`
`protected RFuture<Long>`	`fastRemoveOperationAsync(K... keys)`
`protected RFuture<List<Long>>`	`fastRemoveOperationBatchAsync(K... keys)`
`protected RFuture<Boolean>`	`fastReplaceOperationAsync(K key, V value)`
`RFuture<Map<K,V>>`	`getAllOperationAsync(Set<K> keys)`
`RFuture<V>`	`getOperationAsync(K key)`
`V`	`put(K key, V value, long ttl, TimeUnit unit)` Stores value mapped by key with specified time to live.
`V`	`put(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)` Stores value mapped by key with specified time to live and max idle time.
`void`	`putAll(Map<? extends K,? extends V> map, long ttl, TimeUnit ttlUnit)` Associates the specified `value` with the specified `key` in batch.
`RFuture<Void>`	`putAllAsync(Map<? extends K,? extends V> map, long ttl, TimeUnit ttlUnit)` Associates the specified `value` with the specified `key` in batch.
`protected RFuture<Void>`	`putAllOperationAsync(Map<? extends K,? extends V> map)`
`RFuture<V>`	`putAsync(K key, V value, long ttl, TimeUnit ttlUnit)` Stores value mapped by key with specified time to live.
`RFuture<V>`	`putAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)` Stores value mapped by key with specified time to live and max idle time.
`V`	`putIfAbsent(K key, V value, long ttl, TimeUnit ttlUnit)` If the specified key is not already associated with a value, associate it with the given value.
`V`	`putIfAbsent(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)` If the specified key is not already associated with a value, associate it with the given value.
`RFuture<V>`	`putIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit)` If the specified key is not already associated with a value, associate it with the given value.
`RFuture<V>`	`putIfAbsentAsync(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)` If the specified key is not already associated with a value, associate it with the given value.
`protected RFuture<V>`	`putIfAbsentOperationAsync(K key, V value)`
`protected RFuture<V>`	`putOperationAsync(K key, V value)`
`protected RFuture<V>`	`putOperationAsync(K key, V value, long ttlTimeout, long maxIdleTimeout, long maxIdleDelta)`
`RFuture<Set<Map.Entry<K,V>>>`	`readAllEntrySetAsync()` Read all map entries at once
`RFuture<Set<K>>`	`readAllKeySetAsync()` Read all keys at once
`RFuture<Map<K,V>>`	`readAllMapAsync()` Read all map as local instance at once
`RFuture<Collection<V>>`	`readAllValuesAsync()` Read all values at once
`long`	`remainTimeToLive()` Remaining time to live of Redisson object that has a timeout
`long`	`remainTimeToLive(K key)` Remaining time to live of map entry associated with a `key`.
`RFuture<Long>`	`remainTimeToLiveAsync()` Remaining time to live of Redisson object that has a timeout
`RFuture<Long>`	`remainTimeToLiveAsync(K key)` Remaining time to live of map entry associated with a `key`.
`void`	`removeListener(int listenerId)` Removes object event listener
`protected RFuture<V>`	`removeOperationAsync(K key)`
`protected RFuture<Boolean>`	`removeOperationAsync(Object key, Object value)`
`protected RFuture<V>`	`replaceOperationAsync(K key, V value)`
`protected RFuture<Boolean>`	`replaceOperationAsync(K key, V oldValue, V newValue)`
`MapScanResult<Object,Object>`	`scanIterator(String name, RedisClient client, long startPos, String pattern, int count)`
`RFuture<MapScanResult<Object,Object>>`	`scanIteratorAsync(String name, RedisClient client, long startPos, String pattern, int count)`
`void`	`setMaxSize(int maxSize)` Sets max size of the map.
`RFuture<Void>`	`setMaxSizeAsync(int maxSize)` Sets max size of the map.
`RFuture<Long>`	`sizeInMemoryAsync()` Returns bytes amount used by object in Redis memory.
`boolean`	`trySetMaxSize(int maxSize)` Tries to set max size of the map.
`RFuture<Boolean>`	`trySetMaxSizeAsync(int maxSize)` Tries to set max size of the map.

Methods inherited from class org.redisson.RedissonMap
addAndGetAsync, checkKey, checkValue, clear, containsKey, containsValue, entryIterator, entrySet, entrySet, entrySet, entrySet, equals, fastPut, fastPutAsync, fastPutIfAbsent, fastPutIfAbsentAsync, fastRemove, fastRemoveAsync, fastReplace, fastReplaceAsync, get, getAll, getAllAsync, getAsync, getCountDownLatch, getFairLock, getLock, getPermitExpirableSemaphore, getReadWriteLock, getSemaphore, hashCode, hasNoLoader, hasNoWriter, isEmpty, keyIterator, keySet, keySet, keySet, keySet, loadAll, loadAll, loadAllAsync, loadAllAsync, mapReduce, mapWriterFuture, mapWriterFuture, put, putAll, putAll, putAllAsync, putAllAsync, putAsync, putIfAbsent, putIfAbsentAsync, readAllEntrySet, readAllKeySet, readAllMap, readAllValues, remove, remove, removeAsync, removeAsync, replace, replace, replaceAsync, replaceAsync, size, sizeAsync, valueIterator, values, values, values, values, valueSize, valueSizeAsync

Methods inherited from class org.redisson.RedissonObject
addListener, addListenerAsync, copy, copyAsync, delete, dump, dumpAsync, encode, encode, encode, encodeMapKey, encodeMapKeys, encodeMapValue, encodeMapValues, get, getCodec, getLockByMapKey, getLockByValue, getName, getName, isExists, isExistsAsync, migrate, migrateAsync, move, moveAsync, prefixName, removeListenerAsync, rename, renameAsync, renamenx, renamenxAsync, restore, restore, restoreAndReplace, restoreAndReplace, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemory, sizeInMemoryAsync, suffixName, toSeconds, toStream, touch, touchAsync, unlink, unlinkAsync

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.redisson.api.RMapCache
size

Methods inherited from interface org.redisson.api.RMap
entrySet, entrySet, entrySet, entrySet, fastPut, fastPutIfAbsent, fastRemove, fastReplace, get, getAll, getCountDownLatch, getFairLock, getLock, getPermitExpirableSemaphore, getReadWriteLock, getSemaphore, keySet, keySet, keySet, keySet, loadAll, loadAll, mapReduce, put, putAll, putAll, putIfAbsent, readAllEntrySet, readAllKeySet, readAllMap, readAllValues, remove, remove, replace, replace, values, values, values, values, valueSize

Methods inherited from interface java.util.concurrent.ConcurrentMap
compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface java.util.Map
clear, containsKey, containsValue, equals, hashCode, isEmpty

Methods inherited from interface org.redisson.api.RExpirable
clearExpire, expire, expireAt, expireAt, remainTimeToLive

Methods inherited from interface org.redisson.api.RObject
addListener, copy, delete, dump, getCodec, getName, isExists, migrate, move, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, sizeInMemory, touch, unlink

Methods inherited from interface org.redisson.api.RMapCacheAsync
sizeAsync

Methods inherited from interface org.redisson.api.RMapAsync
addAndGetAsync, fastPutAsync, fastPutIfAbsentAsync, fastRemoveAsync, fastReplaceAsync, getAllAsync, getAsync, loadAllAsync, loadAllAsync, putAllAsync, putAllAsync, putAsync, putIfAbsentAsync, removeAsync, removeAsync, replaceAsync, replaceAsync, valueSizeAsync

Methods inherited from interface org.redisson.api.RExpirableAsync
expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.api.RObjectAsync
addListenerAsync, copyAsync, dumpAsync, isExistsAsync, migrateAsync, moveAsync, removeListenerAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, touchAsync, unlinkAsync

- Constructor Detail
  - RedissonMapCache
```
public RedissonMapCache(EvictionScheduler evictionScheduler,
                        CommandAsyncExecutor commandExecutor,
                        String name,
                        RedissonClient redisson,
                        MapOptions<K,V> options,
                        WriteBehindService writeBehindService)
```
  - RedissonMapCache
```
public RedissonMapCache(Codec codec,
                        EvictionScheduler evictionScheduler,
                        CommandAsyncExecutor commandExecutor,
                        String name,
                        RedissonClient redisson,
                        MapOptions<K,V> options,
                        WriteBehindService writeBehindService)
```
- Method Detail
  - trySetMaxSize
```
public boolean trySetMaxSize(int maxSize)
```
    Description copied from interface: RMapCache
    
    Tries to set max size of the map. Superfluous elements are evicted using LRU algorithm.
    
    Specified by:
    
    trySetMaxSize in interface RMapCache<K,V>
    
    Parameters:
    
    maxSize - - max size
    
    Returns:
    
    true if max size has been successfully set, otherwise false. If 0 the cache is unbounded (default).
  - trySetMaxSizeAsync
```
public RFuture<Boolean> trySetMaxSizeAsync(int maxSize)
```
    Description copied from interface: RMapCacheAsync
    
    Tries to set max size of the map. Superfluous elements are evicted using LRU algorithm.
    
    Specified by:
    
    trySetMaxSizeAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    maxSize - - max size
    
    Returns:
    
    true if max size has been successfully set, otherwise false.
  - setMaxSize
```
public void setMaxSize(int maxSize)
```
    Description copied from interface: RMapCache
    
    Sets max size of the map. Superfluous elements are evicted using LRU algorithm.
    
    Specified by:
    
    setMaxSize in interface RMapCache<K,V>
    
    Parameters:
    
    maxSize - - max size If 0 the cache is unbounded (default).
  - setMaxSizeAsync
```
public RFuture<Void> setMaxSizeAsync(int maxSize)
```
    Description copied from interface: RMapCacheAsync
    
    Sets max size of the map. Superfluous elements are evicted using LRU algorithm.
    
    Specified by:
    
    setMaxSizeAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    maxSize - - max size
    
    Returns:
    
    void
  - containsKeyAsync
```
public RFuture<Boolean> containsKeyAsync(Object key)
```
    Specified by:
    
    containsKeyAsync in interface RMapAsync<K,V>
    
    Overrides:
    
    containsKeyAsync in class RedissonMap<K,V>
  - containsValueAsync
```
public RFuture<Boolean> containsValueAsync(Object value)
```
    Specified by:
    
    containsValueAsync in interface RMapAsync<K,V>
    
    Overrides:
    
    containsValueAsync in class RedissonMap<K,V>
  - getAllOperationAsync
```
public RFuture<Map<K,V>> getAllOperationAsync(Set<K> keys)
```
    Overrides:
    
    getAllOperationAsync in class RedissonMap<K,V>
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value,
                     long ttl,
                     TimeUnit ttlUnit)
```
    Description copied from interface: RMapCache
    
    If the specified key is not already associated with a value, associate it with the given value.
    Stores value mapped by key with specified time to live. Entry expires after specified time to live.
    
    Specified by:
    
    putIfAbsent in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then stores infinitely.
    
    ttlUnit - - time unit
    
    Returns:
    
    current associated value
  - putIfAbsentAsync
```
public RFuture<V> putIfAbsentAsync(K key,
                                   V value,
                                   long ttl,
                                   TimeUnit ttlUnit)
```
    Description copied from interface: RMapCacheAsync
    
    If the specified key is not already associated with a value, associate it with the given value.
    Stores value mapped by key with specified time to live. Entry expires after specified time to live. If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    
    Specified by:
    
    putIfAbsentAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then stores infinitely.
    
    ttlUnit - - time unit
    
    Returns:
    
    previous associated value
  - putIfAbsent
```
public V putIfAbsent(K key,
                     V value,
                     long ttl,
                     TimeUnit ttlUnit,
                     long maxIdleTime,
                     TimeUnit maxIdleUnit)
```
    Description copied from interface: RMapCache
    
    If the specified key is not already associated with a value, associate it with the given value.
    Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.
    
    Specified by:
    
    putIfAbsent in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.
    
    ttlUnit - - time unit
    
    maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.
    
    maxIdleUnit - - time unit
    if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.
    
    Returns:
    
    current associated value
  - putIfAbsentAsync
```
public RFuture<V> putIfAbsentAsync(K key,
                                   V value,
                                   long ttl,
                                   TimeUnit ttlUnit,
                                   long maxIdleTime,
                                   TimeUnit maxIdleUnit)
```
    Description copied from interface: RMapCacheAsync
    
    If the specified key is not already associated with a value, associate it with the given value.
    Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.
    If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    
    Specified by:
    
    putIfAbsentAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.
    
    ttlUnit - - time unit
    
    maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.
    
    maxIdleUnit - - time unit
    if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.
    
    Returns:
    
    previous associated value
  - removeOperationAsync
```
protected RFuture<Boolean> removeOperationAsync(Object key,
                                                Object value)
```
    Overrides:
    
    removeOperationAsync in class RedissonMap<K,V>
  - getOperationAsync
```
public RFuture<V> getOperationAsync(K key)
```
    Overrides:
    
    getOperationAsync in class RedissonMap<K,V>
  - put
```
public V put(K key,
             V value,
             long ttl,
             TimeUnit unit)
```
    Description copied from interface: RMapCache
    
    Stores value mapped by key with specified time to live. Entry expires after specified time to live.
    If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    
    Specified by:
    
    put in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then stores infinitely.
    
    unit - - time unit
    
    Returns:
    
    previous associated value
  - putOperationAsync
```
protected RFuture<V> putOperationAsync(K key,
                                       V value)
```
    Overrides:
    
    putOperationAsync in class RedissonMap<K,V>
  - putIfAbsentOperationAsync
```
protected RFuture<V> putIfAbsentOperationAsync(K key,
                                               V value)
```
    Overrides:
    
    putIfAbsentOperationAsync in class RedissonMap<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> map,
                   long ttl,
                   TimeUnit ttlUnit)
```
    Description copied from interface: RMapCache
    
    Associates the specified value with the specified key in batch.
    If MapWriter is defined then new map entries will be stored in write-through mode.
    
    Specified by:
    
    putAll in interface RMapCache<K,V>
    
    Parameters:
    
    map - - mappings to be stored in this map
    
    ttl - - time to live for all key\value entries. If 0 then stores infinitely.
    
    ttlUnit - - time unit
  - putAllAsync
```
public RFuture<Void> putAllAsync(Map<? extends K,? extends V> map,
                                 long ttl,
                                 TimeUnit ttlUnit)
```
    Description copied from interface: RMapCache
    
    Associates the specified value with the specified key in batch.
    If MapWriter is defined then new map entries are stored in write-through mode.
    
    Specified by:
    
    putAllAsync in interface RMapCache<K,V>
    
    Parameters:
    
    map - - mappings to be stored in this map
    
    ttl - - time to live for all key\value entries. If 0 then stores infinitely.
    
    ttlUnit - - time unit
    
    Returns:
    
    void
  - addAndGet
```
public V addAndGet(K key,
                   Number value)
```
    Description copied from interface: RMap
    
    Atomically adds the given delta to the current value by mapped key. Works only for numeric values!
    
    Specified by:
    
    addAndGet in interface RMap<K,V>
    
    Overrides:
    
    addAndGet in class RedissonMap<K,V>
    
    Parameters:
    
    key - - map key
    
    value - the value to add
    
    Returns:
    
    the updated value
  - addAndGetOperationAsync
```
protected RFuture<V> addAndGetOperationAsync(K key,
                                             Number value)
```
    Overrides:
    
    addAndGetOperationAsync in class RedissonMap<K,V>
  - fastPut
```
public boolean fastPut(K key,
                       V value,
                       long ttl,
                       TimeUnit ttlUnit)
```
    Description copied from interface: RMapCache
    
    Stores value mapped by key with specified time to live. Entry expires after specified time to live.
    If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    Works faster than usual RMapCache.put(Object, Object, long, TimeUnit) as it not returns previous value.
    
    Specified by:
    
    fastPut in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then stores infinitely.
    
    ttlUnit - - time unit
    
    Returns:
    
    true if key is a new key in the hash and value was set. false if key already exists in the hash and the value was updated.
  - fastPutAsync
```
public RFuture<Boolean> fastPutAsync(K key,
                                     V value,
                                     long ttl,
                                     TimeUnit ttlUnit)
```
    Description copied from interface: RMapCacheAsync
    
    Stores value mapped by key with specified time to live. Entry expires after specified time to live.
    If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    Works faster than usual RMapCacheAsync.putAsync(Object, Object, long, TimeUnit) as it not returns previous value.
    
    Specified by:
    
    fastPutAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then stores infinitely.
    
    ttlUnit - - time unit
    
    Returns:
    
    true if key is a new key in the hash and value was set. false if key already exists in the hash and the value was updated.
  - fastPut
```
public boolean fastPut(K key,
                       V value,
                       long ttl,
                       TimeUnit ttlUnit,
                       long maxIdleTime,
                       TimeUnit maxIdleUnit)
```
    Description copied from interface: RMapCache
    
    Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.
    If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    Works faster than usual RMapCache.put(Object, Object, long, TimeUnit, long, TimeUnit) as it not returns previous value.
    
    Specified by:
    
    fastPut in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.
    
    ttlUnit - - time unit
    
    maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.
    
    maxIdleUnit - - time unit
    if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.
    
    Returns:
    
    true if key is a new key in the hash and value was set. false if key already exists in the hash and the value was updated.
  - fastPutAsync
```
public RFuture<Boolean> fastPutAsync(K key,
                                     V value,
                                     long ttl,
                                     TimeUnit ttlUnit,
                                     long maxIdleTime,
                                     TimeUnit maxIdleUnit)
```
    Description copied from interface: RMapCacheAsync
    
    Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.
    If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    Works faster than usual RMapCacheAsync.putAsync(Object, Object, long, TimeUnit, long, TimeUnit) as it not returns previous value.
    
    Specified by:
    
    fastPutAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.
    
    ttlUnit - - time unit
    
    maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.
    
    maxIdleUnit - - time unit
    if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.
    
    Returns:
    
    true if key is a new key in the hash and value was set. false if key already exists in the hash and the value was updated.
  - fastPutOperationAsync
```
protected RFuture<Boolean> fastPutOperationAsync(K key,
                                                 V value,
                                                 long ttl,
                                                 TimeUnit ttlUnit,
                                                 long maxIdleTime,
                                                 TimeUnit maxIdleUnit)
```
  - putAsync
```
public RFuture<V> putAsync(K key,
                           V value,
                           long ttl,
                           TimeUnit ttlUnit)
```
    Description copied from interface: RMapCacheAsync
    
    Stores value mapped by key with specified time to live. Entry expires after specified time to live. If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    
    Specified by:
    
    putAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then stores infinitely.
    
    ttlUnit - - time unit
    
    Returns:
    
    previous associated value
  - put
```
public V put(K key,
             V value,
             long ttl,
             TimeUnit ttlUnit,
             long maxIdleTime,
             TimeUnit maxIdleUnit)
```
    Description copied from interface: RMapCache
    
    Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.
    If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    
    Specified by:
    
    put in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.
    
    ttlUnit - - time unit
    
    maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.
    
    maxIdleUnit - - time unit
    if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.
    
    Returns:
    
    previous associated value
  - putAsync
```
public RFuture<V> putAsync(K key,
                           V value,
                           long ttl,
                           TimeUnit ttlUnit,
                           long maxIdleTime,
                           TimeUnit maxIdleUnit)
```
    Description copied from interface: RMapCacheAsync
    
    Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.
    If the map previously contained a mapping for the key, the old value is replaced by the specified value.
    
    Specified by:
    
    putAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.
    
    ttlUnit - - time unit
    
    maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.
    
    maxIdleUnit - - time unit
    if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.
    
    Returns:
    
    previous associated value
  - putOperationAsync
```
protected RFuture<V> putOperationAsync(K key,
                                       V value,
                                       long ttlTimeout,
                                       long maxIdleTimeout,
                                       long maxIdleDelta)
```
  - remainTimeToLive
```
public long remainTimeToLive(K key)
```
    Description copied from interface: RMapCache
    
    Remaining time to live of map entry associated with a key.
    
    Specified by:
    
    remainTimeToLive in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.
  - remainTimeToLiveAsync
```
public RFuture<Long> remainTimeToLiveAsync(K key)
```
    Description copied from interface: RMapCacheAsync
    
    Remaining time to live of map entry associated with a key.
    
    Specified by:
    
    remainTimeToLiveAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    key - - map key
    
    Returns:
    
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.
  - removeOperationAsync
```
protected RFuture<V> removeOperationAsync(K key)
```
    Overrides:
    
    removeOperationAsync in class RedissonMap<K,V>
  - fastRemoveOperationBatchAsync
```
protected RFuture<List<Long>> fastRemoveOperationBatchAsync(K... keys)
```
    Overrides:
    
    fastRemoveOperationBatchAsync in class RedissonMap<K,V>
  - fastRemoveOperationAsync
```
protected RFuture<Long> fastRemoveOperationAsync(K... keys)
```
    Overrides:
    
    fastRemoveOperationAsync in class RedissonMap<K,V>
  - scanIterator
```
public MapScanResult<Object,Object> scanIterator(String name,
                                                 RedisClient client,
                                                 long startPos,
                                                 String pattern,
                                                 int count)
```
    Overrides:
    
    scanIterator in class RedissonMap<K,V>
  - scanIteratorAsync
```
public RFuture<MapScanResult<Object,Object>> scanIteratorAsync(String name,
                                                               RedisClient client,
                                                               long startPos,
                                                               String pattern,
                                                               int count)
```
    Overrides:
    
    scanIteratorAsync in class RedissonMap<K,V>
  - fastPutOperationAsync
```
protected RFuture<Boolean> fastPutOperationAsync(K key,
                                                 V value)
```
    Overrides:
    
    fastPutOperationAsync in class RedissonMap<K,V>
  - fastPutIfAbsentOperationAsync
```
protected RFuture<Boolean> fastPutIfAbsentOperationAsync(K key,
                                                         V value)
```
    Overrides:
    
    fastPutIfAbsentOperationAsync in class RedissonMap<K,V>
  - fastPutIfAbsent
```
public boolean fastPutIfAbsent(K key,
                               V value,
                               long ttl,
                               TimeUnit ttlUnit)
```
    Description copied from interface: RMapCache
    
    If the specified key is not already associated with a value, associate it with the given value.
    Stores value mapped by key with specified time to live. Entry expires after specified time to live.
    Works faster than usual RMapCache.putIfAbsent(Object, Object, long, TimeUnit) as it not returns previous value.
    
    Specified by:
    
    fastPutIfAbsent in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then stores infinitely.
    
    ttlUnit - - time unit
    
    Returns:
    
    true if key is a new key in the hash and value was set. false if key already exists in the hash
  - fastPutIfAbsent
```
public boolean fastPutIfAbsent(K key,
                               V value,
                               long ttl,
                               TimeUnit ttlUnit,
                               long maxIdleTime,
                               TimeUnit maxIdleUnit)
```
    Description copied from interface: RMapCache
    
    If the specified key is not already associated with a value, associate it with the given value.
    Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.
    Works faster than usual RMapCache.putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit) as it not returns previous value.
    
    Specified by:
    
    fastPutIfAbsent in interface RMapCache<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.
    
    ttlUnit - - time unit
    
    maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.
    
    maxIdleUnit - - time unit
    if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.
    
    Returns:
    
    true if key is a new key in the hash and value was set. false if key already exists in the hash.
  - fastPutIfAbsentAsync
```
public RFuture<Boolean> fastPutIfAbsentAsync(K key,
                                             V value,
                                             long ttl,
                                             TimeUnit ttlUnit,
                                             long maxIdleTime,
                                             TimeUnit maxIdleUnit)
```
    Description copied from interface: RMapCacheAsync
    
    If the specified key is not already associated with a value, associate it with the given value.
    Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.
    Works faster than usual RMapCacheAsync.putIfAbsentAsync(Object, Object, long, TimeUnit, long, TimeUnit) as it not returns previous value.
    
    Specified by:
    
    fastPutIfAbsentAsync in interface RMapCacheAsync<K,V>
    
    Parameters:
    
    key - - map key
    
    value - - map value
    
    ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.
    
    ttlUnit - - time unit
    
    maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.
    
    maxIdleUnit - - time unit
    if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.
    
    Returns:
    
    true if key is a new key in the hash and value was set. false if key already exists in the hash
  - replaceOperationAsync
```
protected RFuture<Boolean> replaceOperationAsync(K key,
                                                 V oldValue,
                                                 V newValue)
```
    Overrides:
    
    replaceOperationAsync in class RedissonMap<K,V>
  - fastReplaceOperationAsync
```
protected RFuture<Boolean> fastReplaceOperationAsync(K key,
                                                     V value)
```
    Overrides:
    
    fastReplaceOperationAsync in class RedissonMap<K,V>
  - replaceOperationAsync
```
protected RFuture<V> replaceOperationAsync(K key,
                                           V value)
```
    Overrides:
    
    replaceOperationAsync in class RedissonMap<K,V>
  - putAllOperationAsync
```
protected RFuture<Void> putAllOperationAsync(Map<? extends K,? extends V> map)
```
    Overrides:
    
    putAllOperationAsync in class RedissonMap<K,V>
  - addListener
```
public int addListener(MapEntryListener listener)
```
    Description copied from interface: RMapCache
    
    Adds map entry listener
    
    Specified by:
    
    addListener in interface RMapCache<K,V>
    
    Parameters:
    
    listener - - entry listener
    
    Returns:
    
    listener id
    
    See Also:
    
    EntryCreatedListener, EntryUpdatedListener, EntryRemovedListener, EntryExpiredListener
  - removeListener
```
public void removeListener(int listenerId)
```
    Description copied from interface: RObject
    
    Removes object event listener
    
    Specified by:
    
    removeListener in interface RMapCache<K,V>
    
    Specified by:
    
    removeListener in interface RObject
    
    Overrides:
    
    removeListener in class RedissonObject
    
    Parameters:
    
    listenerId - - listener id
  - sizeInMemoryAsync
```
public RFuture<Long> sizeInMemoryAsync()
```
    Description copied from interface: RObjectAsync
    
    Returns bytes amount used by object in Redis memory.
    
    Specified by:
    
    sizeInMemoryAsync in interface RObjectAsync
    
    Overrides:
    
    sizeInMemoryAsync in class RedissonObject
    
    Returns:
    
    size in bytes
  - deleteAsync
```
public RFuture<Boolean> deleteAsync()
```
    Description copied from interface: RObjectAsync
    
    Delete object in async mode
    
    Specified by:
    
    deleteAsync in interface RObjectAsync
    
    Overrides:
    
    deleteAsync in class RedissonObject
    
    Returns:
    
    true if object was deleted false if not
  - expireAsync
```
public RFuture<Boolean> expireAsync(long timeToLive,
                                    TimeUnit timeUnit)
```
    Description copied from interface: RExpirableAsync
    
    Set a timeout for object in async mode. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expireAsync in interface RExpirableAsync
    
    Parameters:
    
    timeToLive - - timeout before object will be deleted
    
    timeUnit - - timeout time unit
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAtAsync
```
public RFuture<Boolean> expireAtAsync(long timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Set an expire date for object in async mode. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    
    timestamp - - expire date in milliseconds (Unix timestamp)
    
    Returns:
    
    true if the timeout was set and false if not
  - clearExpireAsync
```
public RFuture<Boolean> clearExpireAsync()
```
    Description copied from interface: RExpirableAsync
    
    Clear an expire timeout or expire date for object in async mode. Object will not be deleted.
    
    Specified by:
    
    clearExpireAsync in interface RExpirableAsync
    
    Returns:
    
    true if the timeout was cleared and false if not
  - readAllKeySetAsync
```
public RFuture<Set<K>> readAllKeySetAsync()
```
    Description copied from interface: RMapAsync
    
    Read all keys at once
    
    Specified by:
    
    readAllKeySetAsync in interface RMapAsync<K,V>
    
    Overrides:
    
    readAllKeySetAsync in class RedissonMap<K,V>
    
    Returns:
    
    keys
  - readAllEntrySetAsync
```
public RFuture<Set<Map.Entry<K,V>>> readAllEntrySetAsync()
```
    Description copied from interface: RMapAsync
    
    Read all map entries at once
    
    Specified by:
    
    readAllEntrySetAsync in interface RMapAsync<K,V>
    
    Overrides:
    
    readAllEntrySetAsync in class RedissonMap<K,V>
    
    Returns:
    
    entries
  - readAllMapAsync
```
public RFuture<Map<K,V>> readAllMapAsync()
```
    Description copied from interface: RMapAsync
    
    Read all map as local instance at once
    
    Specified by:
    
    readAllMapAsync in interface RMapAsync<K,V>
    
    Overrides:
    
    readAllMapAsync in class RedissonMap<K,V>
    
    Returns:
    
    map
  - readAllValuesAsync
```
public RFuture<Collection<V>> readAllValuesAsync()
```
    Description copied from interface: RMapAsync
    
    Read all values at once
    
    Specified by:
    
    readAllValuesAsync in interface RMapAsync<K,V>
    
    Overrides:
    
    readAllValuesAsync in class RedissonMap<K,V>
    
    Returns:
    
    values
  - destroy
```
public void destroy()
```
    Description copied from interface: RDestroyable
    
    Destroys object when it's not necessary anymore.
    
    Specified by:
    
    destroy in interface RDestroyable
  - expire
```
public boolean expire(long timeToLive,
                      TimeUnit timeUnit)
```
    Description copied from interface: RExpirable
    
    Set a timeout for object. After the timeout has expired, the key will automatically be deleted.
    
    Specified by:
    
    expire in interface RExpirable
    
    Parameters:
    
    timeToLive - - timeout before object will be deleted
    
    timeUnit - - timeout time unit
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(long timestamp)
```
    Description copied from interface: RExpirable
    
    Set an expire date for object. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    
    timestamp - - expire date in milliseconds (Unix timestamp)
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAt
```
public boolean expireAt(Date timestamp)
```
    Description copied from interface: RExpirable
    
    Set an expire date for object. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAt in interface RExpirable
    
    Parameters:
    
    timestamp - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - expireAtAsync
```
public RFuture<Boolean> expireAtAsync(Date timestamp)
```
    Description copied from interface: RExpirableAsync
    
    Set an expire date for object in async mode. When expire date comes the key will automatically be deleted.
    
    Specified by:
    
    expireAtAsync in interface RExpirableAsync
    
    Parameters:
    
    timestamp - - expire date
    
    Returns:
    
    true if the timeout was set and false if not
  - clearExpire
```
public boolean clearExpire()
```
    Description copied from interface: RExpirable
    
    Clear an expire timeout or expire date for object.
    
    Specified by:
    
    clearExpire in interface RExpirable
    
    Returns:
    
    true if timeout was removed false if object does not exist or does not have an associated timeout
  - remainTimeToLive
```
public long remainTimeToLive()
```
    Description copied from interface: RExpirable
    
    Remaining time to live of Redisson object that has a timeout
    
    Specified by:
    
    remainTimeToLive in interface RExpirable
    
    Returns:
    
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.
  - remainTimeToLiveAsync
```
public RFuture<Long> remainTimeToLiveAsync()
```
    Description copied from interface: RExpirableAsync
    
    Remaining time to live of Redisson object that has a timeout
    
    Specified by:
    
    remainTimeToLiveAsync in interface RExpirableAsync
    
    Returns:
    
    time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expire.

Class RedissonMapCache<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Fields inherited from class org.redisson.RedissonObject

Constructor Summary

Method Summary

Methods inherited from class org.redisson.RedissonMap

Methods inherited from class org.redisson.RedissonObject

Methods inherited from class java.lang.Object

Methods inherited from interface org.redisson.api.RMapCache

Methods inherited from interface org.redisson.api.RMap

Methods inherited from interface java.util.concurrent.ConcurrentMap

Methods inherited from interface java.util.Map

Methods inherited from interface org.redisson.api.RExpirable

Methods inherited from interface org.redisson.api.RObject

Methods inherited from interface org.redisson.api.RMapCacheAsync

Methods inherited from interface org.redisson.api.RMapAsync

Methods inherited from interface org.redisson.api.RExpirableAsync

Methods inherited from interface org.redisson.api.RObjectAsync

Constructor Detail

RedissonMapCache

RedissonMapCache

Method Detail

trySetMaxSize

trySetMaxSizeAsync

setMaxSize

setMaxSizeAsync

containsKeyAsync

containsValueAsync

getAllOperationAsync

putIfAbsent

putIfAbsentAsync

putIfAbsent

putIfAbsentAsync

removeOperationAsync

getOperationAsync

put

putOperationAsync

putIfAbsentOperationAsync

putAll

putAllAsync

addAndGet

addAndGetOperationAsync

fastPut

fastPutAsync

fastPut

fastPutAsync

fastPutOperationAsync

putAsync

put

putAsync

putOperationAsync

remainTimeToLive

remainTimeToLiveAsync

removeOperationAsync

fastRemoveOperationBatchAsync

fastRemoveOperationAsync

scanIterator

scanIteratorAsync

fastPutOperationAsync

fastPutIfAbsentOperationAsync

fastPutIfAbsent

fastPutIfAbsent

fastPutIfAbsentAsync

replaceOperationAsync

fastReplaceOperationAsync

replaceOperationAsync

putAllOperationAsync

addListener

removeListener

sizeInMemoryAsync

deleteAsync

expireAsync

expireAtAsync

clearExpireAsync

readAllKeySetAsync

readAllEntrySetAsync

readAllMapAsync

readAllValuesAsync