ReactiveRedisTemplate (Spring Data Redis 2.3.9.RELEASE API)

java.lang.Object
- org.springframework.data.redis.core.ReactiveRedisTemplate<K,V>

Type Parameters:

K - the Redis key type against which the template works (usually a String)

V - the Redis value type against which the template works

All Implemented Interfaces:

ReactiveRedisOperations<K,V>

Direct Known Subclasses:

ReactiveStringRedisTemplate
```
public class ReactiveRedisTemplate<K,V>
extends Object
implements ReactiveRedisOperations<K,V>
```
Central abstraction for reactive Redis data access implementing ReactiveRedisOperations.
Performs automatic serialization/deserialization between the given objects and the underlying binary data in the Redis store.
Note that while the template is generified, it is up to the serializers/deserializers to properly convert the given Objects to and from binary data.

Since:

2.0

Author:

Mark Paluch, Christoph Strobl

Constructor Summary

Constructors
Constructor and Description
`ReactiveRedisTemplate(ReactiveRedisConnectionFactory connectionFactory, RedisSerializationContext<K,V> serializationContext)` Creates new `ReactiveRedisTemplate` using given `ReactiveRedisConnectionFactory` and `RedisSerializationContext`.
`ReactiveRedisTemplate(ReactiveRedisConnectionFactory connectionFactory, RedisSerializationContext<K,V> serializationContext, boolean exposeConnection)` Creates new `ReactiveRedisTemplate` using given `ReactiveRedisConnectionFactory` and `RedisSerializationContext`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`reactor.core.publisher.Mono<Long>`	`convertAndSend(String destination, V message)` Publishes the given message to the given channel.
`<T> reactor.core.publisher.Flux<T>`	`createFlux(ReactiveRedisCallback<T> callback)` Create a reusable Flux for a `ReactiveRedisCallback`.
`<T> reactor.core.publisher.Mono<T>`	`createMono(ReactiveRedisCallback<T> callback)` Create a reusable Mono for a `ReactiveRedisCallback`.
`protected ReactiveRedisConnection`	`createRedisConnectionProxy(ReactiveRedisConnection reactiveRedisConnection)`
`reactor.core.publisher.Mono<Long>`	`delete(K... keys)` Delete given `key`.
`reactor.core.publisher.Mono<Long>`	`delete(org.reactivestreams.Publisher<K> keys)` Delete given `keys`.
`<T> reactor.core.publisher.Flux<T>`	`execute(ReactiveRedisCallback<T> action)` Executes the given action within a Redis connection.
`<T> reactor.core.publisher.Flux<T>`	`execute(ReactiveRedisCallback<T> action, boolean exposeConnection)` Executes the given action object within a connection that can be exposed or not.
`<T> reactor.core.publisher.Flux<T>`	`execute(RedisScript<T> script, List<K> keys, List<?> args)` Executes the given `RedisScript`
`<T> reactor.core.publisher.Flux<T>`	`execute(RedisScript<T> script, List<K> keys, List<?> args, RedisElementWriter<?> argsWriter, RedisElementReader<T> resultReader)` Executes the given `RedisScript`, using the provided `RedisSerializer`s to serialize the script arguments and result.
`reactor.core.publisher.Mono<Boolean>`	`expire(K key, Duration timeout)` Set time to live for given `key`.
`reactor.core.publisher.Mono<Boolean>`	`expireAt(K key, Instant expireAt)` Set the expiration for given `key` as a expireAt timestamp.
`ReactiveRedisConnectionFactory`	`getConnectionFactory()` Returns the connectionFactory.
`reactor.core.publisher.Mono<Duration>`	`getExpire(K key)` Get the time to live for `key`.
`RedisSerializationContext<K,V>`	`getSerializationContext()`
`reactor.core.publisher.Mono<Boolean>`	`hasKey(K key)` Determine if given `key` exists.
`reactor.core.publisher.Flux<K>`	`keys(K pattern)` Find all keys matching the given `pattern`.
`reactor.core.publisher.Flux<? extends ReactiveSubscription.Message<String,V>>`	`listenTo(Topic... topics)` Subscribe to the Redis channels for the given `topics` and emit `messages` received for those.
`reactor.core.publisher.Mono<Boolean>`	`move(K key, int dbIndex)` Move given `key` to database with `index`.
`ReactiveGeoOperations<K,V>`	`opsForGeo()` Returns geospatial specific operations interface.
`<K1,V1> ReactiveGeoOperations<K1,V1>`	`opsForGeo(RedisSerializationContext<K1,V1> serializationContext)` Returns geospatial specific operations interface.
`<HK,HV> ReactiveHashOperations<K,HK,HV>`	`opsForHash()` Returns the operations performed on hash values.
`<K1,HK,HV> ReactiveHashOperations<K1,HK,HV>`	`opsForHash(RedisSerializationContext<K1,?> serializationContext)` Returns the operations performed on hash values given a `RedisSerializationContext`.
`ReactiveHyperLogLogOperations<K,V>`	`opsForHyperLogLog()` Returns the operations performed on multisets using HyperLogLog.
`<K1,V1> ReactiveHyperLogLogOperations<K1,V1>`	`opsForHyperLogLog(RedisSerializationContext<K1,V1> serializationContext)` Returns the operations performed on multisets using HyperLogLog given a `RedisSerializationContext`.
`ReactiveListOperations<K,V>`	`opsForList()` Returns the operations performed on list values.
`<K1,V1> ReactiveListOperations<K1,V1>`	`opsForList(RedisSerializationContext<K1,V1> serializationContext)` Returns the operations performed on list values given a `RedisSerializationContext`.
`ReactiveSetOperations<K,V>`	`opsForSet()` Returns the operations performed on set values.
`<K1,V1> ReactiveSetOperations<K1,V1>`	`opsForSet(RedisSerializationContext<K1,V1> serializationContext)` Returns the operations performed on set values given a `RedisSerializationContext`.
`<HK,HV> ReactiveStreamOperations<K,HK,HV>`	`opsForStream()` Returns the operations performed on streams.
`<HK,HV> ReactiveStreamOperations<K,HK,HV>`	`opsForStream(HashMapper<? super K,? super HK,? super HV> hashMapper)` Returns the operations performed on streams.
`<HK,HV> ReactiveStreamOperations<K,HK,HV>`	`opsForStream(RedisSerializationContext<K,?> serializationContext)` Returns the operations performed on streams given a `RedisSerializationContext`.
`protected <HK,HV> ReactiveStreamOperations<K,HK,HV>`	`opsForStream(RedisSerializationContext<K,?> serializationContext, HashMapper<? super K,? super HK,? super HV> hashMapper)`
`ReactiveValueOperations<K,V>`	`opsForValue()` Returns the operations performed on simple values (or Strings in Redis terminology).
`<K1,V1> ReactiveValueOperations<K1,V1>`	`opsForValue(RedisSerializationContext<K1,V1> serializationContext)` Returns the operations performed on simple values (or Strings in Redis terminology) given a `RedisSerializationContext`.
`ReactiveZSetOperations<K,V>`	`opsForZSet()` Returns the operations performed on zset values (also known as sorted sets).
`<K1,V1> ReactiveZSetOperations<K1,V1>`	`opsForZSet(RedisSerializationContext<K1,V1> serializationContext)` Returns the operations performed on zset values (also known as sorted sets) given a `RedisSerializationContext`.
`reactor.core.publisher.Mono<Boolean>`	`persist(K key)` Remove the expiration from given `key`.
`protected <T> org.reactivestreams.Publisher<T>`	`postProcessResult(org.reactivestreams.Publisher<T> result, ReactiveRedisConnection connection, boolean existingConnection)` Processes the result before returning the `Publisher`.
`protected ReactiveRedisConnection`	`preProcessConnection(ReactiveRedisConnection connection, boolean existingConnection)` Processes the connection (before any settings are executed on it).
`reactor.core.publisher.Mono<K>`	`randomKey()` Return a random key from the keyspace.
`reactor.core.publisher.Mono<Boolean>`	`rename(K oldKey, K newKey)` Rename key `oldKey` to `newKey`.
`reactor.core.publisher.Mono<Boolean>`	`renameIfAbsent(K oldKey, K newKey)` Rename key `oleName` to `newKey` only if `newKey` does not exist.
`reactor.core.publisher.Flux<K>`	`scan(ScanOptions options)` Use a `Flux` to iterate over keys.
`reactor.core.publisher.Mono<DataType>`	`type(K key)` Determine the type stored at `key`.
`reactor.core.publisher.Mono<Long>`	`unlink(K... keys)` Unlink the `key` from the keyspace.
`reactor.core.publisher.Mono<Long>`	`unlink(org.reactivestreams.Publisher<K> keys)` Unlink the `keys` from the keyspace.

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

Methods inherited from interface org.springframework.data.redis.core.ReactiveRedisOperations
execute, execute, listenToChannel, listenToPattern, scan

- Constructor Detail
  - ReactiveRedisTemplate
```
public ReactiveRedisTemplate(ReactiveRedisConnectionFactory connectionFactory,
                             RedisSerializationContext<K,V> serializationContext)
```
    Creates new ReactiveRedisTemplate using given ReactiveRedisConnectionFactory and RedisSerializationContext.
    
    Parameters:
    
    connectionFactory - must not be null.
    
    serializationContext - must not be null.
  - ReactiveRedisTemplate
```
public ReactiveRedisTemplate(ReactiveRedisConnectionFactory connectionFactory,
                             RedisSerializationContext<K,V> serializationContext,
                             boolean exposeConnection)
```
    Creates new ReactiveRedisTemplate using given ReactiveRedisConnectionFactory and RedisSerializationContext.
    
    Parameters:
    
    connectionFactory - must not be null.
    
    serializationContext - must not be null.
    
    exposeConnection - flag indicating to expose the connection used.
- Method Detail
  - getConnectionFactory
```
public ReactiveRedisConnectionFactory getConnectionFactory()
```
    Returns the connectionFactory.
    
    Returns:
    
    Returns the connectionFactory
  - execute
```
public <T> reactor.core.publisher.Flux<T> execute(ReactiveRedisCallback<T> action)
```
    Description copied from interface: ReactiveRedisOperations
    
    Executes the given action within a Redis connection. Application exceptions thrown by the action object get propagated to the caller (can only be unchecked) whenever possible. Redis exceptions are transformed into appropriate DAO ones. Allows for returning a result object, that is a domain object or a collection of domain objects. Performs automatic serialization/deserialization for the given objects to and from binary data suitable for the Redis storage. Note: Callback code is not supposed to handle transactions itself! Use an appropriate transaction manager. Generally, callback code must not touch any Connection lifecycle methods, like close, to let the template do its work.
    
    Specified by:
    
    execute in interface ReactiveRedisOperations<K,V>
    
    Type Parameters:
    
    T - return type
    
    Parameters:
    
    action - callback object that specifies the Redis action
    
    Returns:
    
    a result object returned by the action or Flux.empty().
  - execute
```
public <T> reactor.core.publisher.Flux<T> execute(ReactiveRedisCallback<T> action,
                                                  boolean exposeConnection)
```
    Executes the given action object within a connection that can be exposed or not. Additionally, the connection can be pipelined. Note the results of the pipeline are discarded (making it suitable for write-only scenarios).
    
    Type Parameters:
    
    T - return type
    
    Parameters:
    
    action - callback object to execute
    
    exposeConnection - whether to enforce exposure of the native Redis Connection to callback code
    
    Returns:
    
    object returned by the action
  - createFlux
```
public <T> reactor.core.publisher.Flux<T> createFlux(ReactiveRedisCallback<T> callback)
```
    Create a reusable Flux for a ReactiveRedisCallback. Callback is executed within a connection context. The connection is released outside the callback.
    
    Parameters:
    
    callback - must not be null
    
    Returns:
    
    a Flux wrapping the ReactiveRedisCallback.
  - createMono
```
public <T> reactor.core.publisher.Mono<T> createMono(ReactiveRedisCallback<T> callback)
```
    Create a reusable Mono for a ReactiveRedisCallback. Callback is executed within a connection context. The connection is released outside the callback.
    
    Parameters:
    
    callback - must not be null
    
    Returns:
    
    a Mono wrapping the ReactiveRedisCallback.
  - convertAndSend
```
public reactor.core.publisher.Mono<Long> convertAndSend(String destination,
                                                        V message)
```
    Description copied from interface: ReactiveRedisOperations
    
    Publishes the given message to the given channel.
    
    Specified by:
    
    convertAndSend in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    destination - the channel to publish to, must not be null nor empty.
    
    message - message to publish. Must not be null.
    
    Returns:
    
    the number of clients that received the message
    
    See Also:
    
    Redis Documentation: PUBLISH
  - listenTo
```
public reactor.core.publisher.Flux<? extends ReactiveSubscription.Message<String,V>> listenTo(Topic... topics)
```
    Description copied from interface: ReactiveRedisOperations
    
    Subscribe to the Redis channels for the given topics and emit messages received for those.
    
    Specified by:
    
    listenTo in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    topics - must not be null.
    
    Returns:
    
    a hot sequence of messages.
  - hasKey
```
public reactor.core.publisher.Mono<Boolean> hasKey(K key)
```
    Description copied from interface: ReactiveRedisOperations
    
    Determine if given key exists.
    
    Specified by:
    
    hasKey in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EXISTS
  - type
```
public reactor.core.publisher.Mono<DataType> type(K key)
```
    Description copied from interface: ReactiveRedisOperations
    
    Determine the type stored at key.
    
    Specified by:
    
    type in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: TYPE
  - keys
```
public reactor.core.publisher.Flux<K> keys(K pattern)
```
    Description copied from interface: ReactiveRedisOperations
    
    Find all keys matching the given pattern.
    IMPORTANT: It is recommended to use ReactiveRedisOperations.scan() to iterate over the keyspace as ReactiveRedisOperations.keys(Object) is a non-interruptible and expensive Redis operation.
    
    Specified by:
    
    keys in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    pattern - must not be null.
    
    Returns:
    
    the Flux emitting matching keys one by one.
    
    See Also:
    
    Redis Documentation: KEYS
  - scan
```
public reactor.core.publisher.Flux<K> scan(ScanOptions options)
```
    Description copied from interface: ReactiveRedisOperations
    
    Use a Flux to iterate over keys. The resulting Flux acts as a cursor and issues SCAN commands itself as long as the subscriber signals demand.
    
    Specified by:
    
    scan in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    options - must not be null. Use ScanOptions.NONE instead.
    
    Returns:
    
    the Flux emitting the keys one by one or an empty flux if none exist.
    
    See Also:
    
    Redis Documentation: SCAN
  - randomKey
```
public reactor.core.publisher.Mono<K> randomKey()
```
    Description copied from interface: ReactiveRedisOperations
    
    Return a random key from the keyspace.
    
    Specified by:
    
    randomKey in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    See Also:
    
    Redis Documentation: RANDOMKEY
  - rename
```
public reactor.core.publisher.Mono<Boolean> rename(K oldKey,
                                                   K newKey)
```
    Description copied from interface: ReactiveRedisOperations
    
    Rename key oldKey to newKey.
    
    Specified by:
    
    rename in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    oldKey - must not be null.
    
    newKey - must not be null.
    
    See Also:
    
    Redis Documentation: RENAME
  - renameIfAbsent
```
public reactor.core.publisher.Mono<Boolean> renameIfAbsent(K oldKey,
                                                           K newKey)
```
    Description copied from interface: ReactiveRedisOperations
    
    Rename key oleName to newKey only if newKey does not exist.
    
    Specified by:
    
    renameIfAbsent in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    oldKey - must not be null.
    
    newKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RENAMENX
  - delete
```
@SafeVarargs
public final reactor.core.publisher.Mono<Long> delete(K... keys)
```
    Description copied from interface: ReactiveRedisOperations
    
    Delete given key.
    
    Specified by:
    
    delete in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    The number of keys that were removed.
    
    See Also:
    
    Redis Documentation: DEL
  - delete
```
public reactor.core.publisher.Mono<Long> delete(org.reactivestreams.Publisher<K> keys)
```
    Description copied from interface: ReactiveRedisOperations
    
    Delete given keys. This command buffers keys received from Publisher into chunks of 128 keys to delete to reduce the number of issued DEL commands.
    
    Specified by:
    
    delete in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    The number of keys that were removed.
    
    See Also:
    
    Redis Documentation: DEL
  - unlink
```
@SafeVarargs
public final reactor.core.publisher.Mono<Long> unlink(K... keys)
```
    Description copied from interface: ReactiveRedisOperations
    
    Unlink the key from the keyspace. Unlike with ReactiveRedisOperations.delete(Object[]) the actual memory reclaiming here happens asynchronously.
    
    Specified by:
    
    unlink in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    The number of keys that were removed. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: UNLINK
  - unlink
```
public reactor.core.publisher.Mono<Long> unlink(org.reactivestreams.Publisher<K> keys)
```
    Description copied from interface: ReactiveRedisOperations
    
    Unlink the keys from the keyspace. Unlike with ReactiveRedisOperations.delete(Publisher) the actual memory reclaiming here happens asynchronously. This command buffers keys received from Publisher into chunks of 128 keys to delete to reduce the number of issued UNLINK commands.
    
    Specified by:
    
    unlink in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    The number of keys that were removed. null when used in pipeline / transaction.
    
    See Also:
    
    Redis Documentation: UNLINK
  - expire
```
public reactor.core.publisher.Mono<Boolean> expire(K key,
                                                   Duration timeout)
```
    Description copied from interface: ReactiveRedisOperations
    
    Set time to live for given key.
    
    Specified by:
    
    expire in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    key - must not be null.
    
    timeout - must not be null.
    
    Returns:
  - expireAt
```
public reactor.core.publisher.Mono<Boolean> expireAt(K key,
                                                     Instant expireAt)
```
    Description copied from interface: ReactiveRedisOperations
    
    Set the expiration for given key as a expireAt timestamp.
    
    Specified by:
    
    expireAt in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    key - must not be null.
    
    expireAt - must not be null.
    
    Returns:
  - persist
```
public reactor.core.publisher.Mono<Boolean> persist(K key)
```
    Description copied from interface: ReactiveRedisOperations
    
    Remove the expiration from given key.
    
    Specified by:
    
    persist in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PERSIST
  - getExpire
```
public reactor.core.publisher.Mono<Duration> getExpire(K key)
```
    Description copied from interface: ReactiveRedisOperations
    
    Get the time to live for key.
    
    Specified by:
    
    getExpire in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    the Duration of the associated key. Duration.ZERO if no timeout associated or empty Mono if the key does not exist.
    
    See Also:
    
    Redis Documentation: PTTL
  - move
```
public reactor.core.publisher.Mono<Boolean> move(K key,
                                                 int dbIndex)
```
    Description copied from interface: ReactiveRedisOperations
    
    Move given key to database with index.
    
    Specified by:
    
    move in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: MOVE
  - execute
```
public <T> reactor.core.publisher.Flux<T> execute(RedisScript<T> script,
                                                  List<K> keys,
                                                  List<?> args)
```
    Description copied from interface: ReactiveRedisOperations
    
    Executes the given RedisScript
    
    Specified by:
    
    execute in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    script - The script to execute. Must not be null.
    
    keys - keys that need to be passed to the script. Must not be null.
    
    args - args that need to be passed to the script. Must not be null.
    
    Returns:
    
    result value of the script Flux.empty() if RedisScript.getResultType() is null, likely indicating a throw-away status reply (i.e. "OK").
  - execute
```
public <T> reactor.core.publisher.Flux<T> execute(RedisScript<T> script,
                                                  List<K> keys,
                                                  List<?> args,
                                                  RedisElementWriter<?> argsWriter,
                                                  RedisElementReader<T> resultReader)
```
    Description copied from interface: ReactiveRedisOperations
    
    Executes the given RedisScript, using the provided RedisSerializers to serialize the script arguments and result.
    
    Specified by:
    
    execute in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    script - The script to execute
    
    keys - keys that need to be passed to the script.
    
    args - args that need to be passed to the script.
    
    argsWriter - The RedisElementWriter to use for serializing args
    
    resultReader - The RedisElementReader to use for serializing the script return value
    
    Returns:
    
    result value of the script Flux.empty() if RedisScript.getResultType() is null, likely indicating a throw-away status reply (i.e. "OK").
  - preProcessConnection
```
protected ReactiveRedisConnection preProcessConnection(ReactiveRedisConnection connection,
                                                       boolean existingConnection)
```
    Processes the connection (before any settings are executed on it). Default implementation returns the connection as is.
    
    Parameters:
    
    connection - must not be null.
    
    existingConnection -
  - postProcessResult
```
protected <T> org.reactivestreams.Publisher<T> postProcessResult(org.reactivestreams.Publisher<T> result,
                                                                 ReactiveRedisConnection connection,
                                                                 boolean existingConnection)
```
    Processes the result before returning the Publisher. Default implementation returns the result as is.
    
    Parameters:
    
    result - must not be null.
    
    connection - must not be null.
    
    existingConnection -
    
    Returns:
  - createRedisConnectionProxy
```
protected ReactiveRedisConnection createRedisConnectionProxy(ReactiveRedisConnection reactiveRedisConnection)
```
  - opsForGeo
```
public ReactiveGeoOperations<K,V> opsForGeo()
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns geospatial specific operations interface.
    
    Specified by:
    
    opsForGeo in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    geospatial specific operations.
  - opsForGeo
```
public <K1,V1> ReactiveGeoOperations<K1,V1> opsForGeo(RedisSerializationContext<K1,V1> serializationContext)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns geospatial specific operations interface.
    
    Specified by:
    
    opsForGeo in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    serializationContext - serializers to be used with the returned operations, must not be null.
    
    Returns:
    
    geospatial specific operations.
  - opsForHash
```
public <HK,HV> ReactiveHashOperations<K,HK,HV> opsForHash()
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on hash values.
    
    Specified by:
    
    opsForHash in interface ReactiveRedisOperations<K,V>
    
    Type Parameters:
    
    HK - hash key (or field) type.
    
    HV - hash value type.
    
    Returns:
    
    hash operations.
  - opsForHash
```
public <K1,HK,HV> ReactiveHashOperations<K1,HK,HV> opsForHash(RedisSerializationContext<K1,?> serializationContext)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on hash values given a RedisSerializationContext.
    
    Specified by:
    
    opsForHash in interface ReactiveRedisOperations<K,V>
    
    HK - hash key (or field) type.
    
    HV - hash value type.
    
    Parameters:
    
    serializationContext - serializers to be used with the returned operations, must not be null.
    
    Returns:
    
    hash operations.
  - opsForHyperLogLog
```
public ReactiveHyperLogLogOperations<K,V> opsForHyperLogLog()
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on multisets using HyperLogLog.
    
    Specified by:
    
    opsForHyperLogLog in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    never null.
  - opsForHyperLogLog
```
public <K1,V1> ReactiveHyperLogLogOperations<K1,V1> opsForHyperLogLog(RedisSerializationContext<K1,V1> serializationContext)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on multisets using HyperLogLog given a RedisSerializationContext.
    
    Specified by:
    
    opsForHyperLogLog in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    serializationContext - serializers to be used with the returned operations, must not be null.
    
    Returns:
    
    never null.
  - opsForList
```
public ReactiveListOperations<K,V> opsForList()
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on list values.
    
    Specified by:
    
    opsForList in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    list operations.
  - opsForList
```
public <K1,V1> ReactiveListOperations<K1,V1> opsForList(RedisSerializationContext<K1,V1> serializationContext)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on list values given a RedisSerializationContext.
    
    Specified by:
    
    opsForList in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    serializationContext - serializers to be used with the returned operations, must not be null.
    
    Returns:
    
    list operations.
  - opsForSet
```
public ReactiveSetOperations<K,V> opsForSet()
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on set values.
    
    Specified by:
    
    opsForSet in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    set operations.
  - opsForSet
```
public <K1,V1> ReactiveSetOperations<K1,V1> opsForSet(RedisSerializationContext<K1,V1> serializationContext)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on set values given a RedisSerializationContext.
    
    Specified by:
    
    opsForSet in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    serializationContext - serializers to be used with the returned operations, must not be null.
    
    Returns:
    
    set operations.
  - opsForStream
```
public <HK,HV> ReactiveStreamOperations<K,HK,HV> opsForStream()
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on streams.
    
    Specified by:
    
    opsForStream in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    stream operations.
  - opsForStream
```
public <HK,HV> ReactiveStreamOperations<K,HK,HV> opsForStream(HashMapper<? super K,? super HK,? super HV> hashMapper)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on streams.
    
    Specified by:
    
    opsForStream in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    hashMapper - the HashMapper to use when mapping complex objects.
    
    Returns:
    
    stream operations.
  - opsForStream
```
public <HK,HV> ReactiveStreamOperations<K,HK,HV> opsForStream(RedisSerializationContext<K,?> serializationContext)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on streams given a RedisSerializationContext.
    
    Specified by:
    
    opsForStream in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    serializationContext - serializers to be used with the returned operations, must not be null.
    
    Returns:
    
    stream operations.
  - opsForStream
```
protected <HK,HV> ReactiveStreamOperations<K,HK,HV> opsForStream(RedisSerializationContext<K,?> serializationContext,
                                                                 @Nullable
                                                                 HashMapper<? super K,? super HK,? super HV> hashMapper)
```
  - opsForValue
```
public ReactiveValueOperations<K,V> opsForValue()
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on simple values (or Strings in Redis terminology).
    
    Specified by:
    
    opsForValue in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    value operations
  - opsForValue
```
public <K1,V1> ReactiveValueOperations<K1,V1> opsForValue(RedisSerializationContext<K1,V1> serializationContext)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on simple values (or Strings in Redis terminology) given a RedisSerializationContext.
    
    Specified by:
    
    opsForValue in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    serializationContext - serializers to be used with the returned operations, must not be null.
    
    Returns:
    
    value operations.
  - opsForZSet
```
public ReactiveZSetOperations<K,V> opsForZSet()
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on zset values (also known as sorted sets).
    
    Specified by:
    
    opsForZSet in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    zset operations.
  - opsForZSet
```
public <K1,V1> ReactiveZSetOperations<K1,V1> opsForZSet(RedisSerializationContext<K1,V1> serializationContext)
```
    Description copied from interface: ReactiveRedisOperations
    
    Returns the operations performed on zset values (also known as sorted sets) given a RedisSerializationContext.
    
    Specified by:
    
    opsForZSet in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    serializationContext - serializers to be used with the returned operations, must not be null.
    
    Returns:
    
    zset operations.
  - getSerializationContext
```
public RedisSerializationContext<K,V> getSerializationContext()
```
    Specified by:
    
    getSerializationContext in interface ReactiveRedisOperations<K,V>
    
    Returns:
    
    the RedisSerializationContext.

Class ReactiveRedisTemplate<K,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Constructor Detail

ReactiveRedisTemplate

ReactiveRedisTemplate

Method Detail

getConnectionFactory

execute

execute

createFlux

createMono

convertAndSend

listenTo

hasKey

type

keys

scan

randomKey

rename

renameIfAbsent

delete

delete

unlink

unlink

expire

expireAt

persist

getExpire

move

execute

execute

preProcessConnection

postProcessResult

createRedisConnectionProxy

opsForGeo

opsForGeo

opsForHash

opsForHash

opsForHyperLogLog

opsForHyperLogLog

opsForList

opsForList

opsForSet

opsForSet

opsForStream

opsForStream

opsForStream

opsForStream

opsForValue

opsForValue

opsForZSet

opsForZSet

getSerializationContext