org.redisson.api.RMapReactive Maven / Gradle / Ivy
Show all versions of redisson-all Show documentation
/**
* Copyright (c) 2013-2024 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.api;
import org.redisson.api.map.MapLoader;
import org.redisson.api.map.MapWriter;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.Collection;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Function;
/**
* Reactive interface for Redis based implementation
* of {@link java.util.concurrent.ConcurrentMap} and {@link java.util.Map}
*
* This map uses serialized state of key instead of hashCode or equals methods.
* This map doesn't allow to store null as key or value.
*
* @author Nikita Koksharov
*
* @param key
* @param value
*/
public interface RMapReactive extends RExpirableReactive {
/**
* 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 {@code null}.
*
* @param key - map key
* @param value - value to be merged with the existing value
* associated with the key or to be associated with the key,
* if no existing value
* @param remappingFunction - the function is invoked with the existing value to compute new value
* @return new value associated with the specified key or
* {@code null} if no value associated with the key
*/
Mono merge(K key, V value, BiFunction remappingFunction);
/**
* Computes a new mapping for the specified key and its current mapped value.
*
* @param key - map key
* @param remappingFunction - function to compute a value
* @return the new value associated with the specified key, or {@code null} if none
*/
Mono compute(K key, BiFunction remappingFunction);
/**
* Computes a mapping for the specified key if it's not mapped before.
*
* @param key - map key
* @param mappingFunction - function to compute a value
* @return current or new computed value associated with
* the specified key, or {@code null} if the computed value is null
*/
Mono computeIfAbsent(K key, Function mappingFunction);
/**
* Computes a mapping for the specified key only if it's already mapped.
*
* @param key - map key
* @param remappingFunction - function to compute a value
* @return the new value associated with the specified key, or null if none
*/
Mono computeIfPresent(K key, BiFunction remappingFunction);
/**
* Loads all map entries to this Redis map using {@link org.redisson.api.map.MapLoader}.
*
* @param replaceExistingValues - true if existed values should be replaced, false otherwise.
* @param parallelism - parallelism level, used to increase speed of process execution
* @return void
*/
Mono loadAll(boolean replaceExistingValues, int parallelism);
/**
* Loads map entries using {@link org.redisson.api.map.MapLoader} whose keys are listed in defined keys parameter.
*
* @param keys - map keys
* @param replaceExistingValues - true if existed values should be replaced, false otherwise.
* @param parallelism - parallelism level, used to increase speed of process execution
* @return void
*/
Mono loadAll(Set keys, boolean replaceExistingValues, int parallelism);
/**
* Returns size of value mapped by key in bytes
*
* @param key - map key
* @return size of value
*/
Mono valueSize(K key);
/**
* Returns map slice contained the mappings with defined keys.
*
* If map doesn't contain value/values for specified key/keys and {@link MapLoader} is defined
* then value/values will be loaded in read-through mode.
*
* The returned map is NOT backed by the original map.
*
* @param keys - map keys
* @return Map slice
*/
Mono> getAll(Set keys);
/**
* Stores map entries specified in map object in batch mode.
*
* If {@link MapWriter} is defined then map entries will be stored in write-through mode.
*
* @param map mappings to be stored in this map
* @return void
*/
Mono putAll(Map map);
/**
* Adds the given delta to the current value
* by mapped key.
*
* Works only with codecs below
*
* {@link org.redisson.codec.JsonJacksonCodec},
*
* {@link org.redisson.client.codec.StringCodec},
*
* {@link org.redisson.client.codec.IntegerCodec},
*
* {@link org.redisson.client.codec.DoubleCodec}
*
* {@link org.redisson.client.codec.LongCodec}
*
* @param key - map key
* @param delta the value to add
* @return the updated value
*/
Mono addAndGet(K key, Number delta);
/**
* Returns true if this map contains any map entry
* with specified value, otherwise false
*
* @param value - map value
* @return true if this map contains any map entry
* with specified value, otherwise false
*/
Mono containsValue(Object value);
/**
* Returns true if this map contains map entry
* mapped by specified key, otherwise false
*
* @param key - map key
* @return true if this map contains map entry
* mapped by specified key, otherwise false
*/
Mono containsKey(Object key);
/**
* Returns size of this map
*
* @return size
*/
Mono size();
/**
* Removes map entries mapped by specified keys.
*
* Works faster than {@link #remove(Object)} but not returning
* the value.
*
* If {@link MapWriter} is defined then keysare deleted in write-through mode.
*
* @param keys - map keys
* @return the number of keys that were removed from the hash, not including specified but non existing keys
*/
Mono fastRemove(K... keys);
/**
* Stores the specified value mapped by specified key.
*
* Works faster than {@link #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 {@link MapWriter} is defined then map entry is stored in write-through mode.
*
* @param key - map key
* @param value - map value
* @return 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.
*/
Mono fastPut(K key, V value);
/**
* 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 {@link #putIfAbsent(Object, Object)} but not returning
* the previous value associated with key
*
* If {@link MapWriter} is defined then new map entry is stored in write-through mode.
*
* @param key - map key
* @param value - map value
* @return 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.
*/
Mono fastPutIfAbsent(K key, V value);
/**
* Read all keys at once
*
* @return keys
*/
Mono> readAllKeySet();
/**
* Read all values at once
*
* @return values
*/
Mono> readAllValues();
/**
* Read all map entries at once
*
* @return entries
*/
Mono>> readAllEntrySet();
/**
* Read all map as local instance at once
*
* @return map
*/
Mono> readAllMap();
/**
* Returns the value mapped by defined key or {@code null} if value is absent.
*
* If map doesn't contain value for specified key and {@link MapLoader} is defined
* then value will be loaded in read-through mode.
*
* @param key the key
* @return the value mapped by defined key or {@code null} if value is absent
*/
Mono get(K key);
/**
* Stores the specified value mapped by specified key.
* Returns previous value if map entry with specified key already existed.
*
* If {@link MapWriter} is defined then map entry is stored in write-through mode.
*
* @param key - map key
* @param value - map value
* @return previous associated value
*/
Mono put(K key, V value);
/**
* Removes map entry by specified key and returns value.
*
* If {@link MapWriter} is defined then keyis deleted in write-through mode.
*
* @param key - map key
* @return deleted value, null if map entry doesn't exist
*/
Mono remove(K key);
/**
* 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 {@link MapWriter} is defined then new valueis written in write-through mode.
*
* @param key - map key
* @param value - map value
* @return previous associated value
* or null if there is no map entry stored before and doesn't store new map entry
*/
Mono replace(K key, V value);
/**
* Replaces previous oldValue with a newValue mapped by specified key.
* Returns false if previous value doesn't exist or equal to oldValue.
*
* If {@link MapWriter} is defined then newValueis written in write-through mode.
*
* @param key - map key
* @param oldValue - map old value
* @param newValue - map new value
* @return true if value has been replaced otherwise false.
*/
Mono replace(K key, V oldValue, V newValue);
/**
* Removes map entry only if it exists with specified key and value.
*
* If {@link MapWriter} is defined then keyis deleted in write-through mode.
*
* @param key - map key
* @param value - map value
* @return true if map entry has been removed otherwise false.
*/
Mono remove(Object key, Object value);
/**
* Stores the specified value mapped by specified key
* only if there is no value with specifiedkey stored before.
*
* If {@link MapWriter} is defined then new map entry is stored in write-through mode.
*
* @param key - map key
* @param value - map value
* @return 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.
*/
Mono putIfAbsent(K key, V value);
/**
* Stores the specified value mapped by key
* only if mapping already exists.
*
* If {@link MapWriter} is defined then new map entry is stored in write-through mode.
*
* @param key - map key
* @param value - map value
* @return null if key doesn't exist in the hash and value hasn't been set.
* Previous value if key already exists in the hash and new value has been stored.
*/
Mono putIfExists(K key, V value);
/**
* Returns random keys from this map limited by count
*
* @param count - keys amount to return
* @return random keys
*/
Mono> randomKeys(int count);
/**
* Returns random map entries from this map limited by count
*
* @param count - entries amount to return
* @return random entries
*/
Mono> randomEntries(int count);
/**
* Stores the specified value mapped by key
* only if mapping already exists.
*
* 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 {@link #putIfExists(Object, Object)} but doesn't return
* previous value associated with key
*
* If {@link MapWriter} is defined then new map entry is stored in write-through mode.
*
* @param key - map key
* @param value - map value
* @return true if key already exists in the hash and new value has been stored.
* false if key doesn't exist in the hash and value hasn't been set.
*/
Mono fastPutIfExists(K key, V value);
/**
* Returns iterator over map entries collection.
* Map entries are loaded in batch. Batch size is 10.
*
* @see #readAllEntrySet()
*
* @return iterator
*/
Flux> entryIterator();
/**
* Returns iterator over map entries collection.
* Map entries are loaded in batch. Batch size is defined by count param.
*
* @see #readAllEntrySet()
*
* @param count - size of entries batch
* @return iterator
*/
Flux> entryIterator(int count);
/**
* Returns iterator over 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.
*
* Use org.redisson.client.codec.StringCodec for Map keys.
*
* Usage example:
*
* Codec valueCodec = ...
* RMapReactive map = redissonClient.getMap("simpleMap", new CompositeCodec(StringCodec.INSTANCE, valueCodec, valueCodec));
*
* // or
*
* RMapReactive map = redissonClient.getMap("simpleMap", StringCodec.INSTANCE);
*
*
* 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
*
* @see #readAllEntrySet()
*
* @param pattern - key pattern
* @return iterator
*/
Flux> entryIterator(String pattern);
/**
* Returns iterator over 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.
*
* Use org.redisson.client.codec.StringCodec for Map keys.
*
* Usage example:
*
* Codec valueCodec = ...
* RMapReactive map = redissonClient.getMap("simpleMap", new CompositeCodec(StringCodec.INSTANCE, valueCodec, valueCodec));
*
* // or
*
* RMapReactive map = redissonClient.getMap("simpleMap", StringCodec.INSTANCE);
*
*
* 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
*
* @see #readAllEntrySet()
*
* @param pattern - key pattern
* @param count - size of entries batch
* @return iterator
*/
Flux> entryIterator(String pattern, int count);
/**
* Returns iterator over values collection of this map.
* Values are loaded in batch. Batch size is 10.
*
* @see #readAllValues()
*
* @return iterator
*/
Flux valueIterator();
/**
* Returns iterator over values collection of this map.
* Values are loaded in batch. Batch size is defined by count param.
*
* @see #readAllValues()
*
* @param count - size of values batch
* @return iterator
*/
Flux valueIterator(int count);
/**
* Returns iterator over 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.
*
* Usage example:
*
* Codec valueCodec = ...
* RMapReactive map = redissonClient.getMap("simpleMap", new CompositeCodec(StringCodec.INSTANCE, valueCodec, valueCodec));
*
* // or
*
* RMapReactive map = redissonClient.getMap("simpleMap", StringCodec.INSTANCE);
*
*
* 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
*
* @see #readAllValues()
*
* @param pattern - key pattern
* @return iterator
*/
Flux valueIterator(String pattern);
/**
* Returns iterator over 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.
*
* Usage example:
*
* Codec valueCodec = ...
* RMapReactive map = redissonClient.getMap("simpleMap", new CompositeCodec(StringCodec.INSTANCE, valueCodec, valueCodec));
*
* // or
*
* RMapReactive map = redissonClient.getMap("simpleMap", StringCodec.INSTANCE);
*
*
* 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
*
* @see #readAllValues()
*
* @param pattern - key pattern
* @param count - size of values batch
* @return iterator
*/
Flux valueIterator(String pattern, int count);
/**
* Returns iterator over key set of this map.
* Keys are loaded in batch. Batch size is 10.
*
* @see #readAllKeySet()
*
* @return iterator
*/
Flux keyIterator();
/**
* Returns iterator over key set of this map.
* Keys are loaded in batch. Batch size is defined by count param.
*
* @see #readAllKeySet()
*
* @param count - size of keys batch
* @return iterator
*/
Flux keyIterator(int count);
/**
* Returns iterator over 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
*
* @see #readAllKeySet()
*
* @param pattern - key pattern
* @return iterator
*/
Flux keyIterator(String pattern);
/**
* Returns iterator over 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
*
* @see #readAllKeySet()
*
* @param pattern - key pattern
* @param count - size of keys batch
* @return iterator
*/
Flux keyIterator(String pattern, int count);
/**
* Returns RPermitExpirableSemaphore instance associated with key
*
* @param key - map key
* @return permitExpirableSemaphore
*/
RPermitExpirableSemaphoreReactive getPermitExpirableSemaphore(K key);
/**
* Returns RSemaphore instance associated with key
*
* @param key - map key
* @return semaphore
*/
RSemaphoreReactive getSemaphore(K key);
/**
* Returns RLock instance associated with key
*
* @param key - map key
* @return fairLock
*/
RLockReactive getFairLock(K key);
/**
* Returns RReadWriteLock instance associated with key
*
* @param key - map key
* @return readWriteLock
*/
RReadWriteLockReactive getReadWriteLock(K key);
/**
* Returns RLock instance associated with key
*
* @param key - map key
* @return lock
*/
RLockReactive getLock(K key);
/**
* Adds object event listener
*
* @see org.redisson.api.listener.TrackingListener
* @see org.redisson.api.listener.MapPutListener
* @see org.redisson.api.listener.MapRemoveListener
* @see org.redisson.api.ExpiredObjectListener
* @see org.redisson.api.DeletedObjectListener
*
* @param listener object event listener
* @return listener id
*/
Mono addListener(ObjectListener listener);
}