org.redisson.reactive

Class RedissonMapCacheReactive<K,V>

java.lang.Object

org.redisson.reactive.RedissonMapCacheReactive<K,V>

Type Parameters:

K - key

V - value

All Implemented Interfaces:

RExpirableReactive, RMapCacheReactive<K,V>, RMapReactive<K,V>, RObjectReactive

public class RedissonMapCacheReactive<K,V>
extends Object
implements RMapCacheReactive<K,V>

Map-based cache with ability to set TTL for each entry via put(Object, Object, long, TimeUnit) or putIfAbsent(Object, Object, long, TimeUnit) method. And therefore has an complex lua-scripts inside.

Current redis implementation doesnt have map entry eviction functionality. Thus entries are checked for TTL expiration during any key/value/entry read operation. If key/value/entry expired then it doesn't returns and clean task runs asynchronous. Clean task deletes removes 100 expired entries at once. In addition there is EvictionScheduler. This scheduler deletes expired entries in time interval between 5 seconds to 2 hours.

If eviction is not required then it's better to use RedissonMapReactive.

Author:

Nikita Koksharov

Constructor Summary

Constructors

Constructor and Description
RedissonMapCacheReactive(EvictionScheduler evictionScheduler, Codec codec, CommandReactiveExecutor commandExecutor, String name, MapOptions<K,V> options)
RedissonMapCacheReactive(EvictionScheduler evictionScheduler, CommandReactiveExecutor commandExecutor, String name, MapOptions<K,V> options)

Method Summary

Modifier and Type	Method and Description
org.reactivestreams.Publisher<V>	addAndGet(K key, Number delta)
org.reactivestreams.Publisher<Boolean>	clearExpire() Clear an expire timeout or expire date for object in mode.
org.reactivestreams.Publisher<Boolean>	containsKey(Object key)
org.reactivestreams.Publisher<Boolean>	containsValue(Object value)
org.reactivestreams.Publisher<Boolean>	delete() Delete object in mode
protected byte[]	encode(Object value)
protected byte[]	encodeMapKey(Object value)
protected byte[]	encodeMapValue(Object value)
org.reactivestreams.Publisher<Map.Entry<K,V>>	entryIterator()
boolean	equals(Object o)
org.reactivestreams.Publisher<Boolean>	expire(long timeToLive, TimeUnit timeUnit) Set a timeout for object in mode.
org.reactivestreams.Publisher<Boolean>	expireAt(Date timestamp) Set an expire date for object in mode.
org.reactivestreams.Publisher<Boolean>	expireAt(long timestamp) Set an expire date for object in mode.
org.reactivestreams.Publisher<Boolean>	fastPut(K key, V value) Associates the specified value with the specified key in async manner.
org.reactivestreams.Publisher<Boolean>	fastPut(K key, V value, long ttl, TimeUnit unit) Stores value mapped by key with specified time to live.
org.reactivestreams.Publisher<Boolean>	fastPut(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit) Stores value mapped by key with specified time to live and max idle time.
org.reactivestreams.Publisher<Boolean>	fastPutIfAbsent(K key, V value) Associates the specified value with the specified key only if there is no any association with specifiedkey.
org.reactivestreams.Publisher<Boolean>	fastPutIfAbsent(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit) If the specified key is not already associated with a value, associate it with the given value.
org.reactivestreams.Publisher<Long>	fastRemove(K... keys) Removes keys from map by one operation in async manner.
org.reactivestreams.Publisher<V>	get(K key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
org.reactivestreams.Publisher<Map<K,V>>	getAll(Set<K> keys) Gets a map slice contained the mappings with defined keys by one operation.
Codec	getCodec()
String	getName()
int	hashCode()
org.reactivestreams.Publisher<Boolean>	isExists() Check object existence
org.reactivestreams.Publisher<K>	keyIterator()
org.reactivestreams.Publisher<Void>	loadAll(boolean replaceExistingValues, int parallelism) Loads all map entries to this Redis map.
org.reactivestreams.Publisher<Void>	loadAll(Set<? extends K> keys, boolean replaceExistingValues, int parallelism) Loads map entries whose keys are listed in defined keys parameter.
org.reactivestreams.Publisher<Void>	migrate(String host, int port, int database) Transfer a object from a source Redis instance to a destination Redis instance in mode
org.reactivestreams.Publisher<Boolean>	move(int database) Move object to another database in mode
protected <V> reactor.rx.Stream<V>	newSucceeded(V result)
org.reactivestreams.Publisher<V>	put(K key, V value) Associates the specified value with the specified key in async manner.
org.reactivestreams.Publisher<V>	put(K key, V value, long ttl, TimeUnit unit) Stores value mapped by key with specified time to live.
org.reactivestreams.Publisher<V>	put(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit) Stores value mapped by key with specified time to live and max idle time.
org.reactivestreams.Publisher<Void>	putAll(Map<? extends K,? extends V> map) Associates the specified value with the specified key in batch.
org.reactivestreams.Publisher<V>	putIfAbsent(K key, V value) Associates the specified value with the specified key only if there is no any association with specifiedkey.
org.reactivestreams.Publisher<V>	putIfAbsent(K key, V value, long ttl, TimeUnit unit) If the specified key is not already associated with a value, associate it with the given value.
org.reactivestreams.Publisher<V>	putIfAbsent(K key, V value, long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit) If the specified key is not already associated with a value, associate it with the given value.
<R> org.reactivestreams.Publisher<R>	reactive(reactor.fn.Supplier<RFuture<R>> supplier)
org.reactivestreams.Publisher<Set<Map.Entry<K,V>>>	readAllEntrySet() Read all map entries at once
org.reactivestreams.Publisher<Set<K>>	readAllKeySet() Read all keys at once
org.reactivestreams.Publisher<Map<K,V>>	readAllMap() Read all map as local instance at once
org.reactivestreams.Publisher<Collection<V>>	readAllValues() Read all values at once
org.reactivestreams.Publisher<Long>	remainTimeToLive() Get remaining time to live of object in milliseconds.
org.reactivestreams.Publisher<V>	remove(K key) Removes key from map and returns associated value in async manner.
org.reactivestreams.Publisher<Boolean>	remove(Object key, Object value) Removes key from map only if it associated with value.
org.reactivestreams.Publisher<Void>	rename(String newName) Rename current object key to newName in mode
org.reactivestreams.Publisher<Boolean>	renamenx(String newName) Rename current object key to newName in mode only if new key is not exists
org.reactivestreams.Publisher<V>	replace(K key, V value) Replaces previous value with a new value associated with the key.
org.reactivestreams.Publisher<Boolean>	replace(K key, V oldValue, V newValue) Replaces previous oldValue with a newValue associated with the key.
org.reactivestreams.Publisher<MapScanResult<ScanObjectEntry,ScanObjectEntry>>	scanIteratorReactive(InetSocketAddress client, long startPos)
org.reactivestreams.Publisher<Integer>	size() Returns the number of entries in cache.
org.reactivestreams.Publisher<V>	valueIterator()
org.reactivestreams.Publisher<Integer>	valueSize(K key) Returns size of value mapped by key in bytes

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.redisson.api.RExpirableReactive

expireAt, remainTimeToLive

Methods inherited from interface org.redisson.api.RObjectReactive

getCodec, getName, isExists, migrate, move, rename, renamenx

Constructor Detail

RedissonMapCacheReactive

public RedissonMapCacheReactive(EvictionScheduler evictionScheduler,
                                CommandReactiveExecutor commandExecutor,
                                String name,
                                MapOptions<K,V> options)

RedissonMapCacheReactive

public RedissonMapCacheReactive(EvictionScheduler evictionScheduler,
                                Codec codec,
                                CommandReactiveExecutor commandExecutor,
                                String name,
                                MapOptions<K,V> options)

Method Detail

containsKey

public org.reactivestreams.Publisher<Boolean> containsKey(Object key)

Specified by:

containsKey in interface RMapReactive<K,V>

containsValue

public org.reactivestreams.Publisher<Boolean> containsValue(Object value)

Specified by:

containsValue in interface RMapReactive<K,V>

getAll

public org.reactivestreams.Publisher<Map<K,V>> getAll(Set<K> keys)

Description copied from interface: RMapReactive

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.

Specified by:

getAll in interface RMapReactive<K,V>

Parameters:

keys - - map keys

Returns:

Map slice

putIfAbsent

public org.reactivestreams.Publisher<V> putIfAbsent(K key,
                                                    V value,
                                                    long ttl,
                                                    TimeUnit unit)

Description copied from interface: RMapCacheReactive

If the specified key is not already associated with a value, associate it with the given value.

Stores value mapped by key with specified time to live. Entry expires after specified time to live. If the map previously contained a mapping for the key, the old value is replaced by the specified value.

Specified by:

putIfAbsent in interface RMapCacheReactive<K,V>

Parameters:

key - - map key

value - - map value

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

unit - - time unit

Returns:

previous associated value

remove

public org.reactivestreams.Publisher<Boolean> remove(Object key,
                                                     Object value)

Description copied from interface: RMapReactive

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

Parameters:

key - - map key

value - - map value

Returns:

true if map entry has been replaced otherwise false.

get

public org.reactivestreams.Publisher<V> get(K key)

Description copied from interface: RMapReactive

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

public org.reactivestreams.Publisher<V> put(K key,
                                            V value,
                                            long ttl,
                                            TimeUnit unit)

Description copied from interface: RMapCacheReactive

Stores value mapped by key with specified time to live. Entry expires after specified time to live. If the map previously contained a mapping for the key, the old value is replaced by the specified value.

Specified by:

put in interface RMapCacheReactive<K,V>

Parameters:

key - - map key

value - - map value

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

unit - - time unit

Returns:

previous associated value

remove

public org.reactivestreams.Publisher<V> remove(K key)

Description copied from interface: RMapReactive

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

Parameters:

key - - map key

Returns:

deleted value or null if there wasn't any association

fastRemove

public org.reactivestreams.Publisher<Long> fastRemove(K... keys)

Description copied from interface: RMapReactive

Removes keys from map by one operation in async manner.

Works faster than RMapReactive.remove(Object, Object) but doesn't return the value associated with key.

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

Specified by:

fastRemove in interface RMapReactive<K,V>

Parameters:

keys - - map keys

Returns:

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

scanIteratorReactive

public org.reactivestreams.Publisher<MapScanResult<ScanObjectEntry,ScanObjectEntry>> scanIteratorReactive(InetSocketAddress client,
                                                                                                          long startPos)

delete

public org.reactivestreams.Publisher<Boolean> delete()

Description copied from interface: RObjectReactive

Delete object in mode

Specified by:

delete in interface RObjectReactive

Returns:

true if object was deleted false if not

expire

public org.reactivestreams.Publisher<Boolean> expire(long timeToLive,
                                                     TimeUnit timeUnit)

Description copied from interface: RExpirableReactive

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

Specified by:

expire in interface RExpirableReactive

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 org.reactivestreams.Publisher<Boolean> expireAt(long timestamp)

Description copied from interface: RExpirableReactive

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

Specified by:

expireAt in interface RExpirableReactive

Parameters:

timestamp - - expire date in milliseconds (Unix timestamp)

Returns:

true if the timeout was set and false if not

clearExpire

public org.reactivestreams.Publisher<Boolean> clearExpire()

Description copied from interface: RExpirableReactive

Clear an expire timeout or expire date for object in mode. Object will not be deleted.

Specified by:

clearExpire in interface RExpirableReactive

Returns:

true if the timeout was cleared and false if not

putAll

public org.reactivestreams.Publisher<Void> putAll(Map<? extends K,? extends V> map)

Description copied from interface: RMapReactive

Associates the specified value with the specified key in batch.

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

Specified by:

putAll in interface RMapReactive<K,V>

Parameters:

map - mappings to be stored in this map

Returns:

void

addAndGet

public org.reactivestreams.Publisher<V> addAndGet(K key,
                                                  Number delta)

Specified by:

addAndGet in interface RMapReactive<K,V>

fastPut

public org.reactivestreams.Publisher<Boolean> fastPut(K key,
                                                      V value)

Description copied from interface: RMapReactive

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

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

Specified by:

fastPut in interface RMapReactive<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 the value was updated.

put

public org.reactivestreams.Publisher<V> put(K key,
                                            V value)

Description copied from interface: RMapReactive

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

Parameters:

key - - map key

value - - map value

Returns:

previous associated value

replace

public org.reactivestreams.Publisher<V> replace(K key,
                                                V value)

Description copied from interface: RMapReactive

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

public org.reactivestreams.Publisher<Boolean> replace(K key,
                                                      V oldValue,
                                                      V newValue)

Description copied from interface: RMapReactive

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

Parameters:

key - - map key

oldValue - - map old value

newValue - - map new value

Returns:

true if value has been replaced otherwise false.

putIfAbsent

public org.reactivestreams.Publisher<V> putIfAbsent(K key,
                                                    V value)

Description copied from interface: RMapReactive

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

entryIterator

public org.reactivestreams.Publisher<Map.Entry<K,V>> entryIterator()

Specified by:

entryIterator in interface RMapReactive<K,V>

valueIterator

public org.reactivestreams.Publisher<V> valueIterator()

Specified by:

valueIterator in interface RMapReactive<K,V>

keyIterator

public org.reactivestreams.Publisher<K> keyIterator()

Specified by:

keyIterator in interface RMapReactive<K,V>

size

public org.reactivestreams.Publisher<Integer> size()

Description copied from interface: RMapCacheReactive

Returns the number of entries in cache. This number can reflects expired entries too due to non realtime cleanup process.

Specified by:

size in interface RMapCacheReactive<K,V>

Specified by:

size in interface RMapReactive<K,V>

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

loadAll

public org.reactivestreams.Publisher<Void> loadAll(boolean replaceExistingValues,
                                                   int parallelism)

Description copied from interface: RMapReactive

Loads all map entries to this Redis map.

Specified by:

loadAll in interface RMapReactive<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 org.reactivestreams.Publisher<Void> loadAll(Set<? extends K> keys,
                                                   boolean replaceExistingValues,
                                                   int parallelism)

Description copied from interface: RMapReactive

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

Specified by:

loadAll in interface RMapReactive<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

valueSize

public org.reactivestreams.Publisher<Integer> valueSize(K key)

Description copied from interface: RMapReactive

Returns size of value mapped by key in bytes

Specified by:

valueSize in interface RMapReactive<K,V>

Parameters:

key - - map key

Returns:

size of value

fastPutIfAbsent

public org.reactivestreams.Publisher<Boolean> fastPutIfAbsent(K key,
                                                              V value)

Description copied from interface: RMapReactive

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

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

readAllKeySet

public org.reactivestreams.Publisher<Set<K>> readAllKeySet()

Description copied from interface: RMapReactive

Read all keys at once

Specified by:

readAllKeySet in interface RMapReactive<K,V>

Returns:

keys

readAllValues

public org.reactivestreams.Publisher<Collection<V>> readAllValues()

Description copied from interface: RMapReactive

Read all values at once

Specified by:

readAllValues in interface RMapReactive<K,V>

Returns:

values

readAllEntrySet

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

Description copied from interface: RMapReactive

Read all map entries at once

Specified by:

readAllEntrySet in interface RMapReactive<K,V>

Returns:

entries

readAllMap

public org.reactivestreams.Publisher<Map<K,V>> readAllMap()

Description copied from interface: RMapReactive

Read all map as local instance at once

Specified by:

readAllMap in interface RMapReactive<K,V>

Returns:

map

putIfAbsent

public org.reactivestreams.Publisher<V> putIfAbsent(K key,
                                                    V value,
                                                    long ttl,
                                                    TimeUnit ttlUnit,
                                                    long maxIdleTime,
                                                    TimeUnit maxIdleUnit)

Description copied from interface: RMapCacheReactive

If the specified key is not already associated with a value, associate it with the given value.

Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.

If the map previously contained a mapping for the key, the old value is replaced by the specified value.

Specified by:

putIfAbsent in interface RMapCacheReactive<K,V>

Parameters:

key - - map key

value - - map value

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

ttlUnit - - time unit

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

maxIdleUnit - - time unit

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

Returns:

previous associated value

put

public org.reactivestreams.Publisher<V> put(K key,
                                            V value,
                                            long ttl,
                                            TimeUnit ttlUnit,
                                            long maxIdleTime,
                                            TimeUnit maxIdleUnit)

Description copied from interface: RMapCacheReactive

Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.

If the map previously contained a mapping for the key, the old value is replaced by the specified value.

Specified by:

put in interface RMapCacheReactive<K,V>

Parameters:

key - - map key

value - - map value

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

ttlUnit - - time unit

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

maxIdleUnit - - time unit

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

Returns:

previous associated value

fastPut

public org.reactivestreams.Publisher<Boolean> fastPut(K key,
                                                      V value,
                                                      long ttl,
                                                      TimeUnit unit)

Description copied from interface: RMapCacheReactive

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

If the map previously contained a mapping for the key, the old value is replaced by the specified value.

Works faster than usual RMapCacheReactive.put(Object, Object, long, TimeUnit) as it not returns previous value.

Specified by:

fastPut in interface RMapCacheReactive<K,V>

Parameters:

key - - map key

value - - map value

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

unit - - time unit

Returns:

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

fastPut

public org.reactivestreams.Publisher<Boolean> fastPut(K key,
                                                      V value,
                                                      long ttl,
                                                      TimeUnit ttlUnit,
                                                      long maxIdleTime,
                                                      TimeUnit maxIdleUnit)

Description copied from interface: RMapCacheReactive

Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.

If the map previously contained a mapping for the key, the old value is replaced by the specified value.

Works faster than usual RMapCacheReactive.put(Object, Object, long, TimeUnit, long, TimeUnit) as it not returns previous value.

Specified by:

fastPut in interface RMapCacheReactive<K,V>

Parameters:

key - - map key

value - - map value

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

ttlUnit - - time unit

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

maxIdleUnit - - time unit

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

Returns:

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

fastPutIfAbsent

public org.reactivestreams.Publisher<Boolean> fastPutIfAbsent(K key,
                                                              V value,
                                                              long ttl,
                                                              TimeUnit ttlUnit,
                                                              long maxIdleTime,
                                                              TimeUnit maxIdleUnit)

Description copied from interface: RMapCacheReactive

If the specified key is not already associated with a value, associate it with the given value.

Stores value mapped by key with specified time to live and max idle time. Entry expires when specified time to live or max idle time has expired.

Works faster than usual RMapCacheReactive.putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit) as it not returns previous value.

Specified by:

fastPutIfAbsent in interface RMapCacheReactive<K,V>

Parameters:

key - - map key

value - - map value

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

ttlUnit - - time unit

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

maxIdleUnit - - time unit

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

Returns:

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

expireAt

public org.reactivestreams.Publisher<Boolean> expireAt(Date timestamp)

Description copied from interface: RExpirableReactive

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

Specified by:

expireAt in interface RExpirableReactive

Parameters:

timestamp - - expire date

Returns:

true if the timeout was set and false if not

remainTimeToLive

public org.reactivestreams.Publisher<Long> remainTimeToLive()

Description copied from interface: RExpirableReactive

Get remaining time to live of object in milliseconds.

Specified by:

remainTimeToLive in interface RExpirableReactive

Returns:

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

reactive

public <R> org.reactivestreams.Publisher<R> reactive(reactor.fn.Supplier<RFuture<R>> supplier)

newSucceeded

protected <V> reactor.rx.Stream<V> newSucceeded(V result)

getName

public String getName()

Specified by:

getName in interface RObjectReactive

getCodec

public Codec getCodec()

Specified by:

getCodec in interface RObjectReactive

encode

protected byte[] encode(Object value)

encodeMapKey

protected byte[] encodeMapKey(Object value)

encodeMapValue

protected byte[] encodeMapValue(Object value)

rename

public org.reactivestreams.Publisher<Void> rename(String newName)

Description copied from interface: RObjectReactive

Rename current object key to newName in mode

Specified by:

rename in interface RObjectReactive

Parameters:

newName - - new name of object

Returns:

void

migrate

public org.reactivestreams.Publisher<Void> migrate(String host,
                                                   int port,
                                                   int database)

Description copied from interface: RObjectReactive

Transfer a object from a source Redis instance to a destination Redis instance in mode

Specified by:

migrate in interface RObjectReactive

Parameters:

host - - destination host

port - - destination port

database - - destination database

Returns:

void

move

public org.reactivestreams.Publisher<Boolean> move(int database)

Description copied from interface: RObjectReactive

Move object to another database in mode

Specified by:

move in interface RObjectReactive

Parameters:

database - - number of Redis database

Returns:

true if key was moved false if not

renamenx

public org.reactivestreams.Publisher<Boolean> renamenx(String newName)

Description copied from interface: RObjectReactive

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

Specified by:

renamenx in interface RObjectReactive

Parameters:

newName - - new name of object

Returns:

true if object has been renamed successfully and false otherwise

isExists

public org.reactivestreams.Publisher<Boolean> isExists()

Description copied from interface: RObjectReactive

Check object existence

Specified by:

isExists in interface RObjectReactive

Returns:

true if object exists and false otherwise