DefaultRedisMap (Spring Data Redis 2.4.9 API)

java.lang.Object
- org.springframework.data.redis.support.collections.DefaultRedisMap<K,V>

All Implemented Interfaces:

ConcurrentMap<K,V>, Map<K,V>, BoundKeyOperations<String>, RedisMap<K,V>, RedisStore
```
public class DefaultRedisMap<K,V>
extends Object
implements RedisMap<K,V>
```
Default implementation for RedisMap. Note that the current implementation doesn't provide the same locking semantics across all methods. In highly concurrent environments, race conditions might appear.

Author:

Costin Leau, Christoph Strobl, Christian Bühler

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

Constructor Summary

Constructors
Constructor and Description
`DefaultRedisMap(BoundHashOperations<String,K,V> boundOps)` Constructs a new `DefaultRedisMap` instance.
`DefaultRedisMap(String key, RedisOperations<String,?> operations)` Constructs a new `DefaultRedisMap` instance.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`boolean`	`containsKey(Object key)`
`boolean`	`containsValue(Object value)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`boolean`	`equals(Object o)`
`Boolean`	`expire(long timeout, TimeUnit unit)` Sets the key time-to-live/expiration.
`Boolean`	`expireAt(Date date)` Sets the key time-to-live/expiration.
`V`	`get(Object key)`
`Long`	`getExpire()` Returns the expiration of this key.
`String`	`getKey()` Returns the key associated with this entity.
`RedisOperations<String,?>`	`getOperations()` Returns the underlying Redis operations used by the backing implementation.
`DataType`	`getType()` Returns the associated Redis type.
`int`	`hashCode()`
`Double`	`increment(K key, double delta)`
`Long`	`increment(K key, long delta)`
`boolean`	`isEmpty()`
`Set<K>`	`keySet()`
`Boolean`	`persist()` Removes the expiration (if any) of the key.
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> m)`
`V`	`putIfAbsent(K key, V value)`
`V`	`remove(Object key)`
`boolean`	`remove(Object key, Object value)`
`void`	`rename(String newKey)` Renames the key.
`V`	`replace(K key, V value)`
`boolean`	`replace(K key, V oldValue, V newValue)`
`Cursor<Map.Entry<K,V>>`	`scan()`
`int`	`size()`
`String`	`toString()`
`Collection<V>`	`values()`

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

Methods inherited from interface org.springframework.data.redis.core.BoundKeyOperations
expire, expireAt

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

- Constructor Detail
  - DefaultRedisMap
```
public DefaultRedisMap(String key,
                       RedisOperations<String,?> operations)
```
    Constructs a new DefaultRedisMap instance.
    
    Parameters:
    
    key - Redis key of this map.
    
    operations - RedisOperations for this map.
    
    See Also:
    
    RedisOperations.getHashKeySerializer(), RedisOperations.getValueSerializer()
  - DefaultRedisMap
```
public DefaultRedisMap(BoundHashOperations<String,K,V> boundOps)
```
    Constructs a new DefaultRedisMap instance.
    
    Parameters:
    
    boundOps - BoundHashOperations for this map.
- Method Detail
  - increment
```
public Long increment(K key,
                      long delta)
```
    Specified by:
    
    increment in interface RedisMap<K,V>
  - increment
```
public Double increment(K key,
                        double delta)
```
    Specified by:
    
    increment in interface RedisMap<K,V>
  - getOperations
```
public RedisOperations<String,?> getOperations()
```
    Description copied from interface: RedisStore
    
    Returns the underlying Redis operations used by the backing implementation.
    
    Specified by:
    
    getOperations in interface RedisStore
    
    Returns:
    
    operations never null.
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>
  - get
```
@Nullable
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> m)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - remove
```
@Nullable
public V remove(Object key)
```
    Specified by:
    
    remove in interface Map<K,V>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Map<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
  - 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
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - putIfAbsent
```
@Nullable
public V putIfAbsent(K key,
                               V value)
```
    Specified by:
    
    putIfAbsent in interface ConcurrentMap<K,V>
    
    Specified by:
    
    putIfAbsent in interface Map<K,V>
  - remove
```
public boolean remove(Object key,
                      Object value)
```
    Specified by:
    
    remove in interface ConcurrentMap<K,V>
    
    Specified by:
    
    remove in interface Map<K,V>
  - replace
```
public boolean replace(K key,
                       V oldValue,
                       V newValue)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - replace
```
@Nullable
public V replace(K key,
                           V value)
```
    Specified by:
    
    replace in interface ConcurrentMap<K,V>
    
    Specified by:
    
    replace in interface Map<K,V>
  - expire
```
public Boolean expire(long timeout,
                      TimeUnit unit)
```
    Description copied from interface: BoundKeyOperations
    
    Sets the key time-to-live/expiration.
    
    Specified by:
    
    expire in interface BoundKeyOperations<String>
    
    Parameters:
    
    timeout - expiration value
    
    unit - expiration unit
    
    Returns:
    
    true if expiration was set, false otherwise. null when used in pipeline / transaction.
  - expireAt
```
public Boolean expireAt(Date date)
```
    Description copied from interface: BoundKeyOperations
    
    Sets the key time-to-live/expiration.
    
    Specified by:
    
    expireAt in interface BoundKeyOperations<String>
    
    Parameters:
    
    date - expiration date
    
    Returns:
    
    true if expiration was set, false otherwise. null when used in pipeline / transaction.
  - getExpire
```
public Long getExpire()
```
    Description copied from interface: BoundKeyOperations
    
    Returns the expiration of this key.
    
    Specified by:
    
    getExpire in interface BoundKeyOperations<String>
    
    Returns:
    
    expiration value (in seconds). null when used in pipeline / transaction.
  - persist
```
public Boolean persist()
```
    Description copied from interface: BoundKeyOperations
    
    Removes the expiration (if any) of the key.
    
    Specified by:
    
    persist in interface BoundKeyOperations<String>
    
    Returns:
    
    true if expiration was removed, false otherwise. null when used in pipeline / transaction.
  - getKey
```
public String getKey()
```
    Description copied from interface: BoundKeyOperations
    
    Returns the key associated with this entity.
    
    Specified by:
    
    getKey in interface BoundKeyOperations<String>
    
    Returns:
    
    key associated with the implementing entity
  - rename
```
public void rename(String newKey)
```
    Description copied from interface: BoundKeyOperations
    
    Renames the key.
    Note: The new name for empty collections will be propagated on add of first element.
    
    Specified by:
    
    rename in interface BoundKeyOperations<String>
    
    Parameters:
    
    newKey - new key. Must not be null.
  - getType
```
public DataType getType()
```
    Description copied from interface: BoundKeyOperations
    
    Returns the associated Redis type.
    
    Specified by:
    
    getType in interface BoundKeyOperations<String>
    
    Returns:
    
    key type. null when used in pipeline / transaction.
  - scan
```
public Cursor<Map.Entry<K,V>> scan()
```
    Specified by:
    
    scan in interface RedisMap<K,V>
    
    Returns:

Class DefaultRedisMap<K,V>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.springframework.data.redis.core.BoundKeyOperations

Methods inherited from interface java.util.concurrent.ConcurrentMap

Constructor Detail

DefaultRedisMap

DefaultRedisMap

Method Detail

increment

increment

getOperations

clear

containsKey

containsValue

entrySet

get

isEmpty

keySet

put

putAll

remove

size

values

equals

hashCode

toString

putIfAbsent

remove

replace

replace

expire

expireAt

getExpire

persist

getKey

rename

getType

scan