org.redisson

Class RedissonMap<K,V>

java.lang.Object

org.redisson.RedissonObject

org.redisson.RedissonMap<K,V>

Type Parameters:

K - key

V - value

All Implemented Interfaces:

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

Direct Known Subclasses:

RedissonLocalCachedMap, RedissonMapCache, RedissonTransactionalMap

public class RedissonMap<K,V>
extends RedissonObject
implements RMap<K,V>

Distributed and concurrent implementation of ConcurrentMap and Map

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
RedissonMap(Codec codec, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K,V> options, WriteBehindService writeBehindService)
RedissonMap(CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K,V> options, WriteBehindService writeBehindService)

Method Summary

Modifier and Type	Method and Description
V	addAndGet(K key, Number value) Adds the given delta to the current value by mapped key.
RFuture<V>	addAndGetAsync(K key, Number value) Adds the given delta to the current value by mapped key.
protected RFuture<V>	addAndGetOperationAsync(K key, Number value)
protected void	checkKey(Object key)
protected void	checkValue(Object value)
void	clear()
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	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
RFuture<V>	computeAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Computes a new mapping for the specified key and its current mapped value.
V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction)
RFuture<V>	computeIfAbsentAsync(K key, Function<? super K,? extends V> mappingFunction) Computes a mapping for the specified key if it's not mapped before.
V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)
RFuture<V>	computeIfPresentAsync(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Computes a mapping for the specified key only if it's already mapped.
boolean	containsKey(Object key) Returns true if this map contains map entry mapped by specified key, otherwise false
RFuture<Boolean>	containsKeyAsync(Object key) Returns true if this map contains map entry mapped by specified key, otherwise false
boolean	containsValue(Object value) Returns true if this map contains any map entry with specified value, otherwise false
RFuture<Boolean>	containsValueAsync(Object value) Returns true if this map contains any map entry with specified value, otherwise false
protected Iterator<Map.Entry<K,V>>	entryIterator(String pattern, int count)
Set<Map.Entry<K,V>>	entrySet() Returns map entries collection.
Set<Map.Entry<K,V>>	entrySet(int count) Returns map entries collection.
Set<Map.Entry<K,V>>	entrySet(String keyPattern) Returns map entries collection.
Set<Map.Entry<K,V>>	entrySet(String keyPattern, int count) Returns map entries collection.
boolean	equals(Object o)
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.
protected RFuture<Boolean>	expireAsync(long timeToLive, TimeUnit timeUnit, String... keys)
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.
protected RFuture<Boolean>	expireAtAsync(long timestamp, String... keys)
boolean	fastPut(K key, V value) Stores the specified value mapped by specified key.
RFuture<Boolean>	fastPutAsync(K key, V value) Stores the specified value mapped by specified key.
boolean	fastPutIfAbsent(K key, V value) Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
RFuture<Boolean>	fastPutIfAbsentAsync(K key, V value) Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
protected RFuture<Boolean>	fastPutIfAbsentOperationAsync(K key, V value)
protected RFuture<Boolean>	fastPutOperationAsync(K key, V value)
long	fastRemove(K... keys) Removes map entries mapped by specified keys.
RFuture<Long>	fastRemoveAsync(K... keys) Removes map entries mapped by specified keys.
protected RFuture<Long>	fastRemoveOperationAsync(K... keys)
protected RFuture<List<Long>>	fastRemoveOperationBatchAsync(K... keys)
boolean	fastReplace(K key, V value) Replaces previous value with a new value mapped by specified key.
RFuture<Boolean>	fastReplaceAsync(K key, V value) Replaces previous value with a new value mapped by specified key.
protected RFuture<Boolean>	fastReplaceOperationAsync(K key, V value)
V	get(Object key) Returns the value mapped by defined key or null if value is absent.
Map<K,V>	getAll(Set<K> keys) Returns map slice contained the mappings with defined keys.
RFuture<Map<K,V>>	getAllAsync(Set<K> keys) Returns map slice contained the mappings with defined keys.
RFuture<Map<K,V>>	getAllOperationAsync(Set<K> keys)
RFuture<V>	getAsync(K key) Returns the value mapped by defined key or null if value is absent.
RCountDownLatch	getCountDownLatch(K key) Returns RCountDownLatch instance associated with key
RLock	getFairLock(K key) Returns RLock instance associated with key
RLock	getLock(K key) Returns RLock instance associated with key
RFuture<V>	getOperationAsync(K key)
RPermitExpirableSemaphore	getPermitExpirableSemaphore(K key) Returns RPermitExpirableSemaphore instance associated with key
RReadWriteLock	getReadWriteLock(K key) Returns RReadWriteLock instance associated with key
RSemaphore	getSemaphore(K key) Returns RSemaphore instance associated with key
int	hashCode()
protected boolean	hasNoLoader()
protected boolean	hasNoWriter()
boolean	isEmpty()
protected Iterator<K>	keyIterator(String pattern, int count)
Set<K>	keySet() Returns key set of this map.
Set<K>	keySet(int count) Returns key set of this map.
Set<K>	keySet(String pattern) Returns key set of this map.
Set<K>	keySet(String pattern, int count) Returns key set of this map.
void	loadAll(boolean replaceExistingValues, int parallelism) Loads all map entries to this Redis map using MapLoader.
void	loadAll(Set<? extends K> keys, boolean replaceExistingValues, int parallelism) Loads map entries using MapLoader whose keys are listed in defined keys parameter.
RFuture<Void>	loadAllAsync(boolean replaceExistingValues, int parallelism) Loads all map entries to this Redis map using MapLoader.
RFuture<Void>	loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism) Loads map entries using MapLoader whose keys are listed in defined keys parameter.
<KOut,VOut> RMapReduce<K,V,KOut,VOut>	mapReduce() Returns RMapReduce object associated with this map
protected <M> RFuture<M>	mapWriterFuture(RFuture<M> future, MapWriterTask task)
protected <M> RFuture<M>	mapWriterFuture(RFuture<M> future, MapWriterTask task, Function<M,Boolean> condition)
V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)
RFuture<V>	mergeAsync(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) Associates specified key with the given value if key isn't already associated with a value.
V	put(K key, V value) Stores the specified value mapped by specified key.
void	putAll(Map<? extends K,? extends V> map) Stores map entries specified in map object in batch mode.
void	putAll(Map<? extends K,? extends V> map, int batchSize) Stores map entries specified in map object in batch mode.
RFuture<Void>	putAllAsync(Map<? extends K,? extends V> map) Stores map entries specified in map object in batch mode.
RFuture<Void>	putAllAsync(Map<? extends K,? extends V> map, int batchSize) Stores map entries specified in map object in batch mode.
protected RFuture<Void>	putAllOperationAsync(Map<? extends K,? extends V> map)
RFuture<V>	putAsync(K key, V value) Stores the specified value mapped by specified key.
V	putIfAbsent(K key, V value) Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
RFuture<V>	putIfAbsentAsync(K key, V value) Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.
protected RFuture<V>	putIfAbsentOperationAsync(K key, V value)
protected RFuture<V>	putOperationAsync(K key, V value)
Set<Map.Entry<K,V>>	readAllEntrySet() Read all map entries at once
RFuture<Set<Map.Entry<K,V>>>	readAllEntrySetAsync() Read all map entries at once
Set<K>	readAllKeySet() Read all keys at once
RFuture<Set<K>>	readAllKeySetAsync() Read all keys at once
Map<K,V>	readAllMap() Read all map as local instance at once
RFuture<Map<K,V>>	readAllMapAsync() Read all map as local instance at once
Collection<V>	readAllValues() Read all values at once
RFuture<Collection<V>>	readAllValuesAsync() Read all values at once
long	remainTimeToLive() Remaining time to live of Redisson object that has a timeout
RFuture<Long>	remainTimeToLiveAsync() Remaining time to live of Redisson object that has a timeout
V	remove(Object key) Removes map entry by specified key and returns value.
boolean	remove(Object key, Object value) Removes map entry only if it exists with specified key and value.
RFuture<V>	removeAsync(K key) Removes map entry by specified key and returns value.
RFuture<Boolean>	removeAsync(Object key, Object value) Removes map entry only if it exists with specified key and value.
protected RFuture<V>	removeOperationAsync(K key)
protected RFuture<Boolean>	removeOperationAsync(Object key, Object value)
V	replace(K key, V value) Replaces previous value with a new value mapped by specified key.
boolean	replace(K key, V oldValue, V newValue) Replaces previous oldValue with a newValue mapped by specified key.
RFuture<V>	replaceAsync(K key, V value) Replaces previous value with a new value mapped by specified key.
RFuture<Boolean>	replaceAsync(K key, V oldValue, V newValue) Replaces previous oldValue with a newValue mapped by specified key.
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)
int	size()
RFuture<Integer>	sizeAsync() Returns size of this map
protected Iterator<V>	valueIterator(String pattern, int count)
Collection<V>	values() Returns values collection of this map.
Collection<V>	values(int count) Returns values collection of this map.
Collection<V>	values(String keyPattern) Returns values collection of this map.
Collection<V>	values(String keyPattern, int count) Returns values collection of this map.
int	valueSize(K key) Returns size of value mapped by specified key in bytes
RFuture<Integer>	valueSizeAsync(K key) Returns size of value mapped by key in bytes

Methods inherited from class org.redisson.RedissonObject

addListener, addListener, addListenerAsync, addListenerAsync, copy, copyAsync, delete, deleteAsync, deleteAsync, dump, dumpAsync, encode, encode, encode, encode, encodeMapKey, encodeMapKeys, encodeMapValue, encodeMapValues, get, getCodec, getIdleTime, getIdleTimeAsync, getLockByMapKey, getLockByValue, getName, getName, isExists, isExistsAsync, migrate, migrateAsync, move, moveAsync, prefixName, removeListener, removeListenerAsync, removeListenersAsync, rename, renameAsync, renamenx, renamenxAsync, restore, restore, restoreAndReplace, restoreAndReplace, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemory, sizeInMemoryAsync, 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

forEach, getOrDefault, replaceAll

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, getIdleTime, getName, isExists, migrate, move, removeListener, rename, renamenx, restore, restore, restoreAndReplace, restoreAndReplace, sizeInMemory, touch, unlink

Methods inherited from interface org.redisson.api.RExpirableAsync

clearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsync

Methods inherited from interface org.redisson.api.RObjectAsync

addListenerAsync, copyAsync, deleteAsync, dumpAsync, getIdleTimeAsync, isExistsAsync, migrateAsync, moveAsync, removeListenerAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemoryAsync, touchAsync, unlinkAsync

Constructor Detail

RedissonMap

public RedissonMap(CommandAsyncExecutor commandExecutor,
                   String name,
                   RedissonClient redisson,
                   MapOptions<K,V> options,
                   WriteBehindService writeBehindService)

RedissonMap

public RedissonMap(Codec codec,
                   CommandAsyncExecutor commandExecutor,
                   String name,
                   RedissonClient redisson,
                   MapOptions<K,V> options,
                   WriteBehindService writeBehindService)

Method Detail

mapReduce

public <KOut,VOut> RMapReduce<K,V,KOut,VOut> mapReduce()

Description copied from interface: RMap

Returns RMapReduce object associated with this map

Specified by:

mapReduce in interface RMap<K,V>

Type Parameters:

KOut - output key

VOut - output value

Returns:

MapReduce instance

getPermitExpirableSemaphore

public RPermitExpirableSemaphore getPermitExpirableSemaphore(K key)

Description copied from interface: RMap

Returns RPermitExpirableSemaphore instance associated with key

Specified by:

getPermitExpirableSemaphore in interface RMap<K,V>

Parameters:

key - - map key

Returns:

permitExpirableSemaphore

getSemaphore

public RSemaphore getSemaphore(K key)

Description copied from interface: RMap

Returns RSemaphore instance associated with key

Specified by:

getSemaphore in interface RMap<K,V>

Parameters:

key - - map key

Returns:

semaphore

getCountDownLatch

public RCountDownLatch getCountDownLatch(K key)

Description copied from interface: RMap

Returns RCountDownLatch instance associated with key

Specified by:

getCountDownLatch in interface RMap<K,V>

Parameters:

key - - map key

Returns:

countdownlatch

getFairLock

public RLock getFairLock(K key)

Description copied from interface: RMap

Returns RLock instance associated with key

Specified by:

getFairLock in interface RMap<K,V>

Parameters:

key - - map key

Returns:

fairlock

getLock

public RLock getLock(K key)

Description copied from interface: RMap

Returns RLock instance associated with key

Specified by:

getLock in interface RMap<K,V>

Parameters:

key - - map key

Returns:

lock

getReadWriteLock

public RReadWriteLock getReadWriteLock(K key)

Description copied from interface: RMap

Returns RReadWriteLock instance associated with key

Specified by:

getReadWriteLock in interface RMap<K,V>

Parameters:

key - - map key

Returns:

readWriteLock

size

public int size()

Specified by:

size in interface Map<K,V>

merge

public V merge(K key,
               V value,
               BiFunction<? super V,? super V,? extends V> remappingFunction)

Specified by:

merge in interface ConcurrentMap<K,V>

Specified by:

merge in interface Map<K,V>

mergeAsync

public RFuture<V> mergeAsync(K key,
                             V value,
                             BiFunction<? super V,? super V,? extends V> remappingFunction)

Description copied from interface: RMapAsync

Associates specified key with the given value if key isn't already associated with a value. Otherwise, replaces the associated value with the results of the given remapping function, or removes if the result is null.

Specified by:

mergeAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - - value to be merged with the existing value associated with the key or to be associated with the key, if no existing value

remappingFunction - - the function is invoked with the existing value to compute new value

Returns:

new value associated with the specified key or null if no value associated with the key

computeAsync

public RFuture<V> computeAsync(K key,
                               BiFunction<? super K,? super V,? extends V> remappingFunction)

Description copied from interface: RMapAsync

Computes a new mapping for the specified key and its current mapped value.

Specified by:

computeAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

remappingFunction - - function to compute a value

Returns:

the new value associated with the specified key, or null if none

compute

public V compute(K key,
                 BiFunction<? super K,? super V,? extends V> remappingFunction)

Specified by:

compute in interface ConcurrentMap<K,V>

Specified by:

compute in interface Map<K,V>

computeIfAbsentAsync

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

Description copied from interface: RMapAsync

Computes a mapping for the specified key if it's not mapped before.

Specified by:

computeIfAbsentAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

mappingFunction - - function to compute a value

Returns:

current or new computed value associated with the specified key, or null if the computed value is null

computeIfAbsent

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

Specified by:

computeIfAbsent in interface ConcurrentMap<K,V>

Specified by:

computeIfAbsent in interface Map<K,V>

computeIfPresentAsync

public RFuture<V> computeIfPresentAsync(K key,
                                        BiFunction<? super K,? super V,? extends V> remappingFunction)

Description copied from interface: RMapAsync

Computes a mapping for the specified key only if it's already mapped.

Specified by:

computeIfPresentAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

remappingFunction - - function to compute a value

Returns:

the new value associated with the specified key, or null if none

computeIfPresent

public V computeIfPresent(K key,
                          BiFunction<? super K,? super V,? extends V> remappingFunction)

Specified by:

computeIfPresent in interface ConcurrentMap<K,V>

Specified by:

computeIfPresent in interface Map<K,V>

sizeAsync

public RFuture<Integer> sizeAsync()

Description copied from interface: RMapAsync

Returns size of this map

Specified by:

sizeAsync in interface RMapAsync<K,V>

Returns:

size

valueSize

public int valueSize(K key)

Description copied from interface: RMap

Returns size of value mapped by specified key in bytes

Specified by:

valueSize in interface RMap<K,V>

Parameters:

key - - map key

Returns:

size of value

valueSizeAsync

public RFuture<Integer> valueSizeAsync(K key)

Description copied from interface: RMapAsync

Returns size of value mapped by key in bytes

Specified by:

valueSizeAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

Returns:

size of value

checkKey

protected void checkKey(Object key)

isEmpty

public boolean isEmpty()

Specified by:

isEmpty in interface Map<K,V>

containsKey

public boolean containsKey(Object key)

Description copied from interface: RMap

Returns true if this map contains map entry mapped by specified key, otherwise false

Specified by:

containsKey in interface Map<K,V>

Specified by:

containsKey in interface RMap<K,V>

Parameters:

key - - map key

Returns:

true if this map contains map entry mapped by specified key, otherwise false

containsKeyAsync

public RFuture<Boolean> containsKeyAsync(Object key)

Description copied from interface: RMapAsync

Returns true if this map contains map entry mapped by specified key, otherwise false

Specified by:

containsKeyAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

Returns:

true if this map contains map entry mapped by specified key, otherwise false

containsValue

public boolean containsValue(Object value)

Description copied from interface: RMap

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

Specified by:

containsValue in interface Map<K,V>

Specified by:

containsValue in interface RMap<K,V>

Parameters:

value - - map value

Returns:

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

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>

Parameters:

value - - map value

Returns:

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

getAll

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

Description copied from interface: RMap

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.

The returned map is NOT backed by the original map.

Specified by:

getAll in interface RMap<K,V>

Parameters:

keys - - map keys

Returns:

Map slice

getAllAsync

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

Description copied from interface: RMapAsync

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.

The returned map is NOT backed by the original map.

Specified by:

getAllAsync in interface RMapAsync<K,V>

Parameters:

keys - - map keys

Returns:

Map slice

hasNoLoader

protected boolean hasNoLoader()

getAllOperationAsync

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

get

public V get(Object key)

Description copied from interface: RMap

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.

Specified by:

get in interface Map<K,V>

Specified by:

get in interface RMap<K,V>

Parameters:

key - the key

Returns:

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

put

public V put(K key,
             V value)

Description copied from interface: RMap

Stores the specified value mapped by specified key. Returns previous value if map entry with specified key already existed.

If MapWriter is defined then map entry is stored in write-through mode.

Specified by:

put in interface Map<K,V>

Specified by:

put in interface RMap<K,V>

Parameters:

key - - map key

value - - map value

Returns:

previous associated value

remove

public V remove(Object key)

Description copied from interface: RMap

Removes map entry by specified key and returns value.

If MapWriter is defined then keyis deleted in write-through mode.

Specified by:

remove in interface Map<K,V>

Specified by:

remove in interface RMap<K,V>

Parameters:

key - - map key

Returns:

deleted value, null if map entry doesn't exist

putAll

public final void putAll(Map<? extends K,? extends V> map)

Description copied from interface: RMap

Stores map entries specified in map object in batch mode.

If MapWriter is defined then map entries will be stored in write-through mode.

Specified by:

putAll in interface Map<K,V>

Specified by:

putAll in interface RMap<K,V>

Parameters:

map - mappings to be stored in this map

putAll

public void putAll(Map<? extends K,? extends V> map,
                   int batchSize)

Description copied from interface: RMap

Stores map entries specified in map object in batch mode. Batch inserted by chunks limited by batchSize value to avoid OOM and/or Redis response timeout error for map with big size.

If MapWriter is defined then map entries are stored in write-through mode.

Specified by:

putAll in interface RMap<K,V>

Parameters:

map - mappings to be stored in this map

batchSize - - size of map entries batch

putAllAsync

public RFuture<Void> putAllAsync(Map<? extends K,? extends V> map,
                                 int batchSize)

Description copied from interface: RMapAsync

Stores map entries specified in map object in batch mode. Batch inserted by chunks limited by batchSize value to avoid OOM and/or Redis response timeout error for map with big size.

If MapWriter is defined then map entries are stored in write-through mode.

Specified by:

putAllAsync in interface RMapAsync<K,V>

Parameters:

map - mappings to be stored in this map

batchSize - - size of map entries batch

Returns:

void

putAllAsync

public final RFuture<Void> putAllAsync(Map<? extends K,? extends V> map)

Description copied from interface: RMapAsync

Stores map entries specified in map object in batch mode.

If MapWriter is defined then map entries will be stored in write-through mode.

Specified by:

putAllAsync in interface RMapAsync<K,V>

Parameters:

map - mappings to be stored in this map

Returns:

void

mapWriterFuture

protected final <M> RFuture<M> mapWriterFuture(RFuture<M> future,
                                               MapWriterTask task)

mapWriterFuture

protected final <M> RFuture<M> mapWriterFuture(RFuture<M> future,
                                               MapWriterTask task,
                                               Function<M,Boolean> condition)

putAllOperationAsync

protected RFuture<Void> putAllOperationAsync(Map<? extends K,? extends V> map)

clear

public void clear()

Specified by:

clear in interface Map<K,V>

keySet

public Set<K> keySet()

Description copied from interface: RMap

Returns key set of this map. Keys are loaded in batch. Batch size is 10.

Specified by:

keySet in interface Map<K,V>

Specified by:

keySet in interface RMap<K,V>

Returns:

key set

See Also:

RMap.readAllKeySet()

keySet

public Set<K> keySet(String pattern)

Description copied from interface: RMap

Returns key set of this map. If pattern is not null then only keys match this pattern are loaded.

Use org.redisson.client.codec.StringCodec for Map keys.

Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Specified by:

keySet in interface RMap<K,V>

Parameters:

pattern - - key pattern

Returns:

key set

See Also:

RMap.readAllKeySet()

keySet

public Set<K> keySet(String pattern,
                     int count)

Description copied from interface: RMap

Returns key set of this map. If pattern is not null then only keys match this pattern are loaded. Keys are loaded in batch. Batch size is defined by count param.

Use org.redisson.client.codec.StringCodec for Map keys.

Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Specified by:

keySet in interface RMap<K,V>

Parameters:

pattern - - key pattern

count - - size of keys batch

Returns:

key set

See Also:

RMap.readAllKeySet()

keySet

public Set<K> keySet(int count)

Description copied from interface: RMap

Returns key set of this map. Keys are loaded in batch. Batch size is defined by count param.

Specified by:

keySet in interface RMap<K,V>

Parameters:

count - - size of keys batch

Returns:

key set

See Also:

RMap.readAllKeySet()

values

public Collection<V> values()

Description copied from interface: RMap

Returns values collection of this map. Values are loaded in batch. Batch size is 10.

Specified by:

values in interface Map<K,V>

Specified by:

values in interface RMap<K,V>

Returns:

values collection

See Also:

RMap.readAllValues()

values

public Collection<V> values(String keyPattern,
                            int count)

Description copied from interface: RMap

Returns values collection of this map. Values are loaded in batch. Batch size is defined by count param. If keyPattern is not null then only values mapped by matched keys of this pattern are loaded.

Use org.redisson.client.codec.StringCodec for Map keys.

Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Specified by:

values in interface RMap<K,V>

Parameters:

keyPattern - - key pattern

count - - size of values batch

Returns:

values collection

See Also:

RMap.readAllValues()

values

public Collection<V> values(String keyPattern)

Description copied from interface: RMap

Returns values collection of this map. Values are loaded in batch. Batch size is 10. If keyPattern is not null then only values mapped by matched keys of this pattern are loaded.

Use org.redisson.client.codec.StringCodec for Map keys.

Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Specified by:

values in interface RMap<K,V>

Parameters:

keyPattern - - key pattern

Returns:

values collection

See Also:

RMap.readAllValues()

values

public Collection<V> values(int count)

Description copied from interface: RMap

Returns values collection of this map. Values are loaded in batch. Batch size is defined by count param.

Specified by:

values in interface RMap<K,V>

Parameters:

count - - size of values batch

Returns:

values collection

See Also:

RMap.readAllValues()

entrySet

public Set<Map.Entry<K,V>> entrySet()

Description copied from interface: RMap

Returns map entries collection. Map entries are loaded in batch. Batch size is 10.

Specified by:

entrySet in interface Map<K,V>

Specified by:

entrySet in interface RMap<K,V>

Returns:

map entries collection

See Also:

RMap.readAllEntrySet()

entrySet

public Set<Map.Entry<K,V>> entrySet(String keyPattern)

Description copied from interface: RMap

Returns map entries collection. Map entries are loaded in batch. Batch size is 10. If keyPattern is not null then only entries mapped by matched keys of this pattern are loaded. Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Specified by:

entrySet in interface RMap<K,V>

Parameters:

keyPattern - - key pattern

Returns:

map entries collection

See Also:

RMap.readAllEntrySet()

entrySet

public Set<Map.Entry<K,V>> entrySet(String keyPattern,
                                    int count)

Description copied from interface: RMap

Returns map entries collection. Map entries are loaded in batch. Batch size is defined by count param. If keyPattern is not null then only entries mapped by matched keys of this pattern are loaded. Supported glob-style patterns:

h?llo subscribes to hello, hallo and hxllo

h*llo subscribes to hllo and heeeello

h[ae]llo subscribes to hello and hallo, but not hillo

Specified by:

entrySet in interface RMap<K,V>

Parameters:

keyPattern - - key pattern

count - - size of entries batch

Returns:

map entries collection

See Also:

RMap.readAllEntrySet()

entrySet

public Set<Map.Entry<K,V>> entrySet(int count)

Description copied from interface: RMap

Returns map entries collection. Map entries are loaded in batch. Batch size is defined by count param.

Specified by:

entrySet in interface RMap<K,V>

Parameters:

count - - size of entries batch

Returns:

map entries collection

See Also:

RMap.readAllEntrySet()

readAllKeySet

public Set<K> readAllKeySet()

Description copied from interface: RMap

Read all keys at once

Specified by:

readAllKeySet in interface RMap<K,V>

Returns:

keys

readAllKeySetAsync

public RFuture<Set<K>> readAllKeySetAsync()

Description copied from interface: RMapAsync

Read all keys at once

Specified by:

readAllKeySetAsync in interface RMapAsync<K,V>

Returns:

keys

readAllValues

public Collection<V> readAllValues()

Description copied from interface: RMap

Read all values at once

Specified by:

readAllValues in interface RMap<K,V>

Returns:

values

readAllValuesAsync

public RFuture<Collection<V>> readAllValuesAsync()

Description copied from interface: RMapAsync

Read all values at once

Specified by:

readAllValuesAsync in interface RMapAsync<K,V>

Returns:

values

readAllEntrySet

public Set<Map.Entry<K,V>> readAllEntrySet()

Description copied from interface: RMap

Read all map entries at once

Specified by:

readAllEntrySet in interface RMap<K,V>

Returns:

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>

Returns:

entries

readAllMap

public Map<K,V> readAllMap()

Description copied from interface: RMap

Read all map as local instance at once

Specified by:

readAllMap in interface RMap<K,V>

Returns:

map

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>

Returns:

map

putIfAbsent

public V putIfAbsent(K key,
                     V value)

Description copied from interface: RMap

Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.

If MapWriter is defined then new map entry is stored in write-through mode.

Specified by:

putIfAbsent in interface ConcurrentMap<K,V>

Specified by:

putIfAbsent in interface Map<K,V>

Specified by:

putIfAbsent in interface RMap<K,V>

Parameters:

key - - map key

value - - map value

Returns:

null if key is a new one in the hash and value was set. Previous value if key already exists in the hash and change hasn't been made.

putIfAbsentAsync

public RFuture<V> putIfAbsentAsync(K key,
                                   V value)

Description copied from interface: RMapAsync

Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.

If MapWriter is defined then new map entry is stored in write-through mode.

Specified by:

putIfAbsentAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - - map value

Returns:

null if key is a new one in the hash and value was set. Previous value if key already exists in the hash and change hasn't been made.

hasNoWriter

protected boolean hasNoWriter()

putIfAbsentOperationAsync

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

fastPutIfAbsent

public boolean fastPutIfAbsent(K key,
                               V value)

Description copied from interface: RMap

Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.

Returns true if key is a new one in the hash and value was set or false if key already exists in the hash and change hasn't been made.

Works faster than RMap.putIfAbsent(Object, Object) but not returning the previous value associated with key

If MapWriter is defined then new map entry is stored in write-through mode.

Specified by:

fastPutIfAbsent in interface RMap<K,V>

Parameters:

key - - map key

value - - map value

Returns:

true if key is a new one in the hash and value was set. false if key already exists in the hash and change hasn't been made.

fastPutIfAbsentAsync

public RFuture<Boolean> fastPutIfAbsentAsync(K key,
                                             V value)

Description copied from interface: RMapAsync

Stores the specified value mapped by specified key only if there is no value with specifiedkey stored before.

Returns true if key is a new one in the hash and value was set or false if key already exists in the hash and change hasn't been made.

Works faster than RMapAsync.putIfAbsentAsync(Object, Object) but not returning the previous value associated with key

If MapWriter is defined then new map entry is stored in write-through mode.

Specified by:

fastPutIfAbsentAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - - map value

Returns:

true if key is a new one in the hash and value was set. false if key already exists in the hash and change hasn't been made.

fastPutIfAbsentOperationAsync

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

remove

public boolean remove(Object key,
                      Object value)

Description copied from interface: RMap

Removes map entry only if it exists with specified key and value.

If MapWriter is defined then keyis deleted in write-through mode.

Specified by:

remove in interface ConcurrentMap<K,V>

Specified by:

remove in interface Map<K,V>

Specified by:

remove in interface RMap<K,V>

Parameters:

key - - map key

value - - map value

Returns:

true if map entry has been removed otherwise false.

removeAsync

public RFuture<Boolean> removeAsync(Object key,
                                    Object value)

Description copied from interface: RMapAsync

Removes map entry only if it exists with specified key and value.

If MapWriter is defined then keyis deleted in write-through mode.

Specified by:

removeAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - - map value

Returns:

true if map entry has been removed otherwise false.

removeOperationAsync

protected RFuture<Boolean> removeOperationAsync(Object key,
                                                Object value)

checkValue

protected void checkValue(Object value)

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

Description copied from interface: RMap

Replaces previous oldValue with a newValue mapped by specified key. Returns false if previous value doesn't exist or equal to oldValue.

If MapWriter is defined then newValueis written in write-through mode.

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

Specified by:

replace in interface RMap<K,V>

Parameters:

key - - map key

oldValue - - map old value

newValue - - map new value

Returns:

true if value has been replaced otherwise false.

replaceAsync

public RFuture<Boolean> replaceAsync(K key,
                                     V oldValue,
                                     V newValue)

Description copied from interface: RMapAsync

Replaces previous oldValue with a newValue mapped by specified key. Returns false if previous value doesn't exist or equal to oldValue.

If MapWriter is defined then newValueis written in write-through mode.

Specified by:

replaceAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

oldValue - - map old value

newValue - - map new value

Returns:

true if value has been replaced otherwise false.

replaceOperationAsync

protected RFuture<Boolean> replaceOperationAsync(K key,
                                                 V oldValue,
                                                 V newValue)

replace

public V replace(K key,
                 V value)

Description copied from interface: RMap

Replaces previous value with a new value mapped by specified key. Returns null if there is no map entry stored before and doesn't store new map entry.

If MapWriter is defined then new valueis written in write-through mode.

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

Specified by:

replace in interface RMap<K,V>

Parameters:

key - - map key

value - - map value

Returns:

previous associated value or null if there is no map entry stored before and doesn't store new map entry

replaceAsync

public RFuture<V> replaceAsync(K key,
                               V value)

Description copied from interface: RMapAsync

Replaces previous value with a new value mapped by specified key. Returns null if there is no map entry stored before and doesn't store new map entry.

If MapWriter is defined then new valueis written in write-through mode.

Specified by:

replaceAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - - map value

Returns:

previous associated value or null if there is no map entry stored before and doesn't store new map entry

replaceOperationAsync

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

fastReplace

public boolean fastReplace(K key,
                           V value)

Description copied from interface: RMap

Replaces previous value with a new value mapped by specified key.

Works faster than RMap.replace(Object, Object) but not returning the previous value.

Returns true if key exists and value was updated or false if key doesn't exists and value wasn't updated.

If MapWriter is defined then new map entry is stored in write-through mode.

Specified by:

fastReplace in interface RMap<K,V>

Parameters:

key - - map key

value - - map value

Returns:

true if key exists and value was updated. false if key doesn't exists and value wasn't updated.

fastReplaceAsync

public RFuture<Boolean> fastReplaceAsync(K key,
                                         V value)

Description copied from interface: RMapAsync

Replaces previous value with a new value mapped by specified key.

Works faster than RMapAsync.replaceAsync(Object, Object) but not returning the previous value.

Returns true if key exists and value was updated or false if key doesn't exists and value wasn't updated.

If MapWriter is defined then new map entry is stored in write-through mode.

Specified by:

fastReplaceAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - - map value

Returns:

true if key exists and value was updated. false if key doesn't exists and value wasn't updated.

fastReplaceOperationAsync

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

getOperationAsync

public RFuture<V> getOperationAsync(K key)

getAsync

public RFuture<V> getAsync(K key)

Description copied from interface: RMapAsync

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.

Specified by:

getAsync in interface RMapAsync<K,V>

Parameters:

key - the key

Returns:

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

loadAll

public void loadAll(boolean replaceExistingValues,
                    int parallelism)

Description copied from interface: RMap

Loads all map entries to this Redis map using MapLoader.

Specified by:

loadAll in interface RMap<K,V>

Parameters:

replaceExistingValues - - true if existed values should be replaced, false otherwise.

parallelism - - parallelism level, used to increase speed of process execution

loadAllAsync

public RFuture<Void> loadAllAsync(boolean replaceExistingValues,
                                  int parallelism)

Description copied from interface: RMapAsync

Loads all map entries to this Redis map using MapLoader.

Specified by:

loadAllAsync in interface RMapAsync<K,V>

Parameters:

replaceExistingValues - - true if existed values should be replaced, false otherwise.

parallelism - - parallelism level, used to increase speed of process execution

Returns:

void

loadAll

public void loadAll(Set<? extends K> keys,
                    boolean replaceExistingValues,
                    int parallelism)

Description copied from interface: RMap

Loads map entries using MapLoader whose keys are listed in defined keys parameter.

Specified by:

loadAll in interface RMap<K,V>

Parameters:

keys - - map keys

replaceExistingValues - - true if existed values should be replaced, false otherwise.

parallelism - - parallelism level, used to increase speed of process execution

loadAllAsync

public RFuture<Void> loadAllAsync(Set<? extends K> keys,
                                  boolean replaceExistingValues,
                                  int parallelism)

Description copied from interface: RMapAsync

Loads map entries using MapLoader whose keys are listed in defined keys parameter.

Specified by:

loadAllAsync in interface RMapAsync<K,V>

Parameters:

keys - - map keys

replaceExistingValues - - true if existed values should be replaced, false otherwise.

parallelism - - parallelism level, used to increase speed of process execution

Returns:

void

putAsync

public RFuture<V> putAsync(K key,
                           V value)

Description copied from interface: RMapAsync

Stores the specified value mapped by specified key. Returns previous value if map entry with specified key already existed.

If MapWriter is defined then map entry is stored in write-through mode.

Specified by:

putAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - - map value

Returns:

previous associated value

putOperationAsync

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

removeAsync

public RFuture<V> removeAsync(K key)

Description copied from interface: RMapAsync

Removes map entry by specified key and returns value.

If MapWriter is defined then keyis deleted in write-through mode.

Specified by:

removeAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

Returns:

deleted value, null if map entry doesn't exist

removeOperationAsync

protected RFuture<V> removeOperationAsync(K key)

fastPutAsync

public RFuture<Boolean> fastPutAsync(K key,
                                     V value)

Description copied from interface: RMapAsync

Stores the specified value mapped by specified key.

Works faster than RMapAsync.putAsync(Object, Object) but not returning previous value.

Returns true if key is a new key in the hash and value was set or false if key already exists in the hash and the value was updated.

If MapWriter is defined then map entry is stored in write-through mode.

Specified by:

fastPutAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - - map value

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)

fastPut

public boolean fastPut(K key,
                       V value)

Description copied from interface: RMap

Stores the specified value mapped by specified key.

Works faster than RMap.put(Object, Object) but not returning previous value.

Returns true if key is a new key in the hash and value was set or false if key already exists in the hash and the value was updated.

If MapWriter is defined then map entry is stored in write-through mode.

Specified by:

fastPut in interface RMap<K,V>

Parameters:

key - - map key

value - - map value

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.

fastRemoveAsync

public RFuture<Long> fastRemoveAsync(K... keys)

Description copied from interface: RMapAsync

Removes map entries mapped by specified keys.

Works faster than RMapAsync.removeAsync(Object) but not returning the value.

If MapWriter is defined then keysare deleted in write-through mode.

Specified by:

fastRemoveAsync in interface RMapAsync<K,V>

Parameters:

keys - - map keys

Returns:

the number of keys that were removed from the hash, not including specified but non existing keys

fastRemoveOperationBatchAsync

protected RFuture<List<Long>> fastRemoveOperationBatchAsync(K... keys)

fastRemoveOperationAsync

protected RFuture<Long> fastRemoveOperationAsync(K... keys)

fastRemove

public long fastRemove(K... keys)

Description copied from interface: RMap

Removes map entries mapped by specified keys.

Works faster than RMap.remove(Object) but not returning the value.

If MapWriter is defined then keysare deleted in write-through mode.

Specified by:

fastRemove in interface RMap<K,V>

Parameters:

keys - - map keys

Returns:

the number of keys that were removed from the hash, not including specified but non existing keys

scanIterator

public MapScanResult<Object,Object> scanIterator(String name,
                                                 RedisClient client,
                                                 long startPos,
                                                 String pattern,
                                                 int count)

scanIteratorAsync

public RFuture<MapScanResult<Object,Object>> scanIteratorAsync(String name,
                                                               RedisClient client,
                                                               long startPos,
                                                               String pattern,
                                                               int count)

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 for numeric values!

Specified by:

addAndGet in interface RMap<K,V>

Parameters:

key - - map key

value - the value to add

Returns:

the updated value

addAndGetAsync

public RFuture<V> addAndGetAsync(K key,
                                 Number value)

Description copied from interface: RMapAsync

Adds the given delta to the current value by mapped key. Works only for numeric values!

Specified by:

addAndGetAsync in interface RMapAsync<K,V>

Parameters:

key - - map key

value - the value to add

Returns:

the updated value

addAndGetOperationAsync

protected RFuture<V> addAndGetOperationAsync(K key,
                                             Number value)

equals

public boolean equals(Object o)

Specified by:

equals in interface Map<K,V>

Overrides:

equals in class Object

hashCode

public int hashCode()

Specified by:

hashCode in interface Map<K,V>

Overrides:

hashCode in class Object

keyIterator

protected Iterator<K> keyIterator(String pattern,
                                  int count)

valueIterator

protected Iterator<V> valueIterator(String pattern,
                                    int count)

entryIterator

protected Iterator<Map.Entry<K,V>> entryIterator(String pattern,
                                                 int count)

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

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

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

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

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

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

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.

expireAsync

protected RFuture<Boolean> expireAsync(long timeToLive,
                                       TimeUnit timeUnit,
                                       String... keys)

expireAtAsync

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

clearExpireAsync

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