org.redisson.api

Interface RMap<K,V>

Type Parameters:

K - map key

V - value

All Superinterfaces:

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

All Known Subinterfaces:

RLocalCachedMap<K,V>, RMapCache<K,V>

All Known Implementing Classes:

RedissonLocalCachedMap, RedissonMap, RedissonMapCache, RedissonTransactionalLocalCachedMap, RedissonTransactionalMap, RedissonTransactionalMapCache

public interface RMap<K,V>
extends ConcurrentMap<K,V>, RExpirable, RMapAsync<K,V>

Distributed implementation of ConcurrentMap and Map This map doesn't allow to store null as key or value.

Author:

Nikita Koksharov

Nested Class Summary

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

Map.Entry<K,V>

Method Summary

Modifier and Type	Method and Description
V	addAndGet(K key, Number delta) Atomically adds the given delta to the current value by mapped key.
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	fastPut(K key, V value) Associates the specified value with the specified key.
boolean	fastPutIfAbsent(K key, V value) Associates the specified value with the specified key only if there is no any association with specifiedkey.
long	fastRemove(K... keys) Removes keys from map by one operation Works faster than remove(Object) but not returning the value associated with key If MapWriter is defined then keysare deleted in write-through mode.
boolean	fastReplace(K key, V value) Replaces previous value with a new value associated with the key.
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.
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
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
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.
<KOut,VOut> RMapReduce<K,V,KOut,VOut>	mapReduce() Returns RMapReduce object associated with this map
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.
void	putAll(Map<? extends K,? extends V> map, int batchSize) Associates the specified value with the specified key in batch.
V	putIfAbsent(K key, V value) Associates the specified value with the specified key only if there is no any association with specifiedkey.
Set<Map.Entry<K,V>>	readAllEntrySet() Read all map entries at once
Set<K>	readAllKeySet() Read all keys at once
Map<K,V>	readAllMap() Read all map as local instance at once
Collection<V>	readAllValues() Read all values at once
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.
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.
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 key in bytes

Methods inherited from interface java.util.concurrent.ConcurrentMap

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

Methods inherited from interface java.util.Map

clear, containsKey, containsValue, equals, hashCode, isEmpty, size

Methods inherited from interface org.redisson.api.RExpirable

clearExpire, expire, expireAt, expireAt, remainTimeToLive

Methods inherited from interface org.redisson.api.RObject

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

Methods inherited from interface org.redisson.api.RMapAsync

addAndGetAsync, containsKeyAsync, containsValueAsync, fastPutAsync, fastPutIfAbsentAsync, fastRemoveAsync, fastReplaceAsync, getAllAsync, getAsync, loadAllAsync, loadAllAsync, putAllAsync, putAllAsync, putAsync, putIfAbsentAsync, readAllEntrySetAsync, readAllKeySetAsync, readAllMapAsync, readAllValuesAsync, removeAsync, removeAsync, replaceAsync, replaceAsync, sizeAsync, valueSizeAsync

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, isExistsAsync, migrateAsync, moveAsync, removeListenerAsync, renameAsync, renamenxAsync, restoreAndReplaceAsync, restoreAndReplaceAsync, restoreAsync, restoreAsync, sizeInMemoryAsync, touchAsync, unlinkAsync

Method Detail

loadAll

void loadAll(boolean replaceExistingValues,
             int parallelism)

Loads all map entries to this Redis map using MapLoader.

Parameters:

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

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

loadAll

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

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

Parameters:

keys - - map keys

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

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

get

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.

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>

Parameters:

key - the key whose associated value is to be returned

Returns:

the value to which the specified key is mapped, or null if this map contains no mapping for the key

put

V put(K key,
      V value)

Associates the specified value with the specified key in async manner.

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

Specified by:

put in interface Map<K,V>

Parameters:

key - - map key

value - - map value

Returns:

previous associated value

putIfAbsent

V putIfAbsent(K key,
              V value)

Associates the specified value 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.

Specified by:

putIfAbsent in interface ConcurrentMap<K,V>

Specified by:

putIfAbsent in interface Map<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.

mapReduce

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

Returns RMapReduce object associated with this map

Type Parameters:

KOut - output key

VOut - output value

Returns:

MapReduce instance

getCountDownLatch

RCountDownLatch getCountDownLatch(K key)

Returns RCountDownLatch instance associated with key

Parameters:

key - - map key

Returns:

countdownlatch

getPermitExpirableSemaphore

RPermitExpirableSemaphore getPermitExpirableSemaphore(K key)

Returns RPermitExpirableSemaphore instance associated with key

Parameters:

key - - map key

Returns:

permitExpirableSemaphore

getSemaphore

RSemaphore getSemaphore(K key)

Returns RSemaphore instance associated with key

Parameters:

key - - map key

Returns:

semaphore

getFairLock

RLock getFairLock(K key)

Returns RLock instance associated with key

Parameters:

key - - map key

Returns:

fairlock

getReadWriteLock

RReadWriteLock getReadWriteLock(K key)

Returns RReadWriteLock instance associated with key

Parameters:

key - - map key

Returns:

readWriteLock

getLock

RLock getLock(K key)

Returns RLock instance associated with key

Parameters:

key - - map key

Returns:

lock

valueSize

int valueSize(K key)

Returns size of value mapped by key in bytes

Parameters:

key - - map key

Returns:

size of value

addAndGet

V addAndGet(K key,
            Number delta)

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

Parameters:

key - - map key

delta - the value to add

Returns:

the updated value

remove

V remove(Object key)

Removes key from map and returns associated value in async manner.

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

Specified by:

remove in interface Map<K,V>

Parameters:

key - - map key

Returns:

deleted value, null if there wasn't any association

replace

V replace(K key,
          V value)

Replaces previous value with a new value 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.

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

Parameters:

key - - map key

value - - map value

Returns:

previous associated value or null if there wasn't any association and change hasn't been made

replace

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

Replaces previous oldValue 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.

Specified by:

replace in interface ConcurrentMap<K,V>

Specified by:

replace in interface Map<K,V>

Parameters:

key - - map key

oldValue - - map old value

newValue - - map new value

Returns:

true if value has been replaced otherwise false.

remove

boolean remove(Object key,
               Object value)

Removes key from map only if it associated with 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>

Parameters:

key - - map key

value - - map value

Returns:

true if map entry has been replaced otherwise false.

putAll

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

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 Map<K,V>

Parameters:

map - mappings to be stored in this map

putAll

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

Associates the specified value with the specified key in batch. Batch inserted by chunks limited by batchSize amount to avoid OOM and/or Redis response timeout error for map with big size.

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

Parameters:

map - mappings to be stored in this map

batchSize - - map chunk size

getAll

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

Gets a map slice contained the mappings with defined keys 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.

Parameters:

keys - - map keys

Returns:

Map slice

fastRemove

long fastRemove(K... keys)

Removes keys from map by one operation

Works faster than remove(Object) but not returning the value associated with key

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

Parameters:

keys - - map keys

Returns:

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

fastPut

boolean fastPut(K key,
                V value)

Associates the specified value with the specified key.

Works faster than put(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.

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.

fastReplace

boolean fastReplace(K key,
                    V value)

Replaces previous value with a new value associated with the key.

Works faster than replace(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.

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.

fastPutIfAbsent

boolean fastPutIfAbsent(K key,
                        V value)

Associates the specified value with the specified key only if there is no any association with specifiedkey.

Works faster than 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.

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.

readAllKeySet

Set<K> readAllKeySet()

Read all keys at once

Returns:

keys

readAllValues

Collection<V> readAllValues()

Read all values at once

Returns:

values

readAllEntrySet

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

Read all map entries at once

Returns:

entries

readAllMap

Map<K,V> readAllMap()

Read all map as local instance at once

Returns:

map

keySet

Set<K> keySet()

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

Specified by:

keySet in interface Map<K,V>

Returns:

key set

See Also:

readAllKeySet()

keySet

Set<K> keySet(int count)

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

Parameters:

count - - size of keys batch

Returns:

key set

See Also:

readAllKeySet()

keySet

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

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

Parameters:

pattern - - key pattern

count - - size of keys batch

Returns:

key set

See Also:

readAllKeySet()

keySet

Set<K> keySet(String pattern)

Returns key set of this map. If pattern is not null then only keys match 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

Parameters:

pattern - - key pattern

Returns:

key set

See Also:

readAllKeySet()

values

Collection<V> values()

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

Specified by:

values in interface Map<K,V>

Returns:

values collection

See Also:

readAllValues()

values

Collection<V> values(String keyPattern)

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

Parameters:

keyPattern - - key pattern

Returns:

values collection

See Also:

readAllValues()

values

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

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

Parameters:

keyPattern - - key pattern

count - - size of values batch

Returns:

values collection

See Also:

readAllValues()

values

Collection<V> values(int count)

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

Parameters:

count - - size of values batch

Returns:

values collection

See Also:

readAllValues()

entrySet

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

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

Specified by:

entrySet in interface Map<K,V>

Returns:

map entries collection

See Also:

readAllEntrySet()

entrySet

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

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

Parameters:

keyPattern - - key pattern

Returns:

map entries collection

See Also:

readAllEntrySet()

entrySet

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

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

Parameters:

keyPattern - - key pattern

count - - size of entries batch

Returns:

map entries collection

See Also:

readAllEntrySet()

entrySet

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

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

Parameters:

count - - size of entries batch

Returns:

map entries collection

See Also:

readAllEntrySet()