Package org.redisson

Class RedissonMapCache<K,V>

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:

MapCacheNativeWrapper, 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

Modifier and Type	Field	Description
protected String	publishCommand

Fields inherited from class org.redisson.RedissonObject

codec, commandExecutor, name

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method	Description
V	addAndGet(K key, Number value)	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
RFuture<Integer>	addListenerAsync(MapEntryListener listener)	Adds map entry listener
void	clear()
RFuture<Boolean>	clearAsync()	Clears map without removing options data used during map creation.
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.
protected RFuture<Boolean>	clearExpireAsync(String... keys)
V	computeIfAbsent(K key, Duration ttl, Function<? super K,? extends V> mappingFunction)	If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map .
RFuture<V>	computeIfAbsentAsync(K key, Duration ttl, Function<? super K,? extends V> mappingFunction)	If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map .
protected RFuture<Boolean>	containsKeyOperationAsync(String name, Object key)
RFuture<Boolean>	containsValueAsync(Object value)	Returns true if this map contains any map entry with specified value, otherwise false
RFuture<Boolean>	copyAsync(List<Object> keys, int database, boolean replace)
RFuture<Boolean>	deleteAsync()	Delete object in async mode
void	destroy()	Destroys object when it's not necessary anymore.
boolean	expire(long timeToLive, TimeUnit timeUnit)	Use RExpirable.expire(Duration) instead
boolean	expire(Duration duration)	Sets a timeout for this object.
boolean	expire(Instant instant)	Sets an expiration date for this object.
RFuture<Boolean>	expireAsync(long timeToLive, TimeUnit timeUnit)	Use RExpirableAsync.expireAsync(Duration) instead
RFuture<Boolean>	expireAsync(long timeToLive, TimeUnit timeUnit, String param, String... keys)
RFuture<Boolean>	expireAsync(Duration duration)	Set a timeout for object.
RFuture<Boolean>	expireAsync(Instant instant)	Set an expire date for object.
boolean	expireAt(long timestamp)	Use RExpirable.expire(Instant) instead
boolean	expireAt(Date timestamp)	Use RExpirable.expire(Instant) instead
RFuture<Boolean>	expireAtAsync(long timestamp)	Use RExpirableAsync.expireAsync(Instant) instead
protected RFuture<Boolean>	expireAtAsync(long timestamp, String param, String... keys)
RFuture<Boolean>	expireAtAsync(Date timestamp)	Use RExpirableAsync.expireAsync(Instant) instead
int	expireEntries(Set<K> keys, Duration ttl, Duration maxIdleTime)	Updates time to live and max idle time of specified entries by keys.
RFuture<Integer>	expireEntriesAsync(Set<K> keys, Duration ttl, Duration maxIdleTime)	Updates time to live and max idle time of specified entries by keys.
int	expireEntriesIfNotSet(Set<K> keys, Duration ttl, Duration maxIdleTime)	Sets time to live and max idle time of specified entries by keys.
RFuture<Integer>	expireEntriesIfNotSetAsync(Set<K> keys, Duration ttl, Duration maxIdleTime)
boolean	expireEntry(K key, Duration ttl, Duration maxIdleTime)	Updates time to live and max idle time of specified entry by key.
RFuture<Boolean>	expireEntryAsync(K key, Duration ttl, Duration maxIdleTime)	Updates time to live and max idle time of specified entry by key.
boolean	expireEntryIfNotSet(K key, Duration ttl, Duration maxIdleTime)	Sets time to live and max idle time of specified entry by key.
RFuture<Boolean>	expireEntryIfNotSetAsync(K key, Duration ttl, Duration maxIdleTime)
boolean	expireIfGreater(Duration duration)	Sets a timeout for this object only if it's greater than timeout set before.
boolean	expireIfGreater(Instant time)	Sets an expiration date for this object only if it's greater than expiration date set before.
RFuture<Boolean>	expireIfGreaterAsync(Duration duration)	Sets a timeout for this object only if it's greater than timeout set before.
RFuture<Boolean>	expireIfGreaterAsync(Instant time)	Sets an expiration date for this object only if it's greater than expiration date set before.
boolean	expireIfLess(Duration duration)	Sets a timeout for this object only if it's less than timeout set before.
boolean	expireIfLess(Instant time)	Sets an expiration date for this object only if it's less than expiration date set before.
RFuture<Boolean>	expireIfLessAsync(Duration duration)	Sets a timeout for this object only if it's less than timeout set before.
RFuture<Boolean>	expireIfLessAsync(Instant time)	Sets an expiration date for this object only if it's less than expiration date set before.
boolean	expireIfNotSet(Duration duration)	Sets a timeout for this object only if it hasn't been set before.
boolean	expireIfNotSet(Instant time)	Sets an expiration date for this object only if it hasn't been set before.
RFuture<Boolean>	expireIfNotSetAsync(Duration duration)	Sets a timeout for this object only if it hasn't been set before.
RFuture<Boolean>	expireIfNotSetAsync(Instant time)	Sets an expiration date for this object only if it hasn't been set before.
boolean	expireIfSet(Duration duration)	Sets a timeout for this object only if it has been already set.
boolean	expireIfSet(Instant time)	Sets an expiration date for this object only if it has been already set.
RFuture<Boolean>	expireIfSetAsync(Duration duration)	Sets a timeout for this object only if it has been already set.
RFuture<Boolean>	expireIfSetAsync(Instant time)	Sets an expiration date for this object only if it has been already set.
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>	fastPutIfExistsOperationAsync(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)
Map<K,V>	getAllWithTTLOnly(Set<K> keys)	Returns map slice contained the mappings with defined keys.
RFuture<Map<K,V>>	getAllWithTTLOnlyAsync(Set<K> keys)	Returns map slice contained the mappings with defined keys.
protected RFuture<Map<K,V>>	getAllWithTTLOnlyOperationAsync(Set<K> keys)
long	getExpireTime()	Returns expiration time of the object as the absolute Unix expiration timestamp in milliseconds.
RFuture<Long>	getExpireTimeAsync()	Returns expiration time of the object as the absolute Unix expiration timestamp in milliseconds.
RFuture<V>	getOperationAsync(K key)
protected RTopic	getTopic(String name)
V	getWithTTLOnly(K key)	Returns the value mapped by defined key or null if value is absent.
RFuture<V>	getWithTTLOnlyAsync(K key)	Returns the value mapped by defined key or null if value is absent.
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>	putIfExistsOperationAsync(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, long ttlTimeoutDelta)
RFuture<Map<K,V>>	randomEntriesAsync(int count)	Returns random map entries from this map limited by count
RFuture<Set<K>>	randomKeysAsync(int count)	Returns random keys from this map limited by count
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()	Returns remaining time of the object in milliseconds.
long	remainTimeToLive(K key)	Remaining time to live of map entry associated with a key.
RFuture<Long>	remainTimeToLiveAsync()	Returns remaining time of the object in milliseconds.
RFuture<Long>	remainTimeToLiveAsync(K key)	Remaining time to live of map entry associated with a key.
void	removeListener(int listenerId)	Removes object event listener
RFuture<Void>	removeListenerAsync(int listenerId)	Removes object event listener
protected RFuture<Boolean>	removeOperationAsync(Object key, Object value)
protected RFuture<V>	removeOperationAsync(K key)
RFuture<Void>	renameAsync(String nn)	Rename current object key to newName in async mode
RFuture<Boolean>	renamenxAsync(String nn)	Rename current object key to newName in async mode only if new key is not exists
protected RFuture<V>	replaceOperationAsync(K key, V value)
protected RFuture<Boolean>	replaceOperationAsync(K key, V oldValue, V newValue)
RFuture<ScanResult<Map.Entry<Object,Object>>>	scanIteratorAsync(String name, RedisClient client, String startPos, String pattern, int count)
RFuture<ScanResult<Object>>	scanKeyIteratorAsync(String name, RedisClient client, String startPos, String pattern, int count)
void	setMaxSize(int maxSize)	Sets max size of the map and overrides current value.
void	setMaxSize(int maxSize, EvictionMode mode)	Sets max size of the map and overrides current value.
RFuture<Void>	setMaxSizeAsync(int maxSize)	Sets max size of the map and overrides current value.
RFuture<Void>	setMaxSizeAsync(int maxSize, EvictionMode mode)	Sets max size of the map and overrides current value.
RFuture<Long>	sizeInMemoryAsync()	Returns bytes amount used by object in Redis memory.
boolean	trySetMaxSize(int maxSize)	Tries to set max size of the map.
boolean	trySetMaxSize(int maxSize, EvictionMode mode)	Tries to set max size of the map.
RFuture<Boolean>	trySetMaxSizeAsync(int maxSize)	Tries to set max size of the map.
RFuture<Boolean>	trySetMaxSizeAsync(int maxSize, EvictionMode mode)	Tries to set max size of the map.
boolean	updateEntryExpiration(K key, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)	Use RMapCache.expireEntry(Object, Duration, Duration) instead.
RFuture<Boolean>	updateEntryExpirationAsync(K key, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit)	Use RMapCacheAsync.expireEntryAsync(Object, Duration, Duration) instead.

Methods inherited from class org.redisson.RedissonMap

addAndGetAsync, addListener, addListenerAsync, checkKey, checkValue, compute, computeAsync, computeIfAbsent, computeIfAbsentAsync, computeIfPresent, computeIfPresentAsync, containsKey, containsKeyAsync, containsKeyAsync, containsValue, encodeMapKeys, entryIterator, entrySet, entrySet, entrySet, entrySet, equals, fastPut, fastPutAsync, fastPutIfAbsent, fastPutIfAbsentAsync, fastPutIfExists, fastPutIfExistsAsync, fastRemove, fastRemoveAsync, fastReplace, fastReplaceAsync, get, getAll, getAllAsync, getAllAsync, getAsync, getAsync, getCountDownLatch, getFairLock, getLock, getPermitExpirableSemaphore, getReadWriteLock, getSemaphore, hashCode, hasNoLoader, hasNoWriter, isEmpty, keyIterator, keySet, keySet, keySet, keySet, loadAll, loadAll, loadAllAsync, loadAllAsync, loadAllMapAsync, loadValue, loadValue, mapReduce, mapWriterFuture, mapWriterFuture, merge, mergeAsync, put, putAll, putAll, putAllAsync, putAllAsync, putAsync, putIfAbsent, putIfAbsentAsync, putIfExists, putIfExistsAsync, randomEntries, randomKeys, readAllEntrySet, readAllKeySet, readAllMap, readAllValues, remove, remove, removeAsync, removeAsync, replace, replace, replaceAsync, replaceAsync, scanIterator, scanKeyIterator, size, sizeAsync, valueIterator, values, values, values, values, valueSize, valueSizeAsync

Methods inherited from class org.redisson.RedissonObject

addListener, addListener, addListenerAsync, addListenerAsync, addListenerId, addTrackingListener, addTrackingListenerAsync, checkNotBatch, copy, copy, copy, copyAndReplace, copyAndReplace, copyAndReplaceAsync, copyAndReplaceAsync, copyAsync, copyAsync, copyAsync, copyAsync, delete, deleteAsync, dump, dumpAsync, encode, encode, encode, encode, encodeMapKey, encodeMapKey, encodeMapKeys, encodeMapValue, encodeMapValues, get, getCodec, getIdleTime, getIdleTimeAsync, getListenerIdsByName, getLockByMapKey, getLockByValue, getName, getNameByListenerId, getRawName, getRawName, getServiceManager, getSubscribeService, isExists, isExistsAsync, map, mapName, migrate, migrateAsync, move, moveAsync, prefixName, removeListener, removeListenerAsync, removeListenerAsync, removeListenerId, removeListeners, removeTrackingListener, removeTrackingListenerAsync, rename, renameAsync, renameAsync, renamenx, renamenxAsync, renamenxAsync, restore, restore, restoreAndReplace, restoreAndReplace, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, setName, sizeInMemory, sizeInMemoryAsync, 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 java.util.concurrent.ConcurrentMap

compute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAll

Methods inherited from interface java.util.Map

equals, hashCode, isEmpty

Methods inherited from interface org.redisson.api.RExpirable

clearExpire, expire, expire, expire, expireAt, expireAt, expireIfGreater, expireIfGreater, expireIfLess, expireIfLess, expireIfNotSet, expireIfNotSet, expireIfSet, expireIfSet, getExpireTime, remainTimeToLive

Methods inherited from interface org.redisson.api.RExpirableAsync

expireAsync, expireAsync, expireAsync, expireAtAsync, expireAtAsync, expireIfGreaterAsync, expireIfGreaterAsync, expireIfLessAsync, expireIfLessAsync, expireIfNotSetAsync, expireIfNotSetAsync, expireIfSetAsync, expireIfSetAsync, getExpireTimeAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.api.RMap

addListener, containsKey, containsValue, entrySet, entrySet, entrySet, entrySet, fastPut, fastPutIfAbsent, fastPutIfExists, fastRemove, fastReplace, get, getAll, getCountDownLatch, getFairLock, getLock, getPermitExpirableSemaphore, getReadWriteLock, getSemaphore, keySet, keySet, keySet, keySet, loadAll, loadAll, mapReduce, put, putAll, putAll, putIfAbsent, putIfExists, randomEntries, randomKeys, readAllEntrySet, readAllKeySet, readAllMap, readAllValues, remove, remove, replace, replace, values, values, values, values, valueSize

Methods inherited from interface org.redisson.api.RMapAsync

addAndGetAsync, addListenerAsync, computeAsync, computeIfAbsentAsync, computeIfPresentAsync, containsKeyAsync, fastPutAsync, fastPutIfAbsentAsync, fastPutIfExistsAsync, fastRemoveAsync, fastReplaceAsync, getAllAsync, getAsync, loadAllAsync, loadAllAsync, mergeAsync, putAllAsync, putAllAsync, putAsync, putIfAbsentAsync, putIfExistsAsync, removeAsync, removeAsync, replaceAsync, replaceAsync, valueSizeAsync

Methods inherited from interface org.redisson.api.RMapCache

size

Methods inherited from interface org.redisson.api.RMapCacheAsync

sizeAsync

Methods inherited from interface org.redisson.api.RObject

copy, copy, copy, copyAndReplace, copyAndReplace, delete, dump, getCodec, getIdleTime, getName, isExists, migrate, move, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, sizeInMemory, touch, unlink

Methods inherited from interface org.redisson.api.RObjectAsync

copyAndReplaceAsync, copyAndReplaceAsync, copyAsync, copyAsync, copyAsync, dumpAsync, getIdleTimeAsync, isExistsAsync, migrateAsync, moveAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, touchAsync, unlinkAsync

Field Details

publishCommand

protected String publishCommand

Constructor Details

RedissonMapCache

public RedissonMapCache(EvictionScheduler evictionScheduler,
 CommandAsyncExecutor commandExecutor,
 String name,
 RedissonClient redisson,
 MapCacheOptions<K,V> options,
 WriteBehindService writeBehindService)

RedissonMapCache

public RedissonMapCache(Codec codec,
 EvictionScheduler evictionScheduler,
 CommandAsyncExecutor commandExecutor,
 String name,
 RedissonClient redisson,
 MapCacheOptions<K,V> options,
 WriteBehindService writeBehindService)

Method Details

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

trySetMaxSize

public boolean trySetMaxSize(int maxSize,
 EvictionMode mode)

Description copied from interface: RMapCache

Tries to set max size of the map. Superfluous elements are evicted using defined algorithm.

Specified by:

trySetMaxSize in interface RMapCache<K,V>

Parameters:

maxSize - - max size

mode - - eviction mode

Returns:

true if max size has been successfully set, otherwise false.

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

Specified by:

trySetMaxSizeAsync in interface RMapCacheAsync<K,V>

Parameters:

maxSize - - max size

Returns:

true if max size has been successfully set, otherwise false.

trySetMaxSizeAsync

public RFuture<Boolean> trySetMaxSizeAsync(int maxSize,
 EvictionMode mode)

Description copied from interface: RMapCacheAsync

Tries to set max size of the map. Superfluous elements are evicted using defined algorithm.

Specified by:

trySetMaxSizeAsync in interface RMapCacheAsync<K,V>

Parameters:

maxSize - - max size

mode - - eviction mode

Returns:

true if max size has been successfully set, otherwise false.

computeIfAbsent

public V computeIfAbsent(K key,
 Duration ttl,
 Function<? super K,? extends V> mappingFunction)

Description copied from interface: RMapCache

If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map .

Stores value mapped by key with specified time to live. Entry expires after specified time to live.

Specified by:

computeIfAbsent in interface RMapCache<K,V>

Parameters:

key - - map key

ttl - - time to live for key\value entry. If 0 then stores infinitely.

mappingFunction - the mapping function to compute a value

Returns:

current associated value

computeIfAbsentAsync

public RFuture<V> computeIfAbsentAsync(K key,
 Duration ttl,
 Function<? super K,? extends V> mappingFunction)

Description copied from interface: RMapCacheAsync

If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map .

Stores value mapped by key with specified time to live. Entry expires after specified time to live.

Specified by:

computeIfAbsentAsync in interface RMapCacheAsync<K,V>

Parameters:

key - - map key

ttl - - time to live for key\value entry. If 0 then stores infinitely.

mappingFunction - the mapping function to compute a value

Returns:

current associated value

setMaxSize

public void setMaxSize(int maxSize)

Description copied from interface: RMapCache

Sets max size of the map and overrides current value. 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).

setMaxSize

public void setMaxSize(int maxSize,
 EvictionMode mode)

Description copied from interface: RMapCache

Sets max size of the map and overrides current value. Superfluous elements are evicted using defined algorithm.

Specified by:

setMaxSize in interface RMapCache<K,V>

Parameters:

maxSize - - max size

mode - - eviction mode

setMaxSizeAsync

public RFuture<Void> setMaxSizeAsync(int maxSize)

Description copied from interface: RMapCacheAsync

Sets max size of the map and overrides current value. Superfluous elements are evicted using LRU algorithm by default.

Specified by:

setMaxSizeAsync in interface RMapCacheAsync<K,V>

Parameters:

maxSize - - max size

Returns:

void

setMaxSizeAsync

public RFuture<Void> setMaxSizeAsync(int maxSize,
 EvictionMode mode)

Description copied from interface: RMapCacheAsync

Sets max size of the map and overrides current value. Superfluous elements are evicted using defined algorithm.

Specified by:

setMaxSizeAsync in interface RMapCacheAsync<K,V>

Parameters:

maxSize - - max size

mode - - eviction mode

Returns:

void

containsKeyOperationAsync

protected RFuture<Boolean> containsKeyOperationAsync(String name,
 Object key)

Overrides:

containsKeyOperationAsync in class RedissonMap<K,V>

containsValueAsync

public RFuture<Boolean> containsValueAsync(Object value)

Description copied from interface: RMapAsync

Returns true if this map contains any map entry with specified value, otherwise false

Specified by:

containsValueAsync in interface RMapAsync<K,V>

Overrides:

containsValueAsync in class RedissonMap<K,V>

Parameters:

value - - map value

Returns:

true if this map contains any map entry with specified value, otherwise false

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>

putIfExistsOperationAsync

protected RFuture<V> putIfExistsOperationAsync(K key,
 V value)

Overrides:

putIfExistsOperationAsync 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: RMapCacheAsync

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

Adds the given delta to the current value by mapped key.

Works only with codecs below

JsonJacksonCodec,

StringCodec,

IntegerCodec,

DoubleCodec

LongCodec

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)

updateEntryExpiration

public boolean updateEntryExpiration(K key,
 long ttl,
 TimeUnit ttlUnit,
 long maxIdleTime,
 TimeUnit maxIdleUnit)

Description copied from interface: RMapCache

Use RMapCache.expireEntry(Object, Duration, Duration) instead.

Specified by:

updateEntryExpiration in interface RMapCache<K,V>

Parameters:

key - - map key

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:

returns false if entry already expired or doesn't exist, otherwise returns true.

updateEntryExpirationAsync

public RFuture<Boolean> updateEntryExpirationAsync(K key,
 long ttl,
 TimeUnit ttlUnit,
 long maxIdleTime,
 TimeUnit maxIdleUnit)

Description copied from interface: RMapCacheAsync

Use RMapCacheAsync.expireEntryAsync(Object, Duration, Duration) instead.

Specified by:

updateEntryExpirationAsync in interface RMapCacheAsync<K,V>

Parameters:

key - - map key

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:

returns false if entry already expired or doesn't exist, otherwise returns true.

expireEntry

public boolean expireEntry(K key,
 Duration ttl,
 Duration maxIdleTime)

Description copied from interface: RMapCache

Updates time to live and max idle time of specified entry by key. Entry expires when specified time to live or max idle time was reached.

Returns false if entry already expired or doesn't exist, otherwise returns true.

Specified by:

expireEntry in interface RMapCache<K,V>

Parameters:

key - map key

ttl - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.

maxIdleTime - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.

if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.

Returns:

returns false if entry already expired or doesn't exist, otherwise returns true.

expireEntryAsync

public RFuture<Boolean> expireEntryAsync(K key,
 Duration ttl,
 Duration maxIdleTime)

Description copied from interface: RMapCacheAsync

Updates time to live and max idle time of specified entry by key. Entry expires when specified time to live or max idle time was reached.

Returns false if entry already expired or doesn't exist, otherwise returns true.

Specified by:

expireEntryAsync in interface RMapCacheAsync<K,V>

Parameters:

key - - map key

ttl - - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.

maxIdleTime - - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.

if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.

Returns:

returns false if entry already expired or doesn't exist, otherwise returns true.

expireEntryIfNotSet

public boolean expireEntryIfNotSet(K key,
 Duration ttl,
 Duration maxIdleTime)

Description copied from interface: RMapCache

Sets time to live and max idle time of specified entry by key. If these parameters weren't set before. Entry expires when specified time to live or max idle time was reached.

Returns false if entry already has expiration time or doesn't exist, otherwise returns true.

Specified by:

expireEntryIfNotSet in interface RMapCache<K,V>

Parameters:

key - map key

ttl - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.

maxIdleTime - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.

if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.

Returns:

returns false if entry already has expiration time or doesn't exist, otherwise returns true.

expireEntryIfNotSetAsync

public RFuture<Boolean> expireEntryIfNotSetAsync(K key,
 Duration ttl,
 Duration maxIdleTime)

expireEntriesIfNotSet

public int expireEntriesIfNotSet(Set<K> keys,
 Duration ttl,
 Duration maxIdleTime)

Description copied from interface: RMapCache

Sets time to live and max idle time of specified entries by keys. If these parameters weren't set before. Entries expire when specified time to live or max idle time was reached.

Returns amount of updated entries.

Specified by:

expireEntriesIfNotSet in interface RMapCache<K,V>

Parameters:

keys - map keys

ttl - time to live for key\value entry. If 0 then time to live doesn't affect entry expiration.

maxIdleTime - max idle time for key\value entry. If 0 then max idle time doesn't affect entry expiration.

if maxIdleTime and ttl params are equal to 0 then entry stores infinitely.

Returns:

amount of updated entries.

expireEntriesIfNotSetAsync

public RFuture<Integer> expireEntriesIfNotSetAsync(Set<K> keys,
 Duration ttl,
 Duration maxIdleTime)

expireEntries

public int expireEntries(Set<K> keys,
 Duration ttl,
 Duration maxIdleTime)

Description copied from interface: RMapCache

Updates time to live and max idle time of specified entries by keys. Entries expires when specified time to live or max idle time was reached.

Returns amount of updated entries.

Specified by:

expireEntries in interface RMapCache<K,V>

Parameters:

keys - map keys

ttl - time to live for key\value entries. If 0 then time to live doesn't affect entry expiration.

maxIdleTime - max idle time for key\value entries. If 0 then max idle time doesn't affect entry expiration.

if maxIdleTime and ttl params are equal to 0 then entries are stored infinitely.

Returns:

amount of updated entries.

expireEntriesAsync

public RFuture<Integer> expireEntriesAsync(Set<K> keys,
 Duration ttl,
 Duration maxIdleTime)

Description copied from interface: RMapCacheAsync

Updates time to live and max idle time of specified entries by keys. Entries expires when specified time to live or max idle time was reached.

Returns amount of updated entries.

Specified by:

expireEntriesAsync in interface RMapCacheAsync<K,V>

Parameters:

keys - map keys

ttl - time to live for key\value entries. If 0 then time to live doesn't affect entry expiration.

maxIdleTime - max idle time for key\value entries. If 0 then max idle time doesn't affect entry expiration.

if maxIdleTime and ttl params are equal to 0 then entries are stored infinitely.

Returns:

amount of updated entries.

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,
 long ttlTimeoutDelta)

getWithTTLOnly

public V getWithTTLOnly(K key)

Description copied from interface: RMapCache

Returns the value mapped by defined key or null if value is absent.

If map doesn't contain value for specified key and MapLoader is defined then value will be loaded in read-through mode.

NOTE: Idle time of entry is not taken into account. Entry last access time isn't modified if map limited by size.

Specified by:

getWithTTLOnly in interface RMapCache<K,V>

Parameters:

key - the key

Returns:

the value mapped by defined key or null if value is absent

getWithTTLOnlyAsync

public RFuture<V> getWithTTLOnlyAsync(K key)

Description copied from interface: RMapCacheAsync

Returns the value mapped by defined key or null if value is absent.

If map doesn't contain value for specified key and MapLoader is defined then value will be loaded in read-through mode.

NOTE: Idle time of entry is not taken into account. Entry last access time isn't modified if map limited by size.

Specified by:

getWithTTLOnlyAsync in interface RMapCacheAsync<K,V>

Parameters:

key - the key

Returns:

the value mapped by defined key or null if value is absent

getAllWithTTLOnly

public Map<K,V> getAllWithTTLOnly(Set<K> keys)

Description copied from interface: RMapCache

Returns map slice contained the mappings with defined keys.

If map doesn't contain value/values for specified key/keys and MapLoader is defined then value/values will be loaded in read-through mode.

NOTE: Idle time of entry is not taken into account. Entry last access time isn't modified if map limited by size.

Specified by:

getAllWithTTLOnly in interface RMapCache<K,V>

Parameters:

keys - map keys

Returns:

Map slice

getAllWithTTLOnlyAsync

public RFuture<Map<K,V>> getAllWithTTLOnlyAsync(Set<K> keys)

Description copied from interface: RMapCacheAsync

Returns map slice contained the mappings with defined keys.

If map doesn't contain value/values for specified key/keys and MapLoader is defined then value/values will be loaded in read-through mode.

NOTE: Idle time of entry is not taken into account. Entry last access time isn't modified if map limited by size.

Specified by:

getAllWithTTLOnlyAsync in interface RMapCacheAsync<K,V>

Parameters:

keys - map keys

Returns:

Map slice

getAllWithTTLOnlyOperationAsync

protected RFuture<Map<K,V>> getAllWithTTLOnlyOperationAsync(Set<K> keys)

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>

scanKeyIteratorAsync

public RFuture<ScanResult<Object>> scanKeyIteratorAsync(String name,
 RedisClient client,
 String startPos,
 String pattern,
 int count)

Overrides:

scanKeyIteratorAsync in class RedissonMap<K,V>

scanIteratorAsync

public RFuture<ScanResult<Map.Entry<Object,Object>>> scanIteratorAsync(String name,
 RedisClient client,
 String 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>

fastPutIfExistsOperationAsync

protected RFuture<Boolean> fastPutIfExistsOperationAsync(K key,
 V value)

Overrides:

fastPutIfExistsOperationAsync 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

getTopic

protected RTopic getTopic(String name)

addListenerAsync

public RFuture<Integer> addListenerAsync(MapEntryListener listener)

Description copied from interface: RMapCacheAsync

Adds map entry listener

Specified by:

addListenerAsync in interface RMapCacheAsync<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 RedissonMap<K,V>

Parameters:

listenerId - - listener id

removeListenerAsync

public RFuture<Void> removeListenerAsync(int listenerId)

Description copied from interface: RObjectAsync

Removes object event listener

Specified by:

removeListenerAsync in interface RObjectAsync

Overrides:

removeListenerAsync in class RedissonMap<K,V>

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

copyAsync

public RFuture<Boolean> copyAsync(List<Object> keys,
 int database,
 boolean replace)

Overrides:

copyAsync in class RedissonObject

renameAsync

public RFuture<Void> renameAsync(String nn)

Description copied from interface: RObjectAsync

Rename current object key to newName in async mode

Specified by:

renameAsync in interface RObjectAsync

Overrides:

renameAsync in class RedissonObject

Parameters:

nn - - new name of object

Returns:

void

renamenxAsync

public RFuture<Boolean> renamenxAsync(String nn)

Description copied from interface: RObjectAsync

Rename current object key to newName in async mode only if new key is not exists

Specified by:

renamenxAsync in interface RObjectAsync

Overrides:

renamenxAsync in class RedissonObject

Parameters:

nn - - new name of object

Returns:

true if object has been renamed successfully and false otherwise

clear

public void clear()

Specified by:

clear in interface Map<K,V>

Overrides:

clear in class RedissonMap<K,V>

clearAsync

public RFuture<Boolean> clearAsync()

Description copied from interface: RMapAsync

Clears map without removing options data used during map creation.

Specified by:

clearAsync in interface RMapAsync<K,V>

Overrides:

clearAsync in class RedissonMap<K,V>

Returns:

true if map was cleared false if not

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,
 String param,
 String... keys)

expireAtAsync

protected RFuture<Boolean> expireAtAsync(long timestamp,
 String param,
 String... keys)

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

randomKeysAsync

public RFuture<Set<K>> randomKeysAsync(int count)

Description copied from interface: RMapAsync

Returns random keys from this map limited by count

Specified by:

randomKeysAsync in interface RMapAsync<K,V>

Overrides:

randomKeysAsync in class RedissonMap<K,V>

Parameters:

count - - keys amount to return

Returns:

random keys

randomEntriesAsync

public RFuture<Map<K,V>> randomEntriesAsync(int count)

Description copied from interface: RMapAsync

Returns random map entries from this map limited by count

Specified by:

randomEntriesAsync in interface RMapAsync<K,V>

Overrides:

randomEntriesAsync in class RedissonMap<K,V>

Parameters:

count - - entries amount to return

Returns:

random entries

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

Overrides:

destroy in class RedissonMap<K,V>

expire

public boolean expire(long timeToLive,
 TimeUnit timeUnit)

Description copied from interface: RExpirable

Use RExpirable.expire(Duration) instead

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

expireAsync

public RFuture<Boolean> expireAsync(long timeToLive,
 TimeUnit timeUnit)

Description copied from interface: RExpirableAsync

Use RExpirableAsync.expireAsync(Duration) instead

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

expireAt

public boolean expireAt(long timestamp)

Description copied from interface: RExpirable

Use RExpirable.expire(Instant) instead

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

expireAtAsync

public RFuture<Boolean> expireAtAsync(long timestamp)

Description copied from interface: RExpirableAsync

Use RExpirableAsync.expireAsync(Instant) instead

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

expire

public boolean expire(Instant instant)

Description copied from interface: RExpirable

Sets an expiration date for this object. When expire date comes the key will automatically be deleted.

Specified by:

expire in interface RExpirable

Parameters:

instant - expire date

Returns:

true if the timeout was set and false if not

expireIfSet

public boolean expireIfSet(Instant time)

Description copied from interface: RExpirable

Sets an expiration date for this object only if it has been already set. When expire date comes the object will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfSet in interface RExpirable

Parameters:

time - expire date

Returns:

true if the timeout was set and false if not

expireIfSetAsync

public RFuture<Boolean> expireIfSetAsync(Instant time)

Description copied from interface: RExpirableAsync

Sets an expiration date for this object only if it has been already set. When expire date comes the object will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfSetAsync in interface RExpirableAsync

Parameters:

time - expire date

Returns:

true if the timeout was set and false if not

expireIfNotSet

public boolean expireIfNotSet(Instant time)

Description copied from interface: RExpirable

Sets an expiration date for this object only if it hasn't been set before. When expire date comes the object will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfNotSet in interface RExpirable

Parameters:

time - expire date

Returns:

true if the timeout was set and false if not

expireIfNotSetAsync

public RFuture<Boolean> expireIfNotSetAsync(Instant time)

Description copied from interface: RExpirableAsync

Sets an expiration date for this object only if it hasn't been set before. When expire date comes the object will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfNotSetAsync in interface RExpirableAsync

Parameters:

time - expire date

Returns:

true if the timeout was set and false if not

expireIfGreater

public boolean expireIfGreater(Instant time)

Description copied from interface: RExpirable

Sets an expiration date for this object only if it's greater than expiration date set before. When expire date comes the object will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfGreater in interface RExpirable

Parameters:

time - expire date

Returns:

true if the timeout was set and false if not

expireIfGreaterAsync

public RFuture<Boolean> expireIfGreaterAsync(Instant time)

Description copied from interface: RExpirableAsync

Sets an expiration date for this object only if it's greater than expiration date set before. When expire date comes the object will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfGreaterAsync in interface RExpirableAsync

Parameters:

time - expire date

Returns:

true if the timeout was set and false if not

expireIfLess

public boolean expireIfLess(Instant time)

Description copied from interface: RExpirable

Sets an expiration date for this object only if it's less than expiration date set before. When expire date comes the object will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfLess in interface RExpirable

Parameters:

time - expire date

Returns:

true if the timeout was set and false if not

expireIfLessAsync

public RFuture<Boolean> expireIfLessAsync(Instant time)

Description copied from interface: RExpirableAsync

Sets an expiration date for this object only if it's less than expiration date set before. When expire date comes the object will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfLessAsync in interface RExpirableAsync

Parameters:

time - expire date

Returns:

true if the timeout was set and false if not

expireAsync

public RFuture<Boolean> expireAsync(Instant instant)

Description copied from interface: RExpirableAsync

Set an expire date for object. When expire date comes the key will automatically be deleted.

Specified by:

expireAsync in interface RExpirableAsync

Parameters:

instant - - expire date

Returns:

true if the timeout was set and false if not

expire

public boolean expire(Duration duration)

Description copied from interface: RExpirable

Sets a timeout for this object. After the timeout has expired, the key will automatically be deleted.

Specified by:

expire in interface RExpirable

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireAsync

public RFuture<Boolean> expireAsync(Duration duration)

Description copied from interface: RExpirableAsync

Set a timeout for object. After the timeout has expired, the key will automatically be deleted.

Specified by:

expireAsync in interface RExpirableAsync

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireAt

public boolean expireAt(Date timestamp)

Description copied from interface: RExpirable

Use RExpirable.expire(Instant) instead

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

Use RExpirableAsync.expireAsync(Instant) instead

Specified by:

expireAtAsync in interface RExpirableAsync

Parameters:

timestamp - - expire date

Returns:

true if the timeout was set and false if not

expireIfSet

public boolean expireIfSet(Duration duration)

Description copied from interface: RExpirable

Sets a timeout for this object only if it has been already set. After the timeout has expired, the key will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfSet in interface RExpirable

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireIfSetAsync

public RFuture<Boolean> expireIfSetAsync(Duration duration)

Description copied from interface: RExpirableAsync

Sets a timeout for this object only if it has been already set. After the timeout has expired, the key will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfSetAsync in interface RExpirableAsync

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireIfNotSet

public boolean expireIfNotSet(Duration duration)

Description copied from interface: RExpirable

Sets a timeout for this object only if it hasn't been set before. After the timeout has expired, the key will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfNotSet in interface RExpirable

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireIfNotSetAsync

public RFuture<Boolean> expireIfNotSetAsync(Duration duration)

Description copied from interface: RExpirableAsync

Sets a timeout for this object only if it hasn't been set before. After the timeout has expired, the key will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfNotSetAsync in interface RExpirableAsync

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireIfGreater

public boolean expireIfGreater(Duration duration)

Description copied from interface: RExpirable

Sets a timeout for this object only if it's greater than timeout set before. After the timeout has expired, the key will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfGreater in interface RExpirable

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireIfGreaterAsync

public RFuture<Boolean> expireIfGreaterAsync(Duration duration)

Description copied from interface: RExpirableAsync

Sets a timeout for this object only if it's greater than timeout set before. After the timeout has expired, the key will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfGreaterAsync in interface RExpirableAsync

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireIfLess

public boolean expireIfLess(Duration duration)

Description copied from interface: RExpirable

Sets a timeout for this object only if it's less than timeout set before. After the timeout has expired, the key will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfLess in interface RExpirable

Parameters:

duration - timeout before object will be deleted

Returns:

true if the timeout was set and false if not

expireIfLessAsync

public RFuture<Boolean> expireIfLessAsync(Duration duration)

Description copied from interface: RExpirableAsync

Sets a timeout for this object only if it's less than timeout set before. After the timeout has expired, the key will automatically be deleted.

Requires Redis 7.0.0 and higher.

Specified by:

expireIfLessAsync in interface RExpirableAsync

Parameters:

duration - timeout before object will be deleted

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

Returns remaining time of the object in milliseconds.

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

Returns remaining time of the object in milliseconds.

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.

getExpireTime

public long getExpireTime()

Description copied from interface: RExpirable

Returns expiration time of the object as the absolute Unix expiration timestamp in milliseconds.

Requires Redis 7.0.0 and higher.

Specified by:

getExpireTime in interface RExpirable

Returns:

Unix time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expiration time.

getExpireTimeAsync

public RFuture<Long> getExpireTimeAsync()

Description copied from interface: RExpirableAsync

Returns expiration time of the object as the absolute Unix expiration timestamp in milliseconds.

Requires Redis 7.0.0 and higher.

Specified by:

getExpireTimeAsync in interface RExpirableAsync

Returns:

Unix time in milliseconds -2 if the key does not exist. -1 if the key exists but has no associated expiration time.

clearExpireAsync

protected RFuture<Boolean> clearExpireAsync(String... keys)