ReactiveRedisTemplate (Spring Data Redis 2.0.13.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>
```
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
`<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.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`.
`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.Mono<DataType>`	`type(K key)` Determine the type stored at `key`.

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

- 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.
  - 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.
    
    Specified by:
    
    keys in interface ReactiveRedisOperations<K,V>
    
    Parameters:
    
    pattern - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: KEYS
  - 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.
    
    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
  - 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.
  - 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

hasKey

type

keys

randomKey

rename

renameIfAbsent

delete

delete

expire

expireAt

persist

getExpire

move

execute

execute

preProcessConnection

postProcessResult

createRedisConnectionProxy

opsForGeo

opsForGeo

opsForHash

opsForHash

opsForHyperLogLog

opsForHyperLogLog

opsForList

opsForList

opsForSet

opsForSet

opsForValue

opsForValue

opsForZSet

opsForZSet

getSerializationContext