K - keyV - valuepublic class RedissonMap<K,V> extends RedissonObject implements RMap<K,V>
ConcurrentMap
and Mapcodec, commandExecutor| Modifier | Constructor and Description |
|---|---|
|
RedissonMap(Codec codec,
CommandAsyncExecutor commandExecutor,
String name,
RedissonClient redisson,
MapOptions<K,V> options) |
protected |
RedissonMap(CommandAsyncExecutor commandExecutor,
String name,
RedissonClient redisson,
MapOptions<K,V> options) |
| Modifier and Type | Method and Description |
|---|---|
V |
addAndGet(K key,
Number value)
Atomically adds the given
delta to the current value
by mapped key. |
RFuture<V> |
addAndGetAsync(K key,
Number value) |
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.
|
boolean |
containsKey(Object key) |
RFuture<Boolean> |
containsKeyAsync(Object key) |
boolean |
containsValue(Object value) |
RFuture<Boolean> |
containsValueAsync(Object value) |
protected Iterator<Map.Entry<K,V>> |
entryIterator() |
Set<Map.Entry<K,V>> |
entrySet()
Returns values collections.
|
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.
|
boolean |
expireAt(Date timestamp)
Set an expire date for object.
|
boolean |
expireAt(long timestamp)
Set an expire date for object.
|
RFuture<Boolean> |
expireAtAsync(Date timestamp)
Set an expire date for object in async mode.
|
RFuture<Boolean> |
expireAtAsync(long timestamp)
Set an expire date for object in async mode.
|
boolean |
fastPut(K key,
V value)
Associates the specified
value with the specified key. |
RFuture<Boolean> |
fastPutAsync(K key,
V value)
Associates the specified
value with the specified key
in async manner. |
boolean |
fastPutIfAbsent(K key,
V value)
Associates the specified
value with the specified key
only if there is no any association with specifiedkey. |
RFuture<Boolean> |
fastPutIfAbsentAsync(K key,
V value)
Associates the specified
value with the specified key
only if there is no any association with specifiedkey. |
protected RFuture<Boolean> |
fastPutIfAbsentOperationAsync(K key,
V value) |
protected RFuture<Boolean> |
fastPutOperationAsync(K key,
V value) |
long |
fastRemove(K... keys)
Removes
keys from map by one operation
Works faster than key
If MapWriter is defined then keysare deleted in write-through mode. |
RFuture<Long> |
fastRemoveAsync(K... keys)
Removes
keys from map by one operation in async manner. |
protected RFuture<Long> |
fastRemoveOperationAsync(K... keys) |
protected RFuture<List<Long>> |
fastRemoveOperationBatchAsync(K... keys) |
V |
get(Object key)
Returns the value to which the specified key is mapped,
or
null if this map contains no mapping for the key. |
Map<K,V> |
getAll(Set<K> keys)
Gets a map slice contained the mappings with defined
keys
by one operation. |
RFuture<Map<K,V>> |
getAllAsync(Set<K> keys)
Gets a map slice contained the mappings with defined
keys
by one operation. |
protected RFuture<Map<K,V>> |
getAllOperationAsync(Set<K> keys) |
RFuture<V> |
getAsync(K key)
Returns the value to which the specified key is mapped,
or
null if this map contains no mapping for the key. |
RLock |
getLock(K key)
Returns
RLock instance associated with key |
protected RFuture<V> |
getOperationAsync(K key) |
RReadWriteLock |
getReadWriteLock(K key)
Returns
RReadWriteLock instance associated with key |
int |
hashCode() |
protected boolean |
hasNoLoader() |
protected boolean |
hasNoWriter() |
boolean |
isEmpty() |
protected Iterator<K> |
keyIterator() |
Set<K> |
keySet()
Returns key set.
|
void |
loadAll(boolean replaceExistingValues,
int parallelism)
Loads all map entries to this Redis map.
|
void |
loadAll(Set<? extends K> keys,
boolean replaceExistingValues,
int parallelism)
Loads map entries whose keys are listed in defined
keys parameter. |
RFuture<Void> |
loadAllAsync(boolean replaceExistingValues,
int parallelism)
Loads all map entries to this Redis map.
|
RFuture<Void> |
loadAllAsync(Set<? extends K> keys,
boolean replaceExistingValues,
int parallelism)
Loads map entries whose keys are listed in defined
keys parameter. |
<KOut,VOut> |
mapReduce()
Returns
RMapReduce object associated with this map |
protected <M> RFuture<M> |
mapWriterFuture(RFuture<M> future,
MapWriterTask<M> listener) |
V |
put(K key,
V value)
Associates the specified
value with the specified key
in async manner. |
void |
putAll(Map<? extends K,? extends V> map)
Associates the specified
value with the specified key
in batch. |
RFuture<Void> |
putAllAsync(Map<? extends K,? extends V> map)
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)
Associates the specified
value with the specified key
in async manner. |
V |
putIfAbsent(K key,
V value)
Associates the specified
value with the specified key
only if there is no any association with specifiedkey. |
RFuture<V> |
putIfAbsentAsync(K key,
V value)
Associates the specified
value with the specified key
only if there is no any association with specifiedkey. |
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()
Get remaining time to live of object in seconds.
|
V |
remove(Object key)
Removes
key from map and returns associated value in async manner. |
boolean |
remove(Object key,
Object value)
Removes
key from map only if it associated with value. |
RFuture<V> |
removeAsync(K key)
Removes
key from map and returns associated value in async manner. |
RFuture<Boolean> |
removeAsync(Object key,
Object value)
Removes
key from map only if it associated with 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 associated with the key. |
boolean |
replace(K key,
V oldValue,
V newValue)
Replaces previous
oldValue with a newValue associated with the key. |
RFuture<V> |
replaceAsync(K key,
V value)
Replaces previous value with a new
value associated with the key. |
RFuture<Boolean> |
replaceAsync(K key,
V oldValue,
V newValue)
Replaces previous
oldValue with a newValue associated with the key. |
protected RFuture<V> |
replaceOperationAsync(K key,
V value) |
protected RFuture<Boolean> |
replaceOperationAsync(K key,
V oldValue,
V newValue) |
int |
size() |
RFuture<Integer> |
sizeAsync() |
protected Iterator<V> |
valueIterator() |
Collection<V> |
values()
Returns values collections.
|
int |
valueSize(K key)
Returns size of value mapped by key in bytes
|
RFuture<Integer> |
valueSizeAsync(K key)
Returns size of value mapped by key in bytes
|
await, delete, deleteAsync, encode, encodeMapKey, encodeMapValue, get, getCodec, getName, getName, isExists, isExistsAsync, migrate, migrateAsync, move, moveAsync, newPromise, newSucceededFuture, prefixName, rename, renameAsync, renamenx, renamenxAsync, suffixName, touch, touchAsync, unlink, unlinkAsyncclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitcompute, computeIfAbsent, computeIfPresent, forEach, getOrDefault, merge, replaceAllclearExpire, expire, expireAt, expireAt, remainTimeToLivedelete, getCodec, getName, isExists, migrate, move, rename, renamenx, touch, unlinkclearExpireAsync, expireAsync, expireAtAsync, expireAtAsync, remainTimeToLiveAsyncdeleteAsync, isExistsAsync, migrateAsync, moveAsync, renameAsync, renamenxAsync, touchAsync, unlinkAsyncprotected RedissonMap(CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K,V> options)
public RedissonMap(Codec codec, CommandAsyncExecutor commandExecutor, String name, RedissonClient redisson, MapOptions<K,V> options)
public <KOut,VOut> RMapReduce<K,V,KOut,VOut> mapReduce()
RMapRMapReduce object associated with this mappublic RLock getLock(K key)
RMapRLock instance associated with keypublic RReadWriteLock getReadWriteLock(K key)
RMapRReadWriteLock instance associated with keygetReadWriteLock in interface RMap<K,V>key - - map keypublic int valueSize(K key)
RMappublic RFuture<Integer> valueSizeAsync(K key)
RMapAsyncvalueSizeAsync in interface RMapAsync<K,V>key - - map keyprotected void checkKey(Object key)
public boolean containsKey(Object key)
containsKey in interface Map<K,V>public RFuture<Boolean> containsKeyAsync(Object key)
containsKeyAsync in interface RMapAsync<K,V>public boolean containsValue(Object value)
containsValue in interface Map<K,V>public RFuture<Boolean> containsValueAsync(Object value)
containsValueAsync in interface RMapAsync<K,V>public Map<K,V> getAll(Set<K> keys)
RMapkeys
by one operation.
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.
public RFuture<Map<K,V>> getAllAsync(Set<K> keys)
RMapAsynckeys
by one operation.
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.
getAllAsync in interface RMapAsync<K,V>keys - - map keysprotected boolean hasNoLoader()
public V get(Object key)
RMapnull if this map contains no mapping for the key.
If map doesn't contain value for specified key and MapLoader is defined
then value will be loaded in read-through mode.
public V put(K key, V value)
RMapvalue with the specified key
in async manner.
If MapWriter is defined then new map entry is stored in write-through mode.
public V remove(Object key)
RMapkey from map and returns associated value in async manner.
If MapWriter is defined then keyis deleted in write-through mode.
public void putAll(Map<? extends K,? extends V> map)
RMapvalue with the specified key
in batch.
If MapWriter is defined then new map entries will be stored in write-through mode.
public RFuture<Void> putAllAsync(Map<? extends K,? extends V> map)
RMapAsyncvalue with the specified key
in batch.
If MapWriter is defined then new map entries are stored in write-through mode.
putAllAsync in interface RMapAsync<K,V>map - mappings to be stored in this mapprotected <M> RFuture<M> mapWriterFuture(RFuture<M> future, MapWriterTask<M> listener)
public Set<K> keySet()
RMapRMap.readAllKeySet() does.public Collection<V> values()
RMapRMap.readAllValues() does.public Set<Map.Entry<K,V>> entrySet()
RMapRMap.readAllEntrySet() does.public Set<K> readAllKeySet()
RMapreadAllKeySet in interface RMap<K,V>public RFuture<Set<K>> readAllKeySetAsync()
RMapAsyncreadAllKeySetAsync in interface RMapAsync<K,V>public Collection<V> readAllValues()
RMapreadAllValues in interface RMap<K,V>public RFuture<Collection<V>> readAllValuesAsync()
RMapAsyncreadAllValuesAsync in interface RMapAsync<K,V>public Set<Map.Entry<K,V>> readAllEntrySet()
RMapreadAllEntrySet in interface RMap<K,V>public RFuture<Set<Map.Entry<K,V>>> readAllEntrySetAsync()
RMapAsyncreadAllEntrySetAsync in interface RMapAsync<K,V>public Map<K,V> readAllMap()
RMapreadAllMap in interface RMap<K,V>public RFuture<Map<K,V>> readAllMapAsync()
RMapAsyncreadAllMapAsync in interface RMapAsync<K,V>public V putIfAbsent(K key, V value)
RMapvalue with the specified key
only if there is no any association with specifiedkey.
If MapWriter is defined then new map entry is stored in write-through mode.
putIfAbsent in interface ConcurrentMap<K,V>putIfAbsent in interface Map<K,V>putIfAbsent in interface RMap<K,V>key - - map keyvalue - - map valuenull 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.public RFuture<V> putIfAbsentAsync(K key, V value)
RMapAsyncvalue with the specified key
only if there is no any association with specifiedkey.
If MapWriter is defined then new map entry is stored in write-through mode.
putIfAbsentAsync in interface RMapAsync<K,V>key - - map keyvalue - - map valuenull 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.protected boolean hasNoWriter()
public boolean fastPutIfAbsent(K key, V value)
RMapvalue with the specified key
only if there is no any association with specifiedkey.
Works faster than RMap.putIfAbsent(Object, Object)key
If MapWriter is defined then new map entry is stored in write-through mode.
fastPutIfAbsent in interface RMap<K,V>key - - map keyvalue - - map valuetrue 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.public RFuture<Boolean> fastPutIfAbsentAsync(K key, V value)
RMapAsyncvalue with the specified key
only if there is no any association with specifiedkey.
Works faster than RMapAsync.putIfAbsentAsync(Object, Object)key
If MapWriter is defined then new map entry is stored in write-through mode.
fastPutIfAbsentAsync in interface RMapAsync<K,V>key - - map keyvalue - - map valuetrue 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.protected RFuture<Boolean> fastPutIfAbsentOperationAsync(K key, V value)
public boolean remove(Object key, Object value)
RMapkey from map only if it associated with value.
If MapWriter is defined then keyis deleted in write-through mode.
public RFuture<Boolean> removeAsync(Object key, Object value)
RMapAsynckey from map only if it associated with value.
If MapWriter is defined then keyis deleted in write-through mode.
removeAsync in interface RMapAsync<K,V>key - - map keyvalue - - map valuetrue if map entry has been replaced otherwise false.protected void checkValue(Object value)
public boolean replace(K key, V oldValue, V newValue)
RMapoldValue with a newValue associated with the key.
If previous value doesn't exist or equal to oldValue then method returns false.
If MapWriter is defined then newValueis written in write-through mode.
public RFuture<Boolean> replaceAsync(K key, V oldValue, V newValue)
RMapAsyncoldValue with a newValue associated with the key.
If previous value doesn't exist or equal to oldValue then method returns false.
If MapWriter is defined then newValueis written in write-through mode.
replaceAsync in interface RMapAsync<K,V>key - - map keyoldValue - - map old valuenewValue - - map new valuetrue if value has been replaced otherwise false.protected RFuture<Boolean> replaceOperationAsync(K key, V oldValue, V newValue)
public V replace(K key, V value)
RMapvalue associated with the key.
If there wasn't any association before then method returns null.
If MapWriter is defined then new valueis written in write-through mode.
public RFuture<V> replaceAsync(K key, V value)
RMapAsyncvalue associated with the key.
If there wasn't any association before then method returns null.
If MapWriter is defined then new valueis written in write-through mode.
replaceAsync in interface RMapAsync<K,V>key - - map keyvalue - - map valuenull if there wasn't any association and change hasn't been madepublic RFuture<V> getAsync(K key)
RMapAsyncnull if this map contains no mapping for the key.
If map doesn't contain value for specified key and MapLoader is defined
then value will be loaded in read-through mode.
public void loadAll(boolean replaceExistingValues,
int parallelism)
RMappublic RFuture<Void> loadAllAsync(boolean replaceExistingValues, int parallelism)
RMapAsyncloadAllAsync in interface RMapAsync<K,V>replaceExistingValues - - true if existed values should be replaced, false otherwise.parallelism - - parallelism level, used to increase speed of process executionpublic void loadAll(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)
RMapkeys parameter.public RFuture<Void> loadAllAsync(Set<? extends K> keys, boolean replaceExistingValues, int parallelism)
RMapAsynckeys parameter.loadAllAsync in interface RMapAsync<K,V>keys - - map keysreplaceExistingValues - - true if existed values should be replaced, false otherwise.parallelism - - parallelism level, used to increase speed of process executionpublic RFuture<V> putAsync(K key, V value)
RMapAsyncvalue with the specified key
in async manner.
If MapWriter is defined then new map entry is stored in write-through mode.
public RFuture<V> removeAsync(K key)
RMapAsynckey from map and returns associated value in async manner.
If MapWriter is defined then keyis deleted in write-through mode.
removeAsync in interface RMapAsync<K,V>key - - map keynull if there wasn't any associationpublic RFuture<Boolean> fastPutAsync(K key, V value)
RMapAsyncvalue with the specified key
in async manner.
Works faster than RMapAsync.putAsync(Object, Object)key
If MapWriter is defined then new map entry is stored in write-through mode.
fastPutAsync in interface RMapAsync<K,V>key - - map keyvalue - - map valuetrue if key is a new one in the hash and value was set.
false if key already exists in the hash and the value was updated.public boolean fastPut(K key, V value)
RMapvalue with the specified key.
Works faster than RMap.put(Object, Object)key
If MapWriter is defined then new map entry is stored in write-through mode.
public RFuture<Long> fastRemoveAsync(K... keys)
RMapAsynckeys from map by one operation in async manner.
Works faster than RMapAsync.removeAsync(Object, Object)key.
If MapWriter is defined then keysare deleted in write-through mode.
fastRemoveAsync in interface RMapAsync<K,V>keys - - map keysprotected RFuture<List<Long>> fastRemoveOperationBatchAsync(K... keys)
public long fastRemove(K... keys)
RMapkeys from map by one operation
Works faster than RMap.remove(Object)key
If MapWriter is defined then keysare deleted in write-through mode.
fastRemove in interface RMap<K,V>keys - - map keyspublic V addAndGet(K key, Number value)
RMapdelta to the current value
by mapped key.
Works only for numeric values!public RFuture<V> addAndGetAsync(K key, Number value)
addAndGetAsync in interface RMapAsync<K,V>public boolean equals(Object o)
public int hashCode()
public boolean expire(long timeToLive,
TimeUnit timeUnit)
RExpirableexpire in interface RExpirabletimeToLive - - timeout before object will be deletedtimeUnit - - timeout time unittrue if the timeout was set and false if notpublic RFuture<Boolean> expireAsync(long timeToLive, TimeUnit timeUnit)
RExpirableAsyncexpireAsync in interface RExpirableAsynctimeToLive - - timeout before object will be deletedtimeUnit - - timeout time unittrue if the timeout was set and false if notpublic boolean expireAt(long timestamp)
RExpirableexpireAt in interface RExpirabletimestamp - - expire date in milliseconds (Unix timestamp)true if the timeout was set and false if notpublic RFuture<Boolean> expireAtAsync(long timestamp)
RExpirableAsyncexpireAtAsync in interface RExpirableAsynctimestamp - - expire date in seconds (Unix timestamp)true if the timeout was set and false if notpublic boolean expireAt(Date timestamp)
RExpirableexpireAt in interface RExpirabletimestamp - - expire datetrue if the timeout was set and false if notpublic RFuture<Boolean> expireAtAsync(Date timestamp)
RExpirableAsyncexpireAtAsync in interface RExpirableAsynctimestamp - - expire datetrue if the timeout was set and false if notpublic boolean clearExpire()
RExpirableclearExpire in interface RExpirabletrue if timeout was removed
false if object does not exist or does not have an associated timeoutpublic RFuture<Boolean> clearExpireAsync()
RExpirableAsyncclearExpireAsync in interface RExpirableAsynctrue if the timeout was cleared and false if notpublic long remainTimeToLive()
RExpirableremainTimeToLive in interface RExpirablepublic RFuture<Long> remainTimeToLiveAsync()
RExpirableAsyncremainTimeToLiveAsync in interface RExpirableAsync-1 if object does not exist or time in secondsCopyright © 2014–2017 The Redisson Project. All rights reserved.