RedisAsyncConnectionImpl (lettuce 3.4.2.Final API)

java.lang.Object
- io.netty.channel.ChannelHandlerAdapter
- - io.netty.channel.ChannelInboundHandlerAdapter
  - - com.lambdaworks.redis.RedisChannelHandler<K,V>
    - - com.lambdaworks.redis.RedisAsyncConnectionImpl<K,V>

Type Parameters:

K - Key type.

V - Value type.

All Implemented Interfaces:

BaseRedisAsyncConnection<K,V>, RedisAsyncConnection<K,V>, RedisClusterAsyncConnection<K,V>, RedisGeoAsyncConnection<K,V>, RedisHashesAsyncConnection<K,V>, RedisHLLAsyncConnection<K,V>, RedisKeysAsyncConnection<K,V>, RedisListsAsyncConnection<K,V>, RedisScriptingAsyncConnection<K,V>, RedisServerAsyncConnection<K,V>, RedisSetsAsyncConnection<K,V>, RedisSortedSetsAsyncConnection<K,V>, RedisStringsAsyncConnection<K,V>, ChannelHandler, ChannelInboundHandler, Closeable, AutoCloseable

Direct Known Subclasses:

RedisAdvancedClusterAsyncConnectionImpl, RedisPubSubConnectionImpl
```
@ChannelHandler.Sharable
public class RedisAsyncConnectionImpl<K,V>
extends RedisChannelHandler<K,V>
implements RedisAsyncConnection<K,V>, RedisClusterAsyncConnection<K,V>
```
An asynchronous thread-safe connection to a redis server. Multiple threads may share one RedisAsyncConnectionImpl provided they avoid blocking and transactional operations such as blpop(long, K...) and multi()/exec(). A ConnectionWatchdog monitors each connection and reconnects automatically until RedisChannelHandler.close() is called. All pending commands will be (re)sent after successful reconnection.

Author:

Will Glozer

Nested Class Summary
- Nested classes/interfaces inherited from interface io.netty.channel.ChannelHandler
  ChannelHandler.Sharable

Field Summary

Fields
Modifier and Type	Field and Description
`protected RedisCodec<K,V>`	`codec`
`protected com.lambdaworks.redis.RedisCommandBuilder<K,V>`	`commandBuilder`
`protected MultiOutput<K,V>`	`multi`

Fields inherited from class com.lambdaworks.redis.RedisChannelHandler
timeout, unit

Constructor Summary

Constructors
Constructor and Description
`RedisAsyncConnectionImpl(RedisChannelWriter<K,V> writer, RedisCodec<K,V> codec, long timeout, TimeUnit unit)` Initialize a new connection.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`activated()` Notification when the connection becomes active (connected).
`RedisFuture<Long>`	`append(K key, V value)` Append a value to a key.
`RedisFuture<String>`	`asking()` The asking command is required after a `-ASK` redirection.
`String`	`auth(String password)` Authenticate to the server.
`RedisFuture<String>`	`bgrewriteaof()` Asynchronously rewrite the append-only file.
`RedisFuture<String>`	`bgsave()` Asynchronously save the dataset to disk.
`RedisFuture<Long>`	`bitcount(K key)` Count set bits in a string.
`RedisFuture<Long>`	`bitcount(K key, long start, long end)` Count set bits in a string.
`RedisFuture<Long>`	`bitopAnd(K destination, K... keys)` Perform bitwise AND between strings.
`RedisFuture<Long>`	`bitopNot(K destination, K source)` Perform bitwise NOT between strings.
`RedisFuture<Long>`	`bitopOr(K destination, K... keys)` Perform bitwise OR between strings.
`RedisFuture<Long>`	`bitopXor(K destination, K... keys)` Perform bitwise XOR between strings.
`RedisFuture<Long>`	`bitpos(K key, boolean state)` Find first bit set or clear in a string.
`RedisFuture<Long>`	`bitpos(K key, boolean state, long start, long end)` Find first bit set or clear in a string.
`RedisFuture<KeyValue<K,V>>`	`blpop(long timeout, K... keys)` Remove and get the first element in a list, or block until one is available.
`RedisFuture<KeyValue<K,V>>`	`brpop(long timeout, K... keys)` Remove and get the last element in a list, or block until one is available.
`RedisFuture<V>`	`brpoplpush(long timeout, K source, K destination)` Pop a value from a list, push it to another list and return it; or block until one is available.
`RedisFuture<K>`	`clientGetname()` Get the current connection name.
`RedisFuture<Long>`	`clientKill(KillArgs killArgs)` Kill connections of clients which are filtered by `killArgs`
`RedisFuture<String>`	`clientKill(String addr)` Kill the connection of a client identified by ip:port.
`RedisFuture<String>`	`clientList()` Get the list of client connections.
`RedisFuture<String>`	`clientPause(long timeout)` Stop processing commands from clients for some time.
`RedisFuture<String>`	`clientSetname(K name)` Set the current connection name.
`RedisFuture<String>`	`clusterAddSlots(int... slots)` Adds slots to the cluster node.
`RedisFuture<Long>`	`clusterCountFailureReports(String nodeId)` Returns the number of failure reports for the specified node.
`RedisFuture<Long>`	`clusterCountKeysInSlot(int slot)` Returns the number of keys in the specified Redis Cluster hash `slot`.
`RedisFuture<String>`	`clusterDelSlots(int... slots)` Removes slots from the cluster node.
`RedisFuture<String>`	`clusterFailover(boolean force)` Failover a cluster node.
`RedisFuture<String>`	`clusterFlushslots()` Delete all the slots associated with the specified node.
`RedisFuture<String>`	`clusterForget(String nodeId)` Blacklist and remove the cluster node from the cluster.
`RedisFuture<List<K>>`	`clusterGetKeysInSlot(int slot, int count)` Retrieve the list of keys within the `slot`.
`RedisFuture<String>`	`clusterInfo()` Get information and statistics about the cluster viewed by the current node.
`RedisFuture<Long>`	`clusterKeyslot(K key)` Returns an integer identifying the hash slot the specified key hashes to.
`RedisFuture<String>`	`clusterMeet(String ip, int port)` Meet another cluster node to include the node into the cluster.
`RedisFuture<String>`	`clusterMyId()` Obtain the nodeId for the currently connected node.
`RedisFuture<String>`	`clusterNodes()` Obtain details about all cluster nodes.
`RedisFuture<String>`	`clusterReplicate(String nodeId)` Turn this node into a slave of the node with the id `nodeId`.
`RedisFuture<String>`	`clusterReset(boolean hard)` Reset a node performing a soft or hard reset: All other nodes are forgotten All the assigned / open slots are released If the node is a slave, it turns into a master Only for hard reset: a new Node ID is generated Only for hard reset: currentEpoch and configEpoch are set to 0 The new configuration is saved and the cluster state updated If the node was a slave, the whole data set is flushed away
`RedisFuture<String>`	`clusterSaveconfig()` Forces a node to save the nodes.conf configuration on disk.
`RedisFuture<String>`	`clusterSetConfigEpoch(long configEpoch)` This command sets a specific config epoch in a fresh node.
`RedisFuture<String>`	`clusterSetSlotImporting(int slot, String nodeId)` Flag a slot as IMPORTING (incoming) from the node specified in `nodeId`.
`RedisFuture<String>`	`clusterSetSlotMigrating(int slot, String nodeId)` Flag a slot as MIGRATING (outgoing) towards the node specified in `nodeId`.
`RedisFuture<String>`	`clusterSetSlotNode(int slot, String nodeId)` Assign a slot to a node.
`RedisFuture<String>`	`clusterSetSlotStable(int slot)` Clears migrating / importing state from the slot.
`RedisFuture<List<String>>`	`clusterSlaves(String nodeId)` List slaves for a certain node identified by its `nodeId`.
`RedisFuture<List<Object>>`	`clusterSlots()` Get array of cluster slots to node mappings.
`RedisFuture<List<Object>>`	`command()` Returns an array reply of details about all Redis commands.
`RedisFuture<Long>`	`commandCount()` Get total number of Redis commands.
`RedisFuture<List<Object>>`	`commandInfo(CommandType... commands)` Returns an array reply of details about the requested commands.
`RedisFuture<List<Object>>`	`commandInfo(String... commands)` Returns an array reply of details about the requested commands.
`RedisFuture<List<String>>`	`configGet(String parameter)` Get the value of a configuration parameter.
`RedisFuture<String>`	`configResetstat()` Reset the stats returned by INFO.
`RedisFuture<String>`	`configRewrite()` Rewrite the configuration file with the in memory configuration.
`RedisFuture<String>`	`configSet(String parameter, String value)` Set a configuration parameter to the given value.
`RedisFuture<Long>`	`dbsize()` Return the number of keys in the selected database.
`RedisFuture<String>`	`debugHtstats(int db)` Get debugging information about the internal hash-table state.
`RedisFuture<String>`	`debugObject(K key)` Get debugging information about a key.
`void`	`debugOom()` Make the server crash: Out of memory.
`void`	`debugSegfault()` Make the server crash: Invalid pointer access.
`RedisFuture<Long>`	`decr(K key)` Decrement the integer value of a key by one.
`RedisFuture<Long>`	`decrby(K key, long amount)` Decrement the integer value of a key by the given number.
`RedisFuture<Long>`	`del(K... keys)` Delete one or more keys.
`String`	`digest(V script)` Create a SHA1 digest from a Lua script.
`RedisFuture<String>`	`discard()` Discard all commands issued after MULTI.
`protected <T> RedisCommand<K,V,T>`	`dispatch(CommandType type, CommandOutput<K,V,T> output)`
`protected <T> RedisCommand<K,V,T>`	`dispatch(CommandType type, CommandOutput<K,V,T> output, CommandArgs<K,V> args)`
`<T> RedisCommand<K,V,T>`	`dispatch(RedisCommand<K,V,T> cmd)`
`RedisFuture<byte[]>`	`dump(K key)` Return a serialized version of the value stored at the specified key.
`RedisFuture<V>`	`echo(V msg)` Echo the given string.
`<T> RedisFuture<T>`	`eval(String script, ScriptOutputType type, K... keys)` Execute a Lua script server side.
`<T> RedisFuture<T>`	`eval(String script, ScriptOutputType type, K[] keys, V... values)` Execute a Lua script server side.
`<T> RedisFuture<T>`	`evalsha(String digest, ScriptOutputType type, K... keys)` Evaluates a script cached on the server side by its SHA1 digest
`<T> RedisFuture<T>`	`evalsha(String digest, ScriptOutputType type, K[] keys, V... values)` Execute a Lua script server side.
`RedisFuture<List<Object>>`	`exec()` Execute all commands issued after MULTI.
`RedisFuture<Long>`	`exists(K... keys)` Determine how many keys exist.
`RedisFuture<Boolean>`	`exists(K key)` Determine if a key exists.
`RedisFuture<Boolean>`	`expire(K key, long seconds)` Set a key's time to live in seconds.
`RedisFuture<Boolean>`	`expireat(K key, Date timestamp)` Set the expiration for a key as a UNIX timestamp.
`RedisFuture<Boolean>`	`expireat(K key, long timestamp)` Set the expiration for a key as a UNIX timestamp.
`RedisFuture<String>`	`flushall()` Remove all keys from all databases.
`RedisFuture<String>`	`flushallAsync()` Remove all keys asynchronously from all databases.
`RedisFuture<String>`	`flushdb()` Remove all keys from the current database.
`RedisFuture<String>`	`flushdbAsync()` Remove all keys asynchronously from the current database.
`RedisFuture<Long>`	`geoadd(K key, double longitude, double latitude, V member)` Single geo add.
`RedisFuture<Long>`	`geoadd(K key, Object... lngLatMember)` Multi geo add.
`RedisFuture<Double>`	`geodist(K key, V from, V to, GeoArgs.Unit unit)` Retrieve distance between points `from` and `to`.
`RedisFuture<List<GeoCoordinates>>`	`geopos(K key, V... members)` Get geo coordinates for the `members`.
`RedisFuture<Set<V>>`	`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit)` Retrieve members selected by distance with the center of `longitude` and `latitude`.
`RedisFuture<List<GeoWithin<V>>>`	`georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)` Retrieve members selected by distance with the center of `longitude` and `latitude`.
`RedisFuture<Set<V>>`	`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit)` Retrieve members selected by distance with the center of `member`.
`RedisFuture<List<GeoWithin<V>>>`	`georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs)` Retrieve members selected by distance with the center of `member`.
`RedisFuture<V>`	`get(K key)` Get the value of a key.
`RedisFuture<Long>`	`getbit(K key, long offset)` Returns the bit value at offset in the string value stored at key.
`RedisFuture<V>`	`getrange(K key, long start, long end)` Get a substring of the string stored at a key.
`RedisFuture<V>`	`getset(K key, V value)` Set the string value of a key and return its old value.
`RedisFuture<Long>`	`hdel(K key, K... fields)` Delete one or more hash fields.
`RedisFuture<Boolean>`	`hexists(K key, K field)` Determine if a hash field exists.
`RedisFuture<V>`	`hget(K key, K field)` Get the value of a hash field.
`RedisFuture<Map<K,V>>`	`hgetall(K key)` Get all the fields and values in a hash.
`RedisFuture<Long>`	`hgetall(KeyValueStreamingChannel<K,V> channel, K key)` Stream over all the fields and values in a hash.
`RedisFuture<Long>`	`hincrby(K key, K field, long amount)` Increment the integer value of a hash field by the given number.
`RedisFuture<Double>`	`hincrbyfloat(K key, K field, double amount)` Increment the float value of a hash field by the given amount.
`RedisFuture<List<K>>`	`hkeys(K key)` Get all the fields in a hash.
`RedisFuture<Long>`	`hkeys(KeyStreamingChannel<K> channel, K key)` Get all the fields in a hash.
`RedisFuture<Long>`	`hlen(K key)` Get the number of fields in a hash.
`RedisFuture<List<V>>`	`hmget(K key, K... fields)` Get the values of all the given hash fields.
`RedisFuture<Long>`	`hmget(ValueStreamingChannel<V> channel, K key, K... fields)` Stream over the values of all the given hash fields.
`RedisFuture<String>`	`hmset(K key, Map<K,V> map)` Set multiple hash fields to multiple values.
`RedisFuture<MapScanCursor<K,V>>`	`hscan(K key)` Incrementally iterate hash fields and associated values.
`RedisFuture<StreamScanCursor>`	`hscan(KeyValueStreamingChannel<K,V> channel, K key)` Incrementally iterate hash fields and associated values.
`RedisFuture<StreamScanCursor>`	`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanArgs scanArgs)` Incrementally iterate hash fields and associated values.
`RedisFuture<StreamScanCursor>`	`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor)` Incrementally iterate hash fields and associated values.
`RedisFuture<StreamScanCursor>`	`hscan(KeyValueStreamingChannel<K,V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate hash fields and associated values.
`RedisFuture<MapScanCursor<K,V>>`	`hscan(K key, ScanArgs scanArgs)` Incrementally iterate hash fields and associated values.
`RedisFuture<MapScanCursor<K,V>>`	`hscan(K key, ScanCursor scanCursor)` Incrementally iterate hash fields and associated values.
`RedisFuture<MapScanCursor<K,V>>`	`hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate hash fields and associated values.
`RedisFuture<Boolean>`	`hset(K key, K field, V value)` Set the string value of a hash field.
`RedisFuture<Boolean>`	`hsetnx(K key, K field, V value)` Set the value of a hash field, only if the field does not exist.
`RedisFuture<Long>`	`hstrlen(K key, K field)` Get the string length of the field value in a hash.
`RedisFuture<List<V>>`	`hvals(K key)` Get all the values in a hash.
`RedisFuture<Long>`	`hvals(ValueStreamingChannel<V> channel, K key)` Stream over all the values in a hash.
`RedisFuture<Long>`	`incr(K key)` Increment the integer value of a key by one.
`RedisFuture<Long>`	`incrby(K key, long amount)` Increment the integer value of a key by the given amount.
`RedisFuture<Double>`	`incrbyfloat(K key, double amount)` Increment the float value of a key by the given amount.
`RedisFuture<String>`	`info()` Get information and statistics about the server.
`RedisFuture<String>`	`info(String section)` Get information and statistics about the server.
`protected boolean`	`isMulti()`
`RedisFuture<List<K>>`	`keys(K pattern)` Find all keys matching the given pattern.
`RedisFuture<Long>`	`keys(KeyStreamingChannel<K> channel, K pattern)` Find all keys matching the given pattern.
`RedisFuture<Date>`	`lastsave()` Get the UNIX time stamp of the last successful save to disk.
`RedisFuture<V>`	`lindex(K key, long index)` Get an element from a list by its index.
`RedisFuture<Long>`	`linsert(K key, boolean before, V pivot, V value)` Insert an element before or after another element in a list.
`RedisFuture<Long>`	`llen(K key)` Get the length of a list.
`RedisFuture<V>`	`lpop(K key)` Remove and get the first element in a list.
`RedisFuture<Long>`	`lpush(K key, V... values)` Prepend one or multiple values to a list.
`RedisFuture<Long>`	`lpushx(K key, V value)` Prepend a value to a list, only if the list exists.
`RedisFuture<List<V>>`	`lrange(K key, long start, long stop)` Get a range of elements from a list.
`RedisFuture<Long>`	`lrange(ValueStreamingChannel<V> channel, K key, long start, long stop)` Get a range of elements from a list.
`RedisFuture<Long>`	`lrem(K key, long count, V value)` Remove elements from a list.
`RedisFuture<String>`	`lset(K key, long index, V value)` Set the value of an element in a list by its index.
`RedisFuture<String>`	`ltrim(K key, long start, long stop)` Trim a list to the specified range.
`RedisFuture<List<V>>`	`mget(K... keys)` Get the values of all the given keys.
`RedisFuture<Long>`	`mget(ValueStreamingChannel<V> channel, K... keys)` Stream the values of all the given keys.
`RedisFuture<String>`	`migrate(String host, int port, K key, int db, long timeout)` Atomically transfer a key from a Redis instance to another one.
`RedisFuture<Boolean>`	`move(K key, int db)` Move a key to another database.
`RedisFuture<String>`	`mset(Map<K,V> map)` Set multiple keys to multiple values.
`RedisFuture<Boolean>`	`msetnx(Map<K,V> map)` Set multiple keys to multiple values, only if none of the keys exist.
`RedisFuture<String>`	`multi()` Mark the start of a transaction block.
`RedisFuture<String>`	`objectEncoding(K key)` returns the kind of internal representation used in order to store the value associated with a key.
`RedisFuture<Long>`	`objectIdletime(K key)` returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).
`RedisFuture<Long>`	`objectRefcount(K key)` returns the number of references of the value associated with the specified key.
`RedisFuture<Boolean>`	`persist(K key)` Remove the expiration from a key.
`RedisFuture<Boolean>`	`pexpire(K key, long milliseconds)` Set a key's time to live in milliseconds.
`RedisFuture<Boolean>`	`pexpireat(K key, Date timestamp)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`RedisFuture<Boolean>`	`pexpireat(K key, long timestamp)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`RedisFuture<Long>`	`pfadd(K key, V value, V... moreValues)` Adds the specified elements to the specified HyperLogLog.
`RedisFuture<Long>`	`pfcount(K key, K... moreKeys)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
`RedisFuture<String>`	`pfmerge(K destkey, K sourcekey, K... moreSourceKeys)` Merge N different HyperLogLogs into a single one.
`RedisFuture<String>`	`ping()` Ping the server.
`RedisFuture<String>`	`psetex(K key, long milliseconds, V value)` Set the value and expiration in milliseconds of a key.
`RedisFuture<Long>`	`pttl(K key)` Get the time to live for a key in milliseconds.
`RedisFuture<Long>`	`publish(K channel, V message)` Post a message to a channel.
`RedisFuture<List<K>>`	`pubsubChannels()` Lists the currently active channels.
`RedisFuture<List<K>>`	`pubsubChannels(K channel)` Lists the currently active channels.
`RedisFuture<Long>`	`pubsubNumpat()` Returns the number of subscriptions to patterns.
`RedisFuture<Map<K,Long>>`	`pubsubNumsub(K... channels)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels.
`RedisFuture<String>`	`quit()` Close the connection.
`RedisFuture<V>`	`randomkey()` Return a random key from the keyspace.
`String`	`readOnly()` Tells a Redis cluster slave node that the client is ok reading possibly stale data and is not interested in running write queries.
`String`	`readWrite()` Resets readOnly flag.
`RedisFuture<String>`	`rename(K key, K newKey)` Rename a key.
`RedisFuture<Boolean>`	`renamenx(K key, K newKey)` Rename a key, only if the new key does not exist.
`RedisFuture<String>`	`restore(K key, long ttl, byte[] value)` Create a key using the provided serialized value, previously obtained using DUMP.
`RedisFuture<List<Object>>`	`role()` Return the role of the instance in the context of replication.
`RedisFuture<V>`	`rpop(K key)` Remove and get the last element in a list.
`RedisFuture<V>`	`rpoplpush(K source, K destination)` Remove the last element in a list, append it to another list and return it.
`RedisFuture<Long>`	`rpush(K key, V... values)` Append one or multiple values to a list.
`RedisFuture<Long>`	`rpushx(K key, V value)` Append a value to a list, only if the list exists.
`RedisFuture<Long>`	`sadd(K key, V... members)` Add one or more members to a set.
`RedisFuture<String>`	`save()` Synchronously save the dataset to disk.
`RedisFuture<KeyScanCursor<K>>`	`scan()` Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel)` Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs)` Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor)` Incrementally iterate the keys space.
`RedisFuture<StreamScanCursor>`	`scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	`scan(ScanArgs scanArgs)` Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	`scan(ScanCursor scanCursor)` Incrementally iterate the keys space.
`RedisFuture<KeyScanCursor<K>>`	`scan(ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate the keys space.
`RedisFuture<Long>`	`scard(K key)` Get the number of members in a set.
`RedisFuture<List<Boolean>>`	`scriptExists(String... digests)` Check existence of scripts in the script cache.
`RedisFuture<String>`	`scriptFlush()` Remove all the scripts from the script cache.
`RedisFuture<String>`	`scriptKill()` Kill the script currently in execution.
`RedisFuture<String>`	`scriptLoad(V script)` Load the specified Lua script into the script cache.
`RedisFuture<Set<V>>`	`sdiff(K... keys)` Subtract multiple sets.
`RedisFuture<Long>`	`sdiff(ValueStreamingChannel<V> channel, K... keys)` Subtract multiple sets.
`RedisFuture<Long>`	`sdiffstore(K destination, K... keys)` Subtract multiple sets and store the resulting set in a key.
`String`	`select(int db)` Change the selected database for the current connection.
`RedisFuture<String>`	`set(K key, V value)` Set the string value of a key.
`RedisFuture<String>`	`set(K key, V value, SetArgs setArgs)` Set the string value of a key.
`RedisFuture<Long>`	`setbit(K key, long offset, int value)` Sets or clears the bit at offset in the string value stored at key.
`RedisFuture<String>`	`setex(K key, long seconds, V value)` Set the value and expiration of a key.
`RedisFuture<Boolean>`	`setnx(K key, V value)` Set the value of a key, only if the key does not exist.
`RedisFuture<Long>`	`setrange(K key, long offset, V value)` Overwrite part of a string at key starting at the specified offset.
`void`	`shutdown()` Deprecated.
`void`	`shutdown(boolean save)` Synchronously save the dataset to disk and then shut down the server.
`RedisFuture<Set<V>>`	`sinter(K... keys)` Intersect multiple sets.
`RedisFuture<Long>`	`sinter(ValueStreamingChannel<V> channel, K... keys)` Intersect multiple sets.
`RedisFuture<Long>`	`sinterstore(K destination, K... keys)` Intersect multiple sets and store the resulting set in a key.
`RedisFuture<Boolean>`	`sismember(K key, V member)` Determine if a given value is a member of a set.
`RedisFuture<String>`	`slaveof(String host, int port)` Make the server a slave of another instance.
`RedisFuture<String>`	`slaveofNoOne()` Promote server as master.
`RedisFuture<List<Object>>`	`slowlogGet()` Read the slow log.
`RedisFuture<List<Object>>`	`slowlogGet(int count)` Read the slow log.
`RedisFuture<Long>`	`slowlogLen()` Obtaining the current length of the slow log.
`RedisFuture<String>`	`slowlogReset()` Resetting the slow log.
`RedisFuture<Set<V>>`	`smembers(K key)` Get all the members in a set.
`RedisFuture<Long>`	`smembers(ValueStreamingChannel<V> channel, K key)` Get all the members in a set.
`RedisFuture<Boolean>`	`smove(K source, K destination, V member)` Move a member from one set to another.
`RedisFuture<List<V>>`	`sort(K key)` Sort the elements in a list, set or sorted set.
`RedisFuture<List<V>>`	`sort(K key, SortArgs sortArgs)` Sort the elements in a list, set or sorted set.
`RedisFuture<Long>`	`sort(ValueStreamingChannel<V> channel, K key)` Sort the elements in a list, set or sorted set.
`RedisFuture<Long>`	`sort(ValueStreamingChannel<V> channel, K key, SortArgs sortArgs)` Sort the elements in a list, set or sorted set.
`RedisFuture<Long>`	`sortStore(K key, SortArgs sortArgs, K destination)` Sort the elements in a list, set or sorted set.
`RedisFuture<V>`	`spop(K key)` Remove and return a random member from a set.
`RedisFuture<V>`	`srandmember(K key)` Get one or multiple random members from a set.
`RedisFuture<Set<V>>`	`srandmember(K key, long count)` Get one or multiple random members from a set.
`RedisFuture<Long>`	`srandmember(ValueStreamingChannel<V> channel, K key, long count)` Get one or multiple random members from a set.
`RedisFuture<Long>`	`srem(K key, V... members)` Remove one or more members from a set.
`RedisFuture<ValueScanCursor<V>>`	`sscan(K key)` Incrementally iterate Set elements.
`RedisFuture<ValueScanCursor<V>>`	`sscan(K key, ScanArgs scanArgs)` Incrementally iterate Set elements.
`RedisFuture<ValueScanCursor<V>>`	`sscan(K key, ScanCursor scanCursor)` Incrementally iterate Set elements.
`RedisFuture<ValueScanCursor<V>>`	`sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate Set elements.
`RedisFuture<StreamScanCursor>`	`sscan(ValueStreamingChannel<V> channel, K key)` Incrementally iterate Set elements.
`RedisFuture<StreamScanCursor>`	`sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)` Incrementally iterate Set elements.
`RedisFuture<StreamScanCursor>`	`sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)` Incrementally iterate Set elements.
`RedisFuture<StreamScanCursor>`	`sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate Set elements.
`static String`	`string(double n)`
`RedisFuture<Long>`	`strlen(K key)` Get the length of the value stored in a key.
`RedisFuture<Set<V>>`	`sunion(K... keys)` Add multiple sets.
`RedisFuture<Long>`	`sunion(ValueStreamingChannel<V> channel, K... keys)` Add multiple sets.
`RedisFuture<Long>`	`sunionstore(K destination, K... keys)` Add multiple sets and store the resulting set in a key.
`RedisFuture<String>`	`sync()` Internal command used for replication.
`RedisFuture<List<V>>`	`time()` Return the current server time.
`RedisFuture<Long>`	`ttl(K key)` Get the time to live for a key.
`RedisFuture<String>`	`type(K key)` Determine the type stored at key.
`RedisFuture<Long>`	`unlink(K... keys)` Unlink one or more keys (non blocking DEL).
`RedisFuture<String>`	`unwatch()` Forget about all watched keys.
`RedisFuture<Long>`	`waitForReplication(int replicas, long timeout)` Wait for replication.
`RedisFuture<String>`	`watch(K... keys)` Watch the given keys to determine execution of the MULTI/EXEC block.
`RedisFuture<Long>`	`zadd(K key, double score, V member)` Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	`zadd(K key, Object... scoresAndValues)` Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	`zadd(K key, ZAddArgs zAddArgs, double score, V member)` Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Long>`	`zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues)` Add one or more members to a sorted set, or update its score if it already exists.
`RedisFuture<Double>`	`zaddincr(K key, double score, V member)` ZADD acts like ZINCRBY
`RedisFuture<Long>`	`zcard(K key)` Get the number of members in a sorted set.
`RedisFuture<Long>`	`zcount(K key, double min, double max)` Count the members in a sorted set with scores within the given values.
`RedisFuture<Long>`	`zcount(K key, String min, String max)` Count the members in a sorted set with scores within the given values.
`RedisFuture<Double>`	`zincrby(K key, double amount, K member)` Increment the score of a member in a sorted set.
`RedisFuture<Long>`	`zinterstore(K destination, K... keys)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<Long>`	`zinterstore(K destination, ZStoreArgs storeArgs, K... keys)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<Long>`	`zlexcount(K key, String min, String max)` Count the number of members in a sorted set between a given lexicographical range.
`RedisFuture<List<V>>`	`zrange(K key, long start, long stop)` Return a range of members in a sorted set, by index.
`RedisFuture<Long>`	`zrange(ValueStreamingChannel<V> channel, K key, long start, long stop)` Stream over a range of members in a sorted set, by index.
`RedisFuture<List<V>>`	`zrangebylex(K key, String min, String max)` Return a range of members in a sorted set, by lexicographical range.
`RedisFuture<List<V>>`	`zrangebylex(K key, String min, String max, long offset, long count)` Return a range of members in a sorted set, by lexicographical range.
`RedisFuture<List<V>>`	`zrangebyscore(K key, double min, double max)` Return a range of members in a sorted set, by score.
`RedisFuture<List<V>>`	`zrangebyscore(K key, double min, double max, long offset, long count)` Return a range of members in a sorted set, by score.
`RedisFuture<List<V>>`	`zrangebyscore(K key, String min, String max)` Return a range of members in a sorted set, by score.
`RedisFuture<List<V>>`	`zrangebyscore(K key, String min, String max, long offset, long count)` Return a range of members in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max)` Stream over a range of members in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)` Stream over a range of members in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max)` Stream over a range of members in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)` Stream over a range of members in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, double min, double max)` Return a range of members with score in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, double min, double max, long offset, long count)` Return a range of members with score in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, String min, String max)` Return a range of members with score in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	`zrangebyscoreWithScores(K key, String min, String max, long offset, long count)` Return a range of members with score in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max)` Stream over a range of members with scores in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max, long offset, long count)` Stream over a range of members with scores in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max)` Stream over a range of members with scores in a sorted set, by score.
`RedisFuture<Long>`	`zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max, long offset, long count)` Stream over a range of members with scores in a sorted set, by score.
`RedisFuture<List<ScoredValue<V>>>`	`zrangeWithScores(K key, long start, long stop)` Return a range of members in a sorted set, by index.
`RedisFuture<Long>`	`zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)` Stream over a range of members with scores in a sorted set, by index.
`RedisFuture<Long>`	`zrank(K key, V member)` Determine the index of a member in a sorted set.
`RedisFuture<Long>`	`zrem(K key, V... members)` Remove one or more members from a sorted set.
`RedisFuture<Long>`	`zremrangebylex(K key, String min, String max)` Remove all members in a sorted set between the given lexicographical range.
`RedisFuture<Long>`	`zremrangebyrank(K key, long start, long stop)` Remove all members in a sorted set within the given indexes.
`RedisFuture<Long>`	`zremrangebyscore(K key, double min, double max)` Remove all members in a sorted set within the given scores.
`RedisFuture<Long>`	`zremrangebyscore(K key, String min, String max)` Remove all members in a sorted set within the given scores.
`RedisFuture<List<V>>`	`zrevrange(K key, long start, long stop)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop)` Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, double max, double min)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, double max, double min, long offset, long count)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, String max, String min)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<V>>`	`zrevrangebyscore(K key, String max, String min, long offset, long count)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min)` Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)` Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min)` Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)` Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, double max, double min)` Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count)` Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, String max, String min)` Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count)` Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min)` Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min, long offset, long count)` Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min)` Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min, long offset, long count)` Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
`RedisFuture<List<ScoredValue<V>>>`	`zrevrangeWithScores(K key, long start, long stop)` Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop)` Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
`RedisFuture<Long>`	`zrevrank(K key, V member)` Determine the index of a member in a sorted set, with scores ordered from high to low.
`RedisFuture<ScoredValueScanCursor<V>>`	`zscan(K key)` Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	`zscan(K key, ScanArgs scanArgs)` Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	`zscan(K key, ScanCursor scanCursor)` Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<ScoredValueScanCursor<V>>`	`zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key)` Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanArgs scanArgs)` Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor)` Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<StreamScanCursor>`	`zscan(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs)` Incrementally iterate sorted sets elements and associated scores.
`RedisFuture<Double>`	`zscore(K key, V member)` Get the score associated with the given member in a sorted set.
`RedisFuture<Long>`	`zunionstore(K destination, K... keys)` Add multiple sorted sets and store the resulting sorted set in a new key.
`RedisFuture<Long>`	`zunionstore(K destination, ZStoreArgs storeArgs, K... keys)` Add multiple sorted sets and store the resulting sorted set in a new key.

Methods inherited from class com.lambdaworks.redis.RedisChannelHandler
addListener, channelRead, channelRead, channelRegistered, close, deactivated, flushCommands, getChannelWriter, getOptions, getTimeout, getTimeoutUnit, isClosed, isOpen, registerCloseables, reset, setAutoFlushCommands, setOptions, setTimeout

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter
channelActive, channelInactive, channelReadComplete, channelUnregistered, channelWritabilityChanged, exceptionCaught, userEventTriggered

Methods inherited from class io.netty.channel.ChannelHandlerAdapter
handlerAdded, handlerRemoved, isSharable

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

Methods inherited from interface com.lambdaworks.redis.RedisAsyncConnection
setTimeout

Methods inherited from interface com.lambdaworks.redis.RedisClusterAsyncConnection
close

Methods inherited from interface com.lambdaworks.redis.BaseRedisAsyncConnection
flushCommands, isOpen, setAutoFlushCommands

Methods inherited from interface io.netty.channel.ChannelHandler
handlerAdded, handlerRemoved

- Field Detail
  - multi
```
protected MultiOutput<K,V> multi
```
  - commandBuilder
```
protected com.lambdaworks.redis.RedisCommandBuilder<K,V> commandBuilder
```
  - codec
```
protected RedisCodec<K,V> codec
```
- Constructor Detail
  - RedisAsyncConnectionImpl
```
public RedisAsyncConnectionImpl(RedisChannelWriter<K,V> writer,
                                RedisCodec<K,V> codec,
                                long timeout,
                                TimeUnit unit)
```
    Initialize a new connection.
    
    Parameters:
    
    writer - the channel writer
    
    codec - Codec used to encode/decode keys and values.
    
    timeout - Maximum time to wait for a response.
    
    unit - Unit of time for the timeout.
- Method Detail
  - append
```
public RedisFuture<Long> append(K key,
                                V value)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Append a value to a key.
    
    Specified by:
    
    append in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the string after the append operation.
  - auth
```
public String auth(String password)
```
    Description copied from interface: RedisAsyncConnection
    
    Authenticate to the server.
    
    Specified by:
    
    auth in interface RedisAsyncConnection<K,V>
    
    Parameters:
    
    password - the password
    
    Returns:
    
    String simple-string-reply
  - bgrewriteaof
```
public RedisFuture<String> bgrewriteaof()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Asynchronously rewrite the append-only file.
    
    Specified by:
    
    bgrewriteaof in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply always OK.
  - bgsave
```
public RedisFuture<String> bgsave()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Asynchronously save the dataset to disk.
    
    Specified by:
    
    bgsave in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - bitcount
```
public RedisFuture<Long> bitcount(K key)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Count set bits in a string.
    
    Specified by:
    
    bitcount in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply The number of bits set to 1.
  - bitcount
```
public RedisFuture<Long> bitcount(K key,
                                  long start,
                                  long end)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Count set bits in a string.
    
    Specified by:
    
    bitcount in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start
    
    end - the end
    
    Returns:
    
    RedisFuture<Long> integer-reply The number of bits set to 1.
  - bitpos
```
public RedisFuture<Long> bitpos(K key,
                                boolean state)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Find first bit set or clear in a string.
    
    Specified by:
    
    bitpos in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    state - the state
    
    Returns:
    
    RedisFuture<Long> integer-reply The command returns the position of the first bit set to 1 or 0 according to the request. If we look for set bits (the bit argument is 1) and the string is empty or composed of just zero bytes, -1 is returned. If we look for clear bits (the bit argument is 0) and the string only contains bit set to 1, the function returns the first bit not part of the string on the right. So if the string is tree bytes set to the value 0xff the command BITPOS key 0 will return 24, since up to bit 23 all the bits are 1. Basically the function consider the right of the string as padded with zeros if you look for clear bits and specify no range or the start argument only. However this behavior changes if you are looking for clear bits and specify a range with both end and end. If no clear bit is found in the specified range, the function returns -1 as the user specified a clear range and there are no 0 bits in that range.
  - bitpos
```
public RedisFuture<Long> bitpos(K key,
                                boolean state,
                                long start,
                                long end)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Find first bit set or clear in a string.
    
    Specified by:
    
    bitpos in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    state - the bit type: long
    
    start - the start type: long
    
    end - the end type: long
    
    Returns:
    
    RedisFuture<Long> integer-reply The command returns the position of the first bit set to 1 or 0 according to the request. If we look for set bits (the bit argument is 1) and the string is empty or composed of just zero bytes, -1 is returned. If we look for clear bits (the bit argument is 0) and the string only contains bit set to 1, the function returns the first bit not part of the string on the right. So if the string is tree bytes set to the value 0xff the command BITPOS key 0 will return 24, since up to bit 23 all the bits are 1. Basically the function consider the right of the string as padded with zeros if you look for clear bits and specify no range or the start argument only. However this behavior changes if you are looking for clear bits and specify a range with both start and end. If no clear bit is found in the specified range, the function returns -1 as the user specified a clear range and there are no 0 bits in that range.
  - bitopAnd
```
public RedisFuture<Long> bitopAnd(K destination,
                                  K... keys)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Perform bitwise AND between strings.
    
    Specified by:
    
    bitopAnd in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    destination - result key of the operation
    
    keys - operation input key names
    
    Returns:
    
    RedisFuture<Long> integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.
  - bitopNot
```
public RedisFuture<Long> bitopNot(K destination,
                                  K source)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Perform bitwise NOT between strings.
    
    Specified by:
    
    bitopNot in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    destination - result key of the operation
    
    source - operation input key names
    
    Returns:
    
    RedisFuture<Long> integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.
  - bitopOr
```
public RedisFuture<Long> bitopOr(K destination,
                                 K... keys)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Perform bitwise OR between strings.
    
    Specified by:
    
    bitopOr in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    destination - result key of the operation
    
    keys - operation input key names
    
    Returns:
    
    RedisFuture<Long> integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.
  - bitopXor
```
public RedisFuture<Long> bitopXor(K destination,
                                  K... keys)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Perform bitwise XOR between strings.
    
    Specified by:
    
    bitopXor in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    destination - result key of the operation
    
    keys - operation input key names
    
    Returns:
    
    RedisFuture<Long> integer-reply The size of the string stored in the destination key, that is equal to the size of the longest input string.
  - blpop
```
public RedisFuture<KeyValue<K,V>> blpop(long timeout,
                                        K... keys)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Remove and get the first element in a list, or block until one is available.
    
    Specified by:
    
    blpop in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    timeout - the key
    
    keys - the timeout type: long
    
    Returns:
    
    RedisFuture<KeyValue<K,V>> array-reply specifically: A null multi-bulk when no element could be popped and the timeout expired. A two-element multi-bulk with the first element being the name of the key where an element was popped and the second element being the value of the popped element.
  - brpop
```
public RedisFuture<KeyValue<K,V>> brpop(long timeout,
                                        K... keys)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Remove and get the last element in a list, or block until one is available.
    
    Specified by:
    
    brpop in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    timeout - the key
    
    keys - the timeout type: long
    
    Returns:
    
    RedisFuture<KeyValue<K,V>> array-reply specifically: A null multi-bulk when no element could be popped and the timeout expired. A two-element multi-bulk with the first element being the name of the key where an element was popped and the second element being the value of the popped element.
  - brpoplpush
```
public RedisFuture<V> brpoplpush(long timeout,
                                 K source,
                                 K destination)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Pop a value from a list, push it to another list and return it; or block until one is available.
    
    Specified by:
    
    brpoplpush in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    timeout - the source type: key
    
    source - the destination type: key
    
    destination - the timeout type: long
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the element being popped from source and pushed to destination. If timeout is reached, a
  - clientGetname
```
public RedisFuture<K> clientGetname()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get the current connection name.
    
    Specified by:
    
    clientGetname in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<K> bulk-string-reply The connection name, or a null bulk reply if no name is set.
  - clientSetname
```
public RedisFuture<String> clientSetname(K name)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Set the current connection name.
    
    Specified by:
    
    clientSetname in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    name - the client name
    
    Returns:
    
    RedisFuture<String> simple-string-reply OK if the connection name was successfully set.
  - clientKill
```
public RedisFuture<String> clientKill(String addr)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Kill the connection of a client identified by ip:port.
    
    Specified by:
    
    clientKill in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    addr - the addr in format ip:port
    
    Returns:
    
    RedisFuture<String> simple-string-reply OK if the connection exists and has been closed
  - clientKill
```
public RedisFuture<Long> clientKill(KillArgs killArgs)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Kill connections of clients which are filtered by killArgs
    
    Specified by:
    
    clientKill in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    killArgs - args for the kill operation
    
    Returns:
    
    RedisFuture<Long> integer-reply number of killed connections
  - clientPause
```
public RedisFuture<String> clientPause(long timeout)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Stop processing commands from clients for some time.
    
    Specified by:
    
    clientPause in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    timeout - the timeout value in milliseconds
    
    Returns:
    
    RedisFuture<String> simple-string-reply The command returns OK or an error if the timeout is invalid.
  - clientList
```
public RedisFuture<String> clientList()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get the list of client connections.
    
    Specified by:
    
    clientList in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> bulk-string-reply a unique string, formatted as follows: One client connection per line (separated by LF), each line is composed of a succession of property=value fields separated by a space character.
  - command
```
public RedisFuture<List<Object>> command()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Returns an array reply of details about all Redis commands.
    
    Specified by:
    
    command in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<List<Object>> array-reply
  - commandInfo
```
public RedisFuture<List<Object>> commandInfo(String... commands)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Returns an array reply of details about the requested commands.
    
    Specified by:
    
    commandInfo in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    commands - the commands to query for
    
    Returns:
    
    RedisFuture<List<Object>> array-reply
  - commandInfo
```
public RedisFuture<List<Object>> commandInfo(CommandType... commands)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Returns an array reply of details about the requested commands.
    
    Specified by:
    
    commandInfo in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    commands - the commands to query for
    
    Returns:
    
    RedisFuture<List<Object>> array-reply
  - commandCount
```
public RedisFuture<Long> commandCount()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get total number of Redis commands.
    
    Specified by:
    
    commandCount in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<Long> integer-reply of number of total commands in this Redis server.
  - configGet
```
public RedisFuture<List<String>> configGet(String parameter)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get the value of a configuration parameter.
    
    Specified by:
    
    configGet in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    parameter - the parameter
    
    Returns:
    
    RedisFuture<List<String>> bulk-string-reply
  - configResetstat
```
public RedisFuture<String> configResetstat()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Reset the stats returned by INFO.
    
    Specified by:
    
    configResetstat in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply always OK.
  - configSet
```
public RedisFuture<String> configSet(String parameter,
                                     String value)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Set a configuration parameter to the given value.
    
    Specified by:
    
    configSet in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    parameter - the parameter name
    
    value - the parameter value
    
    Returns:
    
    RedisFuture<String> simple-string-reply: OK when the configuration was set properly. Otherwise an error is returned.
  - configRewrite
```
public RedisFuture<String> configRewrite()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Rewrite the configuration file with the in memory configuration.
    
    Specified by:
    
    configRewrite in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply OK when the configuration was rewritten properly. Otherwise an error is returned.
  - dbsize
```
public RedisFuture<Long> dbsize()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Return the number of keys in the selected database.
    
    Specified by:
    
    dbsize in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<Long> integer-reply
  - debugObject
```
public RedisFuture<String> debugObject(K key)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get debugging information about a key.
    
    Specified by:
    
    debugObject in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - debugSegfault
```
public void debugSegfault()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Make the server crash: Invalid pointer access.
    
    Specified by:
    
    debugSegfault in interface RedisServerAsyncConnection<K,V>
  - debugOom
```
public void debugOom()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Make the server crash: Out of memory.
    
    Specified by:
    
    debugOom in interface RedisServerAsyncConnection<K,V>
  - debugHtstats
```
public RedisFuture<String> debugHtstats(int db)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get debugging information about the internal hash-table state.
    
    Specified by:
    
    debugHtstats in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    db - the database number
    
    Returns:
    
    String simple-string-reply
  - decr
```
public RedisFuture<Long> decr(K key)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Decrement the integer value of a key by one.
    
    Specified by:
    
    decr in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the value of key after the decrement
  - decrby
```
public RedisFuture<Long> decrby(K key,
                                long amount)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Decrement the integer value of a key by the given number.
    
    Specified by:
    
    decrby in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    amount - the decrement type: long
    
    Returns:
    
    RedisFuture<Long> integer-reply the value of key after the decrement
  - del
```
public RedisFuture<Long> del(K... keys)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Delete one or more keys.
    
    Specified by:
    
    del in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    RedisFuture<Long> integer-reply The number of keys that were removed.
  - unlink
```
public RedisFuture<Long> unlink(K... keys)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Unlink one or more keys (non blocking DEL).
    
    Specified by:
    
    unlink in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    RedisFuture<Long> integer-reply The number of keys that were removed.
  - discard
```
public RedisFuture<String> discard()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Discard all commands issued after MULTI.
    
    Specified by:
    
    discard in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply always OK.
  - dump
```
public RedisFuture<byte[]> dump(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Return a serialized version of the value stored at the specified key.
    
    Specified by:
    
    dump in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<byte[]>bulk-string-reply the serialized value.
  - echo
```
public RedisFuture<V> echo(V msg)
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Echo the given string.
    
    Specified by:
    
    echo in interface BaseRedisAsyncConnection<K,V>
    
    Parameters:
    
    msg - the message type: value
    
    Returns:
    
    RedisFuture<V> bulk-string-reply
  - eval
```
public <T> RedisFuture<T> eval(String script,
                               ScriptOutputType type,
                               K... keys)
```
    Description copied from interface: RedisScriptingAsyncConnection
    
    Execute a Lua script server side.
    
    Specified by:
    
    eval in interface RedisScriptingAsyncConnection<K,V>
    
    Type Parameters:
    
    T - expected return type
    
    Parameters:
    
    script - Lua 5.1 script.
    
    type - output type
    
    keys - key names
    
    Returns:
    
    script result
  - eval
```
public <T> RedisFuture<T> eval(String script,
                               ScriptOutputType type,
                               K[] keys,
                               V... values)
```
    Description copied from interface: RedisScriptingAsyncConnection
    
    Execute a Lua script server side.
    
    Specified by:
    
    eval in interface RedisScriptingAsyncConnection<K,V>
    
    Type Parameters:
    
    T - expected return type
    
    Parameters:
    
    script - Lua 5.1 script.
    
    type - the type
    
    keys - the keys
    
    values - the values
    
    Returns:
    
    script result
  - evalsha
```
public <T> RedisFuture<T> evalsha(String digest,
                                  ScriptOutputType type,
                                  K... keys)
```
    Description copied from interface: RedisScriptingAsyncConnection
    
    Evaluates a script cached on the server side by its SHA1 digest
    
    Specified by:
    
    evalsha in interface RedisScriptingAsyncConnection<K,V>
    
    Type Parameters:
    
    T - expected return type
    
    Parameters:
    
    digest - SHA1 of the script
    
    type - the type
    
    keys - the keys
    
    Returns:
    
    script result
  - evalsha
```
public <T> RedisFuture<T> evalsha(String digest,
                                  ScriptOutputType type,
                                  K[] keys,
                                  V... values)
```
    Description copied from interface: RedisScriptingAsyncConnection
    
    Execute a Lua script server side.
    
    Specified by:
    
    evalsha in interface RedisScriptingAsyncConnection<K,V>
    
    Type Parameters:
    
    T - expected return type
    
    Parameters:
    
    digest - SHA1 of the script
    
    type - the type
    
    keys - the keys
    
    values - the values
    
    Returns:
    
    script result
  - exists
```
public RedisFuture<Boolean> exists(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Determine if a key exists.
    
    Specified by:
    
    exists in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the key exists. false if the key does not exist.
  - exists
```
public RedisFuture<Long> exists(K... keys)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Determine how many keys exist.
    
    Specified by:
    
    exists in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    keys - the keys
    
    Returns:
    
    Long integer-reply specifically: Number of existing keys
  - expire
```
public RedisFuture<Boolean> expire(K key,
                                   long seconds)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Set a key's time to live in seconds.
    
    Specified by:
    
    expire in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    seconds - the seconds type: long
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.
  - expireat
```
public RedisFuture<Boolean> expireat(K key,
                                     Date timestamp)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Set the expiration for a key as a UNIX timestamp.
    
    Specified by:
    
    expireat in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    timestamp - the timestamp type: posix time
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
  - expireat
```
public RedisFuture<Boolean> expireat(K key,
                                     long timestamp)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Set the expiration for a key as a UNIX timestamp.
    
    Specified by:
    
    expireat in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    timestamp - the timestamp type: posix time
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
  - exec
```
public RedisFuture<List<Object>> exec()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Execute all commands issued after MULTI.
    
    Specified by:
    
    exec in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<List<Object>> array-reply each element being the reply to each of the commands in the atomic transaction. When using WATCH, EXEC can return a
  - flushall
```
public RedisFuture<String> flushall()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Remove all keys from all databases.
    
    Specified by:
    
    flushall in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - flushallAsync
```
public RedisFuture<String> flushallAsync()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Remove all keys asynchronously from all databases.
    
    Specified by:
    
    flushallAsync in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    String simple-string-reply
  - flushdb
```
public RedisFuture<String> flushdb()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Remove all keys from the current database.
    
    Specified by:
    
    flushdb in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - flushdbAsync
```
public RedisFuture<String> flushdbAsync()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Remove all keys asynchronously from the current database.
    
    Specified by:
    
    flushdbAsync in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    String simple-string-reply
  - get
```
public RedisFuture<V> get(K key)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Get the value of a key.
    
    Specified by:
    
    get in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the value of key, or null when key does not exist.
  - getbit
```
public RedisFuture<Long> getbit(K key,
                                long offset)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Returns the bit value at offset in the string value stored at key.
    
    Specified by:
    
    getbit in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    offset - the offset type: long
    
    Returns:
    
    RedisFuture<Long> integer-reply the bit value stored at offset.
  - getrange
```
public RedisFuture<V> getrange(K key,
                               long start,
                               long end)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Get a substring of the string stored at a key.
    
    Specified by:
    
    getrange in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start type: long
    
    end - the end type: long
    
    Returns:
    
    RedisFuture<V> bulk-string-reply
  - getset
```
public RedisFuture<V> getset(K key,
                             V value)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Set the string value of a key and return its old value.
    
    Specified by:
    
    getset in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the old value stored at key, or null when key did not exist.
  - hdel
```
public RedisFuture<Long> hdel(K key,
                              K... fields)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Delete one or more hash fields.
    
    Specified by:
    
    hdel in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    fields - the field type: key
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of fields that were removed from the hash, not including specified but non existing fields.
  - hexists
```
public RedisFuture<Boolean> hexists(K key,
                                    K field)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Determine if a hash field exists.
    
    Specified by:
    
    hexists in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    field - the field type: key
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the hash contains field. false if the hash does not contain field, or key does not exist.
  - hget
```
public RedisFuture<V> hget(K key,
                           K field)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Get the value of a hash field.
    
    Specified by:
    
    hget in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    field - the field type: key
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the value associated with field, or null when field is not present in the hash or key does not exist.
  - hincrby
```
public RedisFuture<Long> hincrby(K key,
                                 K field,
                                 long amount)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Increment the integer value of a hash field by the given number.
    
    Specified by:
    
    hincrby in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    field - the field type: key
    
    amount - the increment type: long
    
    Returns:
    
    RedisFuture<Long> integer-reply the value at field after the increment operation.
  - hincrbyfloat
```
public RedisFuture<Double> hincrbyfloat(K key,
                                        K field,
                                        double amount)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Increment the float value of a hash field by the given amount.
    
    Specified by:
    
    hincrbyfloat in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    field - the field type: key
    
    amount - the increment type: double
    
    Returns:
    
    RedisFuture<Double;> bulk-string-reply the value of field after the increment.
  - hgetall
```
public RedisFuture<Map<K,V>> hgetall(K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Get all the fields and values in a hash.
    
    Specified by:
    
    hgetall in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Map<K,V>> array-reply list of fields and their values stored in the hash, or an empty list when key does not exist.
  - hgetall
```
public RedisFuture<Long> hgetall(KeyValueStreamingChannel<K,V> channel,
                                 K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Stream over all the fields and values in a hash.
    
    Specified by:
    
    hgetall in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    channel - the channel
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> count of the keys.
  - hkeys
```
public RedisFuture<List<K>> hkeys(K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Get all the fields in a hash.
    
    Specified by:
    
    hkeys in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<List<K>> array-reply list of fields in the hash, or an empty list when key does not exist.
  - hkeys
```
public RedisFuture<Long> hkeys(KeyStreamingChannel<K> channel,
                               K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Get all the fields in a hash.
    
    Specified by:
    
    hkeys in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    channel - the channel
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> count of the keys.
  - hlen
```
public RedisFuture<Long> hlen(K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Get the number of fields in a hash.
    
    Specified by:
    
    hlen in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply number of fields in the hash, or false when key does not exist.
  - hstrlen
```
public RedisFuture<Long> hstrlen(K key,
                                 K field)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Get the string length of the field value in a hash.
    
    Specified by:
    
    hstrlen in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    field - the field type: key
    
    Returns:
    
    RedisFuture<Long> integer-reply the string length of the field value, or 0 when field is not present in the hash or key does not exist at all.
  - hmget
```
public RedisFuture<List<V>> hmget(K key,
                                  K... fields)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Get the values of all the given hash fields.
    
    Specified by:
    
    hmget in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    fields - the field type: key
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of values associated with the given fields, in the same
  - hmget
```
public RedisFuture<Long> hmget(ValueStreamingChannel<V> channel,
                               K key,
                               K... fields)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Stream over the values of all the given hash fields.
    
    Specified by:
    
    hmget in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    channel - the channel
    
    key - the key
    
    fields - the fields
    
    Returns:
    
    RedisFuture<Long> count of the keys
  - hmset
```
public RedisFuture<String> hmset(K key,
                                 Map<K,V> map)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Set multiple hash fields to multiple values.
    
    Specified by:
    
    hmset in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    map - the null
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - hset
```
public RedisFuture<Boolean> hset(K key,
                                 K field,
                                 V value)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Set the string value of a hash field.
    
    Specified by:
    
    hset in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    field - the field type: key
    
    value - the value
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if field is a new field in the hash and value was set. false if field already exists in the hash and the value was updated.
  - hsetnx
```
public RedisFuture<Boolean> hsetnx(K key,
                                   K field,
                                   V value)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Set the value of a hash field, only if the field does not exist.
    
    Specified by:
    
    hsetnx in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    field - the field type: key
    
    value - the value
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: 1 if field is a new field in the hash and value was set. 0 if field already exists in the hash and no operation was performed.
  - hvals
```
public RedisFuture<List<V>> hvals(K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Get all the values in a hash.
    
    Specified by:
    
    hvals in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of values in the hash, or an empty list when key does not exist.
  - hvals
```
public RedisFuture<Long> hvals(ValueStreamingChannel<V> channel,
                               K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Stream over all the values in a hash.
    
    Specified by:
    
    hvals in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> count of the keys.
  - incr
```
public RedisFuture<Long> incr(K key)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Increment the integer value of a key by one.
    
    Specified by:
    
    incr in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the value of key after the increment
  - incrby
```
public RedisFuture<Long> incrby(K key,
                                long amount)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Increment the integer value of a key by the given amount.
    
    Specified by:
    
    incrby in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    amount - the increment type: long
    
    Returns:
    
    RedisFuture<Long> integer-reply the value of key after the increment
  - incrbyfloat
```
public RedisFuture<Double> incrbyfloat(K key,
                                       double amount)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Increment the float value of a key by the given amount.
    
    Specified by:
    
    incrbyfloat in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    amount - the increment type: double
    
    Returns:
    
    RedisFuture<Double;> bulk-string-reply the value of key after the increment.
  - info
```
public RedisFuture<String> info()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get information and statistics about the server.
    
    Specified by:
    
    info in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> bulk-string-reply as a collection of text lines.
  - info
```
public RedisFuture<String> info(String section)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get information and statistics about the server.
    
    Specified by:
    
    info in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    section - the section type: string
    
    Returns:
    
    RedisFuture<String> bulk-string-reply as a collection of text lines.
  - keys
```
public RedisFuture<List<K>> keys(K pattern)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    pattern - the pattern type: patternkey (pattern)
    
    Returns:
    
    RedisFuture<List<K>> array-reply list of keys matching pattern.
  - keys
```
public RedisFuture<Long> keys(KeyStreamingChannel<K> channel,
                              K pattern)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    channel - the channel
    
    pattern - the pattern
    
    Returns:
    
    RedisFuture<Long> array-reply list of keys matching pattern.
  - lastsave
```
public RedisFuture<Date> lastsave()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Get the UNIX time stamp of the last successful save to disk.
    
    Specified by:
    
    lastsave in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<Date> integer-reply an UNIX time stamp.
  - lindex
```
public RedisFuture<V> lindex(K key,
                             long index)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Get an element from a list by its index.
    
    Specified by:
    
    lindex in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    index - the index type: long
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the requested element, or null when index is out of range.
  - linsert
```
public RedisFuture<Long> linsert(K key,
                                 boolean before,
                                 V pivot,
                                 V value)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Insert an element before or after another element in a list.
    
    Specified by:
    
    linsert in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    before - the before
    
    pivot - the pivot
    
    value - the value
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the list after the insert operation, or -1 when the value pivot was not found.
  - llen
```
public RedisFuture<Long> llen(K key)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Get the length of a list.
    
    Specified by:
    
    llen in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the list at key.
  - lpop
```
public RedisFuture<V> lpop(K key)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Remove and get the first element in a list.
    
    Specified by:
    
    lpop in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the value of the first element, or null when key does not exist.
  - lpush
```
public RedisFuture<Long> lpush(K key,
                               V... values)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Prepend one or multiple values to a list.
    
    Specified by:
    
    lpush in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    values - the value
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the list after the push operations.
  - lpushx
```
public RedisFuture<Long> lpushx(K key,
                                V value)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Prepend a value to a list, only if the list exists.
    
    Specified by:
    
    lpushx in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the list after the push operation.
  - lrange
```
public RedisFuture<List<V>> lrange(K key,
                                   long start,
                                   long stop)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Get a range of elements from a list.
    
    Specified by:
    
    lrange in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start type: long
    
    stop - the stop type: long
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified range.
  - lrange
```
public RedisFuture<Long> lrange(ValueStreamingChannel<V> channel,
                                K key,
                                long start,
                                long stop)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Get a range of elements from a list.
    
    Specified by:
    
    lrange in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    channel - the channel
    
    key - the key
    
    start - the start type: long
    
    stop - the stop type: long
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - lrem
```
public RedisFuture<Long> lrem(K key,
                              long count,
                              V value)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Remove elements from a list.
    
    Specified by:
    
    lrem in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    count - the count type: long
    
    value - the value
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of removed elements.
  - lset
```
public RedisFuture<String> lset(K key,
                                long index,
                                V value)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Set the value of an element in a list by its index.
    
    Specified by:
    
    lset in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    index - the index type: long
    
    value - the value
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - ltrim
```
public RedisFuture<String> ltrim(K key,
                                 long start,
                                 long stop)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Trim a list to the specified range.
    
    Specified by:
    
    ltrim in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start type: long
    
    stop - the stop type: long
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - migrate
```
public RedisFuture<String> migrate(String host,
                                   int port,
                                   K key,
                                   int db,
                                   long timeout)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Atomically transfer a key from a Redis instance to another one.
    
    Specified by:
    
    migrate in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    host - the host
    
    port - the port
    
    key - the key
    
    db - the database
    
    timeout - the timeout in milliseconds
    
    Returns:
    
    RedisFuture<String> simple-string-reply The command returns OK on success.
  - mget
```
public RedisFuture<List<V>> mget(K... keys)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Get the values of all the given keys.
    
    Specified by:
    
    mget in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    keys - the key
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of values at the specified keys.
  - mget
```
public RedisFuture<Long> mget(ValueStreamingChannel<V> channel,
                              K... keys)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Stream the values of all the given keys.
    
    Specified by:
    
    mget in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    channel - the channel
    
    keys - the keys
    
    Returns:
    
    RedisFuture<Long> array-reply list of values at the specified keys.
  - move
```
public RedisFuture<Boolean> move(K key,
                                 int db)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Move a key to another database.
    
    Specified by:
    
    move in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    db - the db type: long
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically:
  - multi
```
public RedisFuture<String> multi()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Mark the start of a transaction block.
    
    Specified by:
    
    multi in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply always OK.
  - mset
```
public RedisFuture<String> mset(Map<K,V> map)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Set multiple keys to multiple values.
    
    Specified by:
    
    mset in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    map - the null
    
    Returns:
    
    RedisFuture<String> simple-string-reply always OK since MSET can't fail.
  - msetnx
```
public RedisFuture<Boolean> msetnx(Map<K,V> map)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Set multiple keys to multiple values, only if none of the keys exist.
    
    Specified by:
    
    msetnx in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    map - the null
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: 1 if the all the keys were set. 0 if no key was set (at least one key already existed).
  - objectEncoding
```
public RedisFuture<String> objectEncoding(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    returns the kind of internal representation used in order to store the value associated with a key.
    
    Specified by:
    
    objectEncoding in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<String>
  - objectIdletime
```
public RedisFuture<Long> objectIdletime(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    returns the number of seconds since the object stored at the specified key is idle (not requested by read or write operations).
    
    Specified by:
    
    objectIdletime in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> number of seconds since the object stored at the specified key is idle.
  - objectRefcount
```
public RedisFuture<Long> objectRefcount(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    returns the number of references of the value associated with the specified key.
    
    Specified by:
    
    objectRefcount in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long>
  - persist
```
public RedisFuture<Boolean> persist(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Remove the expiration from a key.
    
    Specified by:
    
    persist in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the timeout was removed. false if key does not exist or does not have an associated timeout.
  - pexpire
```
public RedisFuture<Boolean> pexpire(K key,
                                    long milliseconds)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Set a key's time to live in milliseconds.
    
    Specified by:
    
    pexpire in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    milliseconds - the milliseconds type: long
    
    Returns:
    
    integer-reply, specifically: true if the timeout was set. false if key does not exist or the timeout could not be set.
  - pexpireat
```
public RedisFuture<Boolean> pexpireat(K key,
                                      Date timestamp)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    
    Specified by:
    
    pexpireat in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    timestamp - the milliseconds-timestamp type: posix time
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
  - pexpireat
```
public RedisFuture<Boolean> pexpireat(K key,
                                      long timestamp)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    
    Specified by:
    
    pexpireat in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    timestamp - the milliseconds-timestamp type: posix time
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the timeout was set. false if key does not exist or the timeout could not be set (see: EXPIRE).
  - ping
```
public RedisFuture<String> ping()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Ping the server.
    
    Specified by:
    
    ping in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - readOnly
```
public String readOnly()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Tells a Redis cluster slave node that the client is ok reading possibly stale data and is not interested in running write queries.
    
    Specified by:
    
    readOnly in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    String simple-string-reply
  - readWrite
```
public String readWrite()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Resets readOnly flag.
    
    Specified by:
    
    readWrite in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    String simple-string-reply
  - pttl
```
public RedisFuture<Long> pttl(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Get the time to live for a key in milliseconds.
    
    Specified by:
    
    pttl in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply TTL in milliseconds, or a negative value in order to signal an error (see the description above).
  - publish
```
public RedisFuture<Long> publish(K channel,
                                 V message)
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Post a message to a channel.
    
    Specified by:
    
    publish in interface BaseRedisAsyncConnection<K,V>
    
    Parameters:
    
    channel - the channel type: key
    
    message - the message type: value
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of clients that received the message.
  - pubsubChannels
```
public RedisFuture<List<K>> pubsubChannels()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Lists the currently *active channels*.
    
    Specified by:
    
    pubsubChannels in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<List<K>> array-reply a list of active channels, optionally matching the specified pattern.
  - pubsubChannels
```
public RedisFuture<List<K>> pubsubChannels(K channel)
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Lists the currently *active channels*.
    
    Specified by:
    
    pubsubChannels in interface BaseRedisAsyncConnection<K,V>
    
    Parameters:
    
    channel - the key
    
    Returns:
    
    RedisFuture<List<K>> array-reply a list of active channels, optionally matching the specified pattern.
  - pubsubNumsub
```
public RedisFuture<Map<K,Long>> pubsubNumsub(K... channels)
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels.
    
    Specified by:
    
    pubsubNumsub in interface BaseRedisAsyncConnection<K,V>
    
    Parameters:
    
    channels - channel keys
    
    Returns:
    
    array-reply a list of channels and number of subscribers for every channel.
  - pubsubNumpat
```
public RedisFuture<Long> pubsubNumpat()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Returns the number of subscriptions to patterns.
    
    Specified by:
    
    pubsubNumpat in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of patterns all the clients are subscribed to.
  - quit
```
public RedisFuture<String> quit()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Close the connection.
    
    Specified by:
    
    quit in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply always OK.
  - role
```
public RedisFuture<List<Object>> role()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Return the role of the instance in the context of replication.
    
    Specified by:
    
    role in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<List<Object>> array-reply where the first element is one of master, slave, sentinel and the additional elements are role-specific.
  - randomkey
```
public RedisFuture<V> randomkey()
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Return a random key from the keyspace.
    
    Specified by:
    
    randomkey in interface RedisKeysAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the random key, or null when the database is empty.
  - rename
```
public RedisFuture<String> rename(K key,
                                  K newKey)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Rename a key.
    
    Specified by:
    
    rename in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    newKey - the newkey type: key
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - renamenx
```
public RedisFuture<Boolean> renamenx(K key,
                                     K newKey)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Rename a key, only if the new key does not exist.
    
    Specified by:
    
    renamenx in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    newKey - the newkey type: key
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if key was renamed to newkey. false if newkey already exists.
  - restore
```
public RedisFuture<String> restore(K key,
                                   long ttl,
                                   byte[] value)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Create a key using the provided serialized value, previously obtained using DUMP.
    
    Specified by:
    
    restore in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    ttl - the ttl type: long
    
    value - the serialized-value type: string
    
    Returns:
    
    RedisFuture<String> simple-string-reply The command returns OK on success.
  - rpop
```
public RedisFuture<V> rpop(K key)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Remove and get the last element in a list.
    
    Specified by:
    
    rpop in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the value of the last element, or null when key does not exist.
  - rpoplpush
```
public RedisFuture<V> rpoplpush(K source,
                                K destination)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Remove the last element in a list, append it to another list and return it.
    
    Specified by:
    
    rpoplpush in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    source - the source type: key
    
    destination - the destination type: key
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the element being popped and pushed.
  - rpush
```
public RedisFuture<Long> rpush(K key,
                               V... values)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Append one or multiple values to a list.
    
    Specified by:
    
    rpush in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    values - the value
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the list after the push operation.
  - rpushx
```
public RedisFuture<Long> rpushx(K key,
                                V value)
```
    Description copied from interface: RedisListsAsyncConnection
    
    Append a value to a list, only if the list exists.
    
    Specified by:
    
    rpushx in interface RedisListsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the list after the push operation.
  - sadd
```
public RedisFuture<Long> sadd(K key,
                              V... members)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Add one or more members to a set.
    
    Specified by:
    
    sadd in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    members - the member type: value
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements that were added to the set, not including all the elements already present into the set.
  - save
```
public RedisFuture<String> save()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Synchronously save the dataset to disk.
    
    Specified by:
    
    save in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply The commands returns OK on success.
  - scard
```
public RedisFuture<Long> scard(K key)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Get the number of members in a set.
    
    Specified by:
    
    scard in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the cardinality (number of elements) of the set, or false if key does not exist.
  - scriptExists
```
public RedisFuture<List<Boolean>> scriptExists(String... digests)
```
    Description copied from interface: RedisScriptingAsyncConnection
    
    Check existence of scripts in the script cache.
    
    Specified by:
    
    scriptExists in interface RedisScriptingAsyncConnection<K,V>
    
    Parameters:
    
    digests - script digests
    
    Returns:
    
    RedisFuture<List<Boolean>> array-reply The command returns an array of integers that correspond to the specified SHA1 digest arguments. For every corresponding SHA1 digest of a script that actually exists in the script cache, an 1 is returned, otherwise 0 is returned.
  - scriptFlush
```
public RedisFuture<String> scriptFlush()
```
    Description copied from interface: RedisScriptingAsyncConnection
    
    Remove all the scripts from the script cache.
    
    Specified by:
    
    scriptFlush in interface RedisScriptingAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - scriptKill
```
public RedisFuture<String> scriptKill()
```
    Description copied from interface: RedisScriptingAsyncConnection
    
    Kill the script currently in execution.
    
    Specified by:
    
    scriptKill in interface RedisScriptingAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - scriptLoad
```
public RedisFuture<String> scriptLoad(V script)
```
    Description copied from interface: RedisScriptingAsyncConnection
    
    Load the specified Lua script into the script cache.
    
    Specified by:
    
    scriptLoad in interface RedisScriptingAsyncConnection<K,V>
    
    Parameters:
    
    script - script content
    
    Returns:
    
    RedisFuture<String> bulk-string-reply This command returns the SHA1 digest of the script added into the script cache.
  - sdiff
```
public RedisFuture<Set<V>> sdiff(K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Subtract multiple sets.
    
    Specified by:
    
    sdiff in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    keys - the key
    
    Returns:
    
    RedisFuture<Set<V>> array-reply list with members of the resulting set.
  - sdiff
```
public RedisFuture<Long> sdiff(ValueStreamingChannel<V> channel,
                               K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Subtract multiple sets.
    
    Specified by:
    
    sdiff in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    keys - the keys
    
    Returns:
    
    RedisFuture<Long> count of members of the resulting set.
  - sdiffstore
```
public RedisFuture<Long> sdiffstore(K destination,
                                    K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Subtract multiple sets and store the resulting set in a key.
    
    Specified by:
    
    sdiffstore in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    destination - the destination type: key
    
    keys - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the resulting set.
  - select
```
public String select(int db)
```
    Description copied from interface: RedisAsyncConnection
    
    Change the selected database for the current connection.
    
    Specified by:
    
    select in interface RedisAsyncConnection<K,V>
    
    Parameters:
    
    db - the database number
    
    Returns:
    
    String simple-string-reply
  - set
```
public RedisFuture<String> set(K key,
                               V value)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Set the string value of a key.
    
    Specified by:
    
    set in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    RedisFuture<String> simple-string-reply OK if SET was executed correctly.
  - set
```
public RedisFuture<String> set(K key,
                               V value,
                               SetArgs setArgs)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Set the string value of a key.
    
    Specified by:
    
    set in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    value - the value
    
    setArgs - the setArgs
    
    Returns:
    
    RedisFuture<V> simple-string-reply OK if SET was executed correctly.
  - setbit
```
public RedisFuture<Long> setbit(K key,
                                long offset,
                                int value)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Sets or clears the bit at offset in the string value stored at key.
    
    Specified by:
    
    setbit in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    offset - the offset type: long
    
    value - the value type: string
    
    Returns:
    
    RedisFuture<Long> integer-reply the original bit value stored at offset.
  - setex
```
public RedisFuture<String> setex(K key,
                                 long seconds,
                                 V value)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Set the value and expiration of a key.
    
    Specified by:
    
    setex in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    seconds - the seconds type: long
    
    value - the value
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - psetex
```
public RedisFuture<String> psetex(K key,
                                  long milliseconds,
                                  V value)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Set the value and expiration in milliseconds of a key.
    
    Specified by:
    
    psetex in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    milliseconds - the milliseconds type: long
    
    value - the value
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - setnx
```
public RedisFuture<Boolean> setnx(K key,
                                  V value)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Set the value of a key, only if the key does not exist.
    
    Specified by:
    
    setnx in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    value - the value
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: 1 if the key was set 0 if the key was not set
  - setrange
```
public RedisFuture<Long> setrange(K key,
                                  long offset,
                                  V value)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Overwrite part of a string at key starting at the specified offset.
    
    Specified by:
    
    setrange in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    offset - the offset type: long
    
    value - the value
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the string after it was modified by the command.
  - shutdown
```
@Deprecated
public void shutdown()
```
    Deprecated.
  - shutdown
```
public void shutdown(boolean save)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Synchronously save the dataset to disk and then shut down the server.
    
    Specified by:
    
    shutdown in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    save - true force save operation
  - sinter
```
public RedisFuture<Set<V>> sinter(K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Intersect multiple sets.
    
    Specified by:
    
    sinter in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    keys - the key
    
    Returns:
    
    RedisFuture<Set<V>> array-reply list with members of the resulting set.
  - sinter
```
public RedisFuture<Long> sinter(ValueStreamingChannel<V> channel,
                                K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Intersect multiple sets.
    
    Specified by:
    
    sinter in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    keys - the keys
    
    Returns:
    
    RedisFuture<Long> count of members of the resulting set.
  - sinterstore
```
public RedisFuture<Long> sinterstore(K destination,
                                     K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Intersect multiple sets and store the resulting set in a key.
    
    Specified by:
    
    sinterstore in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    destination - the destination type: key
    
    keys - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the resulting set.
  - sismember
```
public RedisFuture<Boolean> sismember(K key,
                                      V member)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Determine if a given value is a member of a set.
    
    Specified by:
    
    sismember in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    member - the member type: value
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.
  - smove
```
public RedisFuture<Boolean> smove(K source,
                                  K destination,
                                  V member)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Move a member from one set to another.
    
    Specified by:
    
    smove in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    source - the source type: key
    
    destination - the destination type: key
    
    member - the member type: value
    
    Returns:
    
    RedisFuture<Boolean> integer-reply specifically: true if the element is moved. false if the element is not a member of source and no operation was performed.
  - slaveof
```
public RedisFuture<String> slaveof(String host,
                                   int port)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Make the server a slave of another instance.
    
    Specified by:
    
    slaveof in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    host - the host type: string
    
    port - the port type: string
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - slaveofNoOne
```
public RedisFuture<String> slaveofNoOne()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Promote server as master.
    
    Specified by:
    
    slaveofNoOne in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply
  - slowlogGet
```
public RedisFuture<List<Object>> slowlogGet()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Read the slow log.
    
    Specified by:
    
    slowlogGet in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    List<Object> deeply nested multi bulk replies
  - slowlogGet
```
public RedisFuture<List<Object>> slowlogGet(int count)
```
    Description copied from interface: RedisServerAsyncConnection
    
    Read the slow log.
    
    Specified by:
    
    slowlogGet in interface RedisServerAsyncConnection<K,V>
    
    Parameters:
    
    count - the count
    
    Returns:
    
    List<Object> deeply nested multi bulk replies
  - slowlogLen
```
public RedisFuture<Long> slowlogLen()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Obtaining the current length of the slow log.
    
    Specified by:
    
    slowlogLen in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<Long> length of the slow log.
  - slowlogReset
```
public RedisFuture<String> slowlogReset()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Resetting the slow log.
    
    Specified by:
    
    slowlogReset in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply The commands returns OK on success.
  - smembers
```
public RedisFuture<Set<V>> smembers(K key)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Get all the members in a set.
    
    Specified by:
    
    smembers in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Set<V>> array-reply all elements of the set.
  - smembers
```
public RedisFuture<Long> smembers(ValueStreamingChannel<V> channel,
                                  K key)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Get all the members in a set.
    
    Specified by:
    
    smembers in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> count of members of the resulting set.
  - sort
```
public RedisFuture<List<V>> sort(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Sort the elements in a list, set or sorted set.
    
    Specified by:
    
    sort in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of sorted elements.
  - sort
```
public RedisFuture<Long> sort(ValueStreamingChannel<V> channel,
                              K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Sort the elements in a list, set or sorted set.
    
    Specified by:
    
    sort in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> number of values.
  - sort
```
public RedisFuture<List<V>> sort(K key,
                                 SortArgs sortArgs)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Sort the elements in a list, set or sorted set.
    
    Specified by:
    
    sort in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    sortArgs - sort arguments
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of sorted elements.
  - sort
```
public RedisFuture<Long> sort(ValueStreamingChannel<V> channel,
                              K key,
                              SortArgs sortArgs)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Sort the elements in a list, set or sorted set.
    
    Specified by:
    
    sort in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    sortArgs - sort arguments
    
    Returns:
    
    RedisFuture<Long> number of values.
  - sortStore
```
public RedisFuture<Long> sortStore(K key,
                                   SortArgs sortArgs,
                                   K destination)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Sort the elements in a list, set or sorted set.
    
    Specified by:
    
    sortStore in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    sortArgs - sort arguments
    
    destination - the destination key to store sort results
    
    Returns:
    
    RedisFuture<Long> number of values.
  - spop
```
public RedisFuture<V> spop(K key)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Remove and return a random member from a set.
    
    Specified by:
    
    spop in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<V> bulk-string-reply the removed element, or null when key does not exist.
  - srandmember
```
public RedisFuture<V> srandmember(K key)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Get one or multiple random members from a set.
    
    Specified by:
    
    srandmember in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<V> bulk-string-reply without the additional count argument the command returns a Bulk Reply with the randomly selected element, or null when key does not exist.
  - srandmember
```
public RedisFuture<Set<V>> srandmember(K key,
                                       long count)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Get one or multiple random members from a set.
    
    Specified by:
    
    srandmember in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    count - the count type: long
    
    Returns:
    
    RedisFuture<Set<V>> bulk-string-reply without the additional count argument the command returns a Bulk Reply with the randomly selected element, or null when key does not exist.
  - srandmember
```
public RedisFuture<Long> srandmember(ValueStreamingChannel<V> channel,
                                     K key,
                                     long count)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Get one or multiple random members from a set.
    
    Specified by:
    
    srandmember in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of members of the resulting set.
  - srem
```
public RedisFuture<Long> srem(K key,
                              V... members)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Remove one or more members from a set.
    
    Specified by:
    
    srem in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    members - the member type: value
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of members that were removed from the set, not including non existing members.
  - sunion
```
public RedisFuture<Set<V>> sunion(K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Add multiple sets.
    
    Specified by:
    
    sunion in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    keys - the key
    
    Returns:
    
    RedisFuture<Set<V>> array-reply list with members of the resulting set.
  - sunion
```
public RedisFuture<Long> sunion(ValueStreamingChannel<V> channel,
                                K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Add multiple sets.
    
    Specified by:
    
    sunion in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    keys - the key
    
    Returns:
    
    RedisFuture<Long> count of members of the resulting set.
  - sunionstore
```
public RedisFuture<Long> sunionstore(K destination,
                                     K... keys)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Add multiple sets and store the resulting set in a key.
    
    Specified by:
    
    sunionstore in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    destination - the destination type: key
    
    keys - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the resulting set.
  - sync
```
public RedisFuture<String> sync()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Internal command used for replication.
    
    Specified by:
    
    sync in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String>
  - strlen
```
public RedisFuture<Long> strlen(K key)
```
    Description copied from interface: RedisStringsAsyncConnection
    
    Get the length of the value stored in a key.
    
    Specified by:
    
    strlen in interface RedisStringsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the length of the string at key, or 0 when key does not exist.
  - ttl
```
public RedisFuture<Long> ttl(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Get the time to live for a key.
    
    Specified by:
    
    ttl in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply TTL in seconds, or a negative value in order to signal an error (see the description above).
  - type
```
public RedisFuture<String> type(K key)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Determine the type stored at key.
    
    Specified by:
    
    type in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<String> simple-string-reply type of key, or none when key does not exist.
  - watch
```
public RedisFuture<String> watch(K... keys)
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Watch the given keys to determine execution of the MULTI/EXEC block.
    
    Specified by:
    
    watch in interface BaseRedisAsyncConnection<K,V>
    
    Parameters:
    
    keys - the key
    
    Returns:
    
    RedisFuture<String> simple-string-reply always OK.
  - unwatch
```
public RedisFuture<String> unwatch()
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Forget about all watched keys.
    
    Specified by:
    
    unwatch in interface BaseRedisAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<String> simple-string-reply always OK.
  - zadd
```
public RedisFuture<Long> zadd(K key,
                              double score,
                              V member)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Specified by:
    
    zadd in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    score - the score
    
    member - the member
    
    Returns:
    
    RedisFuture<Long> integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zadd
```
public RedisFuture<Long> zadd(K key,
                              Object... scoresAndValues)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Specified by:
    
    zadd in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scoresAndValues - the scoresAndValue tuples (score,value,score,value,...)
    
    Returns:
    
    RedisFuture<Long> integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zadd
```
public RedisFuture<Long> zadd(K key,
                              ZAddArgs zAddArgs,
                              double score,
                              V member)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Specified by:
    
    zadd in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    zAddArgs - arguments for zadd
    
    score - the score
    
    member - the member
    
    Returns:
    
    RedisFuture<Long> integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zadd
```
public RedisFuture<Long> zadd(K key,
                              ZAddArgs zAddArgs,
                              Object... scoresAndValues)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Add one or more members to a sorted set, or update its score if it already exists.
    
    Specified by:
    
    zadd in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    zAddArgs - arguments for zadd
    
    scoresAndValues - the scoresAndValue tuples (score,value,score,value,...)
    
    Returns:
    
    RedisFuture<Long> integer-reply specifically: The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
  - zaddincr
```
public RedisFuture<Double> zaddincr(K key,
                                    double score,
                                    V member)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    ZADD acts like ZINCRBY
    
    Specified by:
    
    zaddincr in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    score - the score
    
    member - the member
    
    Returns:
    
    RedisFuture<Long> integer-reply specifically: The total number of elements changed
  - zcard
```
public RedisFuture<Long> zcard(K key)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Get the number of members in a sorted set.
    
    Specified by:
    
    zcard in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<Long> integer-reply the cardinality (number of elements) of the sorted set, or false if key does not exist.
  - zcount
```
public RedisFuture<Long> zcount(K key,
                                double min,
                                double max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Count the members in a sorted set with scores within the given values.
    
    Specified by:
    
    zcount in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the specified score range.
  - zcount
```
public RedisFuture<Long> zcount(K key,
                                String min,
                                String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Count the members in a sorted set with scores within the given values.
    
    Specified by:
    
    zcount in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the specified score range.
  - zincrby
```
public RedisFuture<Double> zincrby(K key,
                                   double amount,
                                   K member)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Increment the score of a member in a sorted set.
    
    Specified by:
    
    zincrby in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    amount - the increment type: long
    
    member - the member type: key
    
    Returns:
    
    RedisFuture<Double;> bulk-string-reply the new score of member (a double precision floating point number), represented as string.
  - zinterstore
```
public RedisFuture<Long> zinterstore(K destination,
                                     K... keys)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Intersect multiple sorted sets and store the resulting sorted set in a new key.
    
    Specified by:
    
    zinterstore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    destination - the destination
    
    keys - the keys
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the resulting sorted set at destination.
  - zinterstore
```
public RedisFuture<Long> zinterstore(K destination,
                                     ZStoreArgs storeArgs,
                                     K... keys)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Intersect multiple sorted sets and store the resulting sorted set in a new key.
    
    Specified by:
    
    zinterstore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    destination - the destination
    
    storeArgs - the storeArgs
    
    keys - the keys
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the resulting sorted set at destination.
  - zrange
```
public RedisFuture<List<V>> zrange(K key,
                                   long start,
                                   long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by index.
    
    Specified by:
    
    zrange in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start
    
    stop - the stop
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified range.
  - zrangeWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrangeWithScores(K key,
                                                          long start,
                                                          long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by index.
    
    Specified by:
    
    zrangeWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start
    
    stop - the stop
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified range.
  - zrangebyscore
```
public RedisFuture<List<V>> zrangebyscore(K key,
                                          double min,
                                          double max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by score.
    
    Specified by:
    
    zrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrangebyscore
```
public RedisFuture<List<V>> zrangebyscore(K key,
                                          String min,
                                          String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by score.
    
    Specified by:
    
    zrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrangebyscore
```
public RedisFuture<List<V>> zrangebyscore(K key,
                                          double min,
                                          double max,
                                          long offset,
                                          long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by score.
    
    Specified by:
    
    zrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrangebyscore
```
public RedisFuture<List<V>> zrangebyscore(K key,
                                          String min,
                                          String max,
                                          long offset,
                                          long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by score.
    
    Specified by:
    
    zrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrangebyscoreWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                 double min,
                                                                 double max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with score in a sorted set, by score.
    
    Specified by:
    
    zrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified score range.
  - zrangebyscoreWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                 String min,
                                                                 String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with score in a sorted set, by score.
    
    Specified by:
    
    zrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified score range.
  - zrangebyscoreWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                 double min,
                                                                 double max,
                                                                 long offset,
                                                                 long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with score in a sorted set, by score.
    
    Specified by:
    
    zrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified score range.
  - zrangebyscoreWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key,
                                                                 String min,
                                                                 String max,
                                                                 long offset,
                                                                 long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with score in a sorted set, by score.
    
    Specified by:
    
    zrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified score range.
  - zrange
```
public RedisFuture<Long> zrange(ValueStreamingChannel<V> channel,
                                K key,
                                long start,
                                long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by index.
    
    Specified by:
    
    zrange in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    start - the start
    
    stop - the stop
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrangeWithScores
```
public RedisFuture<Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel,
                                          K key,
                                          long start,
                                          long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by index.
    
    Specified by:
    
    zrangeWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    start - the start
    
    stop - the stop
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrangebyscore
```
public RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                       K key,
                                       double min,
                                       double max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by score.
    
    Specified by:
    
    zrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified score range.
  - zrangebyscore
```
public RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                       K key,
                                       String min,
                                       String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by score.
    
    Specified by:
    
    zrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified score range.
  - zrangebyscore
```
public RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                       K key,
                                       double min,
                                       double max,
                                       long offset,
                                       long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by score.
    
    Specified by:
    
    zrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified score range.
  - zrangebyscore
```
public RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel,
                                       K key,
                                       String min,
                                       String max,
                                       long offset,
                                       long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by score.
    
    Specified by:
    
    zrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified score range.
  - zrangebyscoreWithScores
```
public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                                 K key,
                                                 double min,
                                                 double max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by score.
    
    Specified by:
    
    zrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified score range.
  - zrangebyscoreWithScores
```
public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                                 K key,
                                                 String min,
                                                 String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by score.
    
    Specified by:
    
    zrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified score range.
  - zrangebyscoreWithScores
```
public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                                 K key,
                                                 double min,
                                                 double max,
                                                 long offset,
                                                 long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by score.
    
    Specified by:
    
    zrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified score range.
  - zrangebyscoreWithScores
```
public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                                 K key,
                                                 String min,
                                                 String max,
                                                 long offset,
                                                 long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by score.
    
    Specified by:
    
    zrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified score range.
  - zrank
```
public RedisFuture<Long> zrank(K key,
                               V member)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Determine the index of a member in a sorted set.
    
    Specified by:
    
    zrank in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    member - the member type: value
    
    Returns:
    
    RedisFuture<Long> integer-reply the rank of member. If member does not exist in the sorted set or key does not exist,
  - zrem
```
public RedisFuture<Long> zrem(K key,
                              V... members)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Remove one or more members from a sorted set.
    
    Specified by:
    
    zrem in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    members - the member type: value
    
    Returns:
    
    RedisFuture<Long> integer-reply specifically: The number of members removed from the sorted set, not including non existing members.
  - zremrangebyrank
```
public RedisFuture<Long> zremrangebyrank(K key,
                                         long start,
                                         long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Remove all members in a sorted set within the given indexes.
    
    Specified by:
    
    zremrangebyrank in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start type: long
    
    stop - the stop type: long
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements removed.
  - zremrangebyscore
```
public RedisFuture<Long> zremrangebyscore(K key,
                                          double min,
                                          double max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Remove all members in a sorted set within the given scores.
    
    Specified by:
    
    zremrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements removed.
  - zremrangebyscore
```
public RedisFuture<Long> zremrangebyscore(K key,
                                          String min,
                                          String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Remove all members in a sorted set within the given scores.
    
    Specified by:
    
    zremrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements removed.
  - zrevrange
```
public RedisFuture<List<V>> zrevrange(K key,
                                      long start,
                                      long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by index, with scores ordered from high to low.
    
    Specified by:
    
    zrevrange in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start
    
    stop - the stop
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified range.
  - zrevrangeWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrevrangeWithScores(K key,
                                                             long start,
                                                             long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with scores in a sorted set, by index, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangeWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    start - the start
    
    stop - the stop
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified range.
  - zrevrangebyscore
```
public RedisFuture<List<V>> zrevrangebyscore(K key,
                                             double max,
                                             double min)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    max - max score
    
    min - min score
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrevrangebyscore
```
public RedisFuture<List<V>> zrevrangebyscore(K key,
                                             String max,
                                             String min)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    max - max score
    
    min - min score
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrevrangebyscore
```
public RedisFuture<List<V>> zrevrangebyscore(K key,
                                             double max,
                                             double min,
                                             long offset,
                                             long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    max - max score
    
    min - min score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrevrangebyscore
```
public RedisFuture<List<V>> zrevrangebyscore(K key,
                                             String max,
                                             String min,
                                             long offset,
                                             long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    max - max score
    
    min - min score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrevrangebyscoreWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                                    double max,
                                                                    double min)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    max - max score
    
    min - min score
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified score range.
  - zrevrangebyscoreWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                                    String max,
                                                                    String min)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    max - max score
    
    min - min score
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified score range.
  - zrevrangebyscoreWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                                    double max,
                                                                    double min,
                                                                    long offset,
                                                                    long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    max - max score
    
    min - min score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified score range.
  - zrevrangebyscoreWithScores
```
public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key,
                                                                    String max,
                                                                    String min,
                                                                    long offset,
                                                                    long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    max - max score
    
    min - min score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<ScoredValue<V>>> array-reply list of elements in the specified score range.
  - zrevrange
```
public RedisFuture<Long> zrevrange(ValueStreamingChannel<V> channel,
                                   K key,
                                   long start,
                                   long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by index, with scores ordered from high to low.
    
    Specified by:
    
    zrevrange in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    start - the start
    
    stop - the stop
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangeWithScores
```
public RedisFuture<Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel,
                                             K key,
                                             long start,
                                             long stop)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by index, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangeWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    start - the start
    
    stop - the stop
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangebyscore
```
public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                          K key,
                                          double max,
                                          double min)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    max - max score
    
    min - min score
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangebyscore
```
public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                          K key,
                                          String max,
                                          String min)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    max - max score
    
    min - min score
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangebyscore
```
public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                          K key,
                                          double max,
                                          double min,
                                          long offset,
                                          long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    max - max score
    
    min - min score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangebyscore
```
public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel,
                                          K key,
                                          String max,
                                          String min,
                                          long offset,
                                          long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    max - max score
    
    min - min score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                                    K key,
                                                    double max,
                                                    double min)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    max - max score
    
    min - min score
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                                    K key,
                                                    String max,
                                                    String min)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    max - max score
    
    min - min score
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                                    K key,
                                                    double max,
                                                    double min,
                                                    long offset,
                                                    long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    max - max score
    
    min - min score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrangebyscoreWithScores
```
public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel,
                                                    K key,
                                                    String max,
                                                    String min,
                                                    long offset,
                                                    long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Stream over a range of members with scores in a sorted set, by score, with scores ordered from high to low.
    
    Specified by:
    
    zrevrangebyscoreWithScores in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    max - max score
    
    min - min score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<Long> count of elements in the specified range.
  - zrevrank
```
public RedisFuture<Long> zrevrank(K key,
                                  V member)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Determine the index of a member in a sorted set, with scores ordered from high to low.
    
    Specified by:
    
    zrevrank in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    member - the member type: value
    
    Returns:
    
    RedisFuture<Long> integer-reply the rank of member. If member does not exist in the sorted set or key does not exist,
  - zscore
```
public RedisFuture<Double> zscore(K key,
                                  V member)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Get the score associated with the given member in a sorted set.
    
    Specified by:
    
    zscore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    member - the member type: value
    
    Returns:
    
    RedisFuture<Double;> bulk-string-reply the score of member (a double precision floating point number), represented as string.
  - zunionstore
```
public RedisFuture<Long> zunionstore(K destination,
                                     K... keys)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Add multiple sorted sets and store the resulting sorted set in a new key.
    
    Specified by:
    
    zunionstore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    destination - destination key
    
    keys - source keys
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the resulting sorted set at destination.
  - zunionstore
```
public RedisFuture<Long> zunionstore(K destination,
                                     ZStoreArgs storeArgs,
                                     K... keys)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Add multiple sorted sets and store the resulting sorted set in a new key.
    
    Specified by:
    
    zunionstore in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    destination - the destination
    
    storeArgs - the storeArgs
    
    keys - the keys
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the resulting sorted set at destination.
  - scan
```
public RedisFuture<KeyScanCursor<K>> scan()
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeysAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<KeyScanCursor<K>> scan cursor.
  - scan
```
public RedisFuture<KeyScanCursor<K>> scan(ScanArgs scanArgs)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<KeyScanCursor<K>> scan cursor.
  - scan
```
public RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor,
                                          ScanArgs scanArgs)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    scanCursor - cursor to resume from a previous scan
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<KeyScanCursor<K>> scan cursor.
  - scan
```
public RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    scanCursor - cursor to resume from a previous scan
    
    Returns:
    
    RedisFuture<KeyScanCursor<K>> scan cursor.
  - scan
```
public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - scan
```
public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel,
                                          ScanArgs scanArgs)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - scan
```
public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel,
                                          ScanCursor scanCursor,
                                          ScanArgs scanArgs)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key
    
    scanCursor - cursor to resume from a previous scan
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - scan
```
public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel,
                                          ScanCursor scanCursor)
```
    Description copied from interface: RedisKeysAsyncConnection
    
    Incrementally iterate the keys space.
    
    Specified by:
    
    scan in interface RedisKeysAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key
    
    scanCursor - cursor to resume from a previous scan
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - sscan
```
public RedisFuture<ValueScanCursor<V>> sscan(K key)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Incrementally iterate Set elements.
    
    Specified by:
    
    sscan in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<ValueScanCursor>V<> scan cursor.
  - sscan
```
public RedisFuture<ValueScanCursor<V>> sscan(K key,
                                             ScanArgs scanArgs)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Incrementally iterate Set elements.
    
    Specified by:
    
    sscan in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<ValueScanCursor>V<> scan cursor.
  - sscan
```
public RedisFuture<ValueScanCursor<V>> sscan(K key,
                                             ScanCursor scanCursor,
                                             ScanArgs scanArgs)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Incrementally iterate Set elements.
    
    Specified by:
    
    sscan in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<ValueScanCursor>V<> scan cursor.
  - sscan
```
public RedisFuture<ValueScanCursor<V>> sscan(K key,
                                             ScanCursor scanCursor)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Incrementally iterate Set elements.
    
    Specified by:
    
    sscan in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    Returns:
    
    RedisFuture<ValueScanCursor>V<> scan cursor.
  - sscan
```
public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel,
                                           K key)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Incrementally iterate Set elements.
    
    Specified by:
    
    sscan in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - sscan
```
public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel,
                                           K key,
                                           ScanArgs scanArgs)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Incrementally iterate Set elements.
    
    Specified by:
    
    sscan in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - sscan
```
public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel,
                                           K key,
                                           ScanCursor scanCursor,
                                           ScanArgs scanArgs)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Incrementally iterate Set elements.
    
    Specified by:
    
    sscan in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - sscan
```
public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel,
                                           K key,
                                           ScanCursor scanCursor)
```
    Description copied from interface: RedisSetsAsyncConnection
    
    Incrementally iterate Set elements.
    
    Specified by:
    
    sscan in interface RedisSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every value
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - hscan
```
public RedisFuture<MapScanCursor<K,V>> hscan(K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Incrementally iterate hash fields and associated values.
    
    Specified by:
    
    hscan in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<MapScanCursor<K, V>> scan cursor.
  - hscan
```
public RedisFuture<MapScanCursor<K,V>> hscan(K key,
                                             ScanArgs scanArgs)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Incrementally iterate hash fields and associated values.
    
    Specified by:
    
    hscan in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<MapScanCursor<K, V>> scan cursor.
  - hscan
```
public RedisFuture<MapScanCursor<K,V>> hscan(K key,
                                             ScanCursor scanCursor,
                                             ScanArgs scanArgs)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Incrementally iterate hash fields and associated values.
    
    Specified by:
    
    hscan in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<MapScanCursor<K, V>> scan cursor.
  - hscan
```
public RedisFuture<MapScanCursor<K,V>> hscan(K key,
                                             ScanCursor scanCursor)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Incrementally iterate hash fields and associated values.
    
    Specified by:
    
    hscan in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    Returns:
    
    RedisFuture<MapScanCursor<K, V>> scan cursor.
  - hscan
```
public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K,V> channel,
                                           K key)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Incrementally iterate hash fields and associated values.
    
    Specified by:
    
    hscan in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key-value pair
    
    key - the key
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - hscan
```
public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K,V> channel,
                                           K key,
                                           ScanArgs scanArgs)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Incrementally iterate hash fields and associated values.
    
    Specified by:
    
    hscan in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key-value pair
    
    key - the key
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - hscan
```
public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K,V> channel,
                                           K key,
                                           ScanCursor scanCursor,
                                           ScanArgs scanArgs)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Incrementally iterate hash fields and associated values.
    
    Specified by:
    
    hscan in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key-value pair
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - hscan
```
public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K,V> channel,
                                           K key,
                                           ScanCursor scanCursor)
```
    Description copied from interface: RedisHashesAsyncConnection
    
    Incrementally iterate hash fields and associated values.
    
    Specified by:
    
    hscan in interface RedisHashesAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every key-value pair
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - zscan
```
public RedisFuture<ScoredValueScanCursor<V>> zscan(K key)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Incrementally iterate sorted sets elements and associated scores.
    
    Specified by:
    
    zscan in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    Returns:
    
    RedisFuture<ScoredValueScanCursor<V>> scan cursor.
  - zscan
```
public RedisFuture<ScoredValueScanCursor<V>> zscan(K key,
                                                   ScanArgs scanArgs)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Incrementally iterate sorted sets elements and associated scores.
    
    Specified by:
    
    zscan in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<ScoredValueScanCursor<V>> scan cursor.
  - zscan
```
public RedisFuture<ScoredValueScanCursor<V>> zscan(K key,
                                                   ScanCursor scanCursor,
                                                   ScanArgs scanArgs)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Incrementally iterate sorted sets elements and associated scores.
    
    Specified by:
    
    zscan in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<ScoredValueScanCursor<V>> scan cursor.
  - zscan
```
public RedisFuture<ScoredValueScanCursor<V>> zscan(K key,
                                                   ScanCursor scanCursor)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Incrementally iterate sorted sets elements and associated scores.
    
    Specified by:
    
    zscan in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    Returns:
    
    RedisFuture<ScoredValueScanCursor<V>> scan cursor.
  - zscan
```
public RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel,
                                           K key)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Incrementally iterate sorted sets elements and associated scores.
    
    Specified by:
    
    zscan in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - zscan
```
public RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel,
                                           K key,
                                           ScanArgs scanArgs)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Incrementally iterate sorted sets elements and associated scores.
    
    Specified by:
    
    zscan in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - zscan
```
public RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel,
                                           K key,
                                           ScanCursor scanCursor,
                                           ScanArgs scanArgs)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Incrementally iterate sorted sets elements and associated scores.
    
    Specified by:
    
    zscan in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    scanArgs - scan arguments
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - zscan
```
public RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel,
                                           K key,
                                           ScanCursor scanCursor)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Incrementally iterate sorted sets elements and associated scores.
    
    Specified by:
    
    zscan in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    channel - streaming channel that receives a call for every scored value
    
    key - the key
    
    scanCursor - cursor to resume from a previous scan
    
    Returns:
    
    RedisFuture<StreamScanCursor> scan cursor.
  - digest
```
public String digest(V script)
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Create a SHA1 digest from a Lua script.
    
    Specified by:
    
    digest in interface BaseRedisAsyncConnection<K,V>
    
    Parameters:
    
    script - script content
    
    Returns:
    
    the SHA1 value
  - time
```
public RedisFuture<List<V>> time()
```
    Description copied from interface: RedisServerAsyncConnection
    
    Return the current server time.
    
    Specified by:
    
    time in interface RedisServerAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<List<V>> array-reply specifically: A multi bulk reply containing two elements: unix time in seconds. microseconds.
  - waitForReplication
```
public RedisFuture<Long> waitForReplication(int replicas,
                                            long timeout)
```
    Description copied from interface: BaseRedisAsyncConnection
    
    Wait for replication.
    
    Specified by:
    
    waitForReplication in interface BaseRedisAsyncConnection<K,V>
    
    Parameters:
    
    replicas - minimum number of replicas
    
    timeout - timeout in milliseconds
    
    Returns:
    
    number of replicas
  - pfadd
```
public RedisFuture<Long> pfadd(K key,
                               V value,
                               V... moreValues)
```
    Description copied from interface: RedisHLLAsyncConnection
    
    Adds the specified elements to the specified HyperLogLog.
    
    Specified by:
    
    pfadd in interface RedisHLLAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    value - the value
    
    moreValues - more values
    
    Returns:
    
    RedisFuture<Long> integer-reply specifically: 1 if at least 1 HyperLogLog internal register was altered. 0 otherwise.
  - pfmerge
```
public RedisFuture<String> pfmerge(K destkey,
                                   K sourcekey,
                                   K... moreSourceKeys)
```
    Description copied from interface: RedisHLLAsyncConnection
    
    Merge N different HyperLogLogs into a single one.
    
    Specified by:
    
    pfmerge in interface RedisHLLAsyncConnection<K,V>
    
    Parameters:
    
    destkey - the destination key
    
    sourcekey - the source key
    
    moreSourceKeys - more source keys
    
    Returns:
    
    RedisFuture<String> simple-string-reply The command just returns OK.
  - pfcount
```
public RedisFuture<Long> pfcount(K key,
                                 K... moreKeys)
```
    Description copied from interface: RedisHLLAsyncConnection
    
    Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    
    Specified by:
    
    pfcount in interface RedisHLLAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    moreKeys - more keys
    
    Returns:
    
    RedisFuture<Long> integer-reply specifically: The approximated number of unique elements observed via PFADD.
  - clusterMeet
```
public RedisFuture<String> clusterMeet(String ip,
                                       int port)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Meet another cluster node to include the node into the cluster. The command starts the cluster handshake and returns with OK when the node was added to the cluster.
    
    Specified by:
    
    clusterMeet in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    ip - IP address of the host
    
    port - port number.
    
    Returns:
    
    String simple-string-reply
  - clusterForget
```
public RedisFuture<String> clusterForget(String nodeId)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Blacklist and remove the cluster node from the cluster.
    
    Specified by:
    
    clusterForget in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    nodeId - the node Id
    
    Returns:
    
    String simple-string-reply
  - clusterAddSlots
```
public RedisFuture<String> clusterAddSlots(int... slots)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Adds slots to the cluster node. The current node will become the master for the specified slots.
    
    Specified by:
    
    clusterAddSlots in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    slots - one or more slots from 0 to 16384
    
    Returns:
    
    String simple-string-reply
  - clusterDelSlots
```
public RedisFuture<String> clusterDelSlots(int... slots)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Removes slots from the cluster node.
    
    Specified by:
    
    clusterDelSlots in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    slots - one or more slots from 0 to 16384
    
    Returns:
    
    String simple-string-reply
  - clusterInfo
```
public RedisFuture<String> clusterInfo()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Get information and statistics about the cluster viewed by the current node.
    
    Specified by:
    
    clusterInfo in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    String bulk-string-reply as a collection of text lines.
  - clusterMyId
```
public RedisFuture<String> clusterMyId()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Obtain the nodeId for the currently connected node.
    
    Specified by:
    
    clusterMyId in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    String simple-string-reply
  - clusterNodes
```
public RedisFuture<String> clusterNodes()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Obtain details about all cluster nodes. Can be parsed using ClusterPartitionParser.parse(java.lang.String)
    
    Specified by:
    
    clusterNodes in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    String bulk-string-reply as a collection of text lines
  - clusterGetKeysInSlot
```
public RedisFuture<List<K>> clusterGetKeysInSlot(int slot,
                                                 int count)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Retrieve the list of keys within the slot.
    
    Specified by:
    
    clusterGetKeysInSlot in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    slot - the slot
    
    count - maximal number of keys
    
    Returns:
    
    List<K> array-reply list of keys
  - clusterCountKeysInSlot
```
public RedisFuture<Long> clusterCountKeysInSlot(int slot)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Returns the number of keys in the specified Redis Cluster hash slot.
    
    Specified by:
    
    clusterCountKeysInSlot in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    slot - the slot
    
    Returns:
    
    Integer reply: The number of keys in the specified hash slot, or an error if the hash slot is invalid.
  - clusterCountFailureReports
```
public RedisFuture<Long> clusterCountFailureReports(String nodeId)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Returns the number of failure reports for the specified node. Failure reports are the way Redis Cluster uses in order to promote a PFAIL state, that means a node is not reachable, to a FAIL state, that means that the majority of masters in the cluster agreed within a window of time that the node is not reachable.
    
    Specified by:
    
    clusterCountFailureReports in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    nodeId - the node id
    
    Returns:
    
    Integer reply: The number of active failure reports for the node.
  - clusterKeyslot
```
public RedisFuture<Long> clusterKeyslot(K key)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Returns an integer identifying the hash slot the specified key hashes to. This command is mainly useful for debugging and testing, since it exposes via an API the underlying Redis implementation of the hashing algorithm. Basically the same as SlotHash.getSlot(byte[]). If not, call Houston and report that we've got a problem.
    
    Specified by:
    
    clusterKeyslot in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    key - the key.
    
    Returns:
    
    Integer reply: The hash slot number.
  - clusterSaveconfig
```
public RedisFuture<String> clusterSaveconfig()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Forces a node to save the nodes.conf configuration on disk.
    
    Specified by:
    
    clusterSaveconfig in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    String simple-string-reply: OK or an error if the operation fails.
  - clusterSetConfigEpoch
```
public RedisFuture<String> clusterSetConfigEpoch(long configEpoch)
```
    Description copied from interface: RedisClusterAsyncConnection
    This command sets a specific config epoch in a fresh node. It only works when:
    - The nodes table of the node is empty.
    - The node current config epoch is zero.
    Specified by:
    
    clusterSetConfigEpoch in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    configEpoch - the config epoch
    
    Returns:
    
    String simple-string-reply: OK or an error if the operation fails.
  - clusterSlots
```
public RedisFuture<List<Object>> clusterSlots()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Get array of cluster slots to node mappings.
    
    Specified by:
    
    clusterSlots in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    RedisFuture<List<Object>> array-reply nested list of slot ranges with IP/Port mappings.
  - clusterSetSlotNode
```
public RedisFuture<String> clusterSetSlotNode(int slot,
                                              String nodeId)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Assign a slot to a node. The command migrates the specified slot from the current node to the specified node in nodeId
    
    Specified by:
    
    clusterSetSlotNode in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    slot - the slot
    
    nodeId - the id of the node that will become the master for the slot
    
    Returns:
    
    String simple-string-reply
  - clusterSetSlotStable
```
public RedisFuture<String> clusterSetSlotStable(int slot)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Clears migrating / importing state from the slot.
    
    Specified by:
    
    clusterSetSlotStable in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    slot - the slot
    
    Returns:
    
    String simple-string-reply
  - clusterSetSlotMigrating
```
public RedisFuture<String> clusterSetSlotMigrating(int slot,
                                                   String nodeId)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Flag a slot as MIGRATING (outgoing) towards the node specified in nodeId. The slot must be handled by the current node in order to be migrated.
    
    Specified by:
    
    clusterSetSlotMigrating in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    slot - the slot
    
    nodeId - the id of the node is targeted to become the master for the slot
    
    Returns:
    
    String simple-string-reply
  - clusterSetSlotImporting
```
public RedisFuture<String> clusterSetSlotImporting(int slot,
                                                   String nodeId)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Flag a slot as IMPORTING (incoming) from the node specified in nodeId.
    
    Specified by:
    
    clusterSetSlotImporting in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    slot - the slot
    
    nodeId - the id of the node is the master of the slot
    
    Returns:
    
    String simple-string-reply
  - clusterFailover
```
public RedisFuture<String> clusterFailover(boolean force)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Failover a cluster node. Turns the currently connected node into a master and the master into its slave.
    
    Specified by:
    
    clusterFailover in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    force - do not coordinate with master if true
    
    Returns:
    
    String simple-string-reply
  - clusterReset
```
public RedisFuture<String> clusterReset(boolean hard)
```
    Description copied from interface: RedisClusterAsyncConnection
    Reset a node performing a soft or hard reset:
    - All other nodes are forgotten
    - All the assigned / open slots are released
    - If the node is a slave, it turns into a master
    - Only for hard reset: a new Node ID is generated
    - Only for hard reset: currentEpoch and configEpoch are set to 0
    - The new configuration is saved and the cluster state updated
    - If the node was a slave, the whole data set is flushed away
    Specified by:
    
    clusterReset in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    hard - true for hard reset. Generates a new nodeId and currentEpoch/configEpoch are set to 0
    
    Returns:
    
    String simple-string-reply
  - asking
```
public RedisFuture<String> asking()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    The asking command is required after a -ASK redirection. The client should issue ASKING before to actually send the command to the target instance. See the Redis Cluster specification for more information.
    
    Specified by:
    
    asking in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    String simple-string-reply
  - clusterReplicate
```
public RedisFuture<String> clusterReplicate(String nodeId)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Turn this node into a slave of the node with the id nodeId.
    
    Specified by:
    
    clusterReplicate in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    nodeId - master node id
    
    Returns:
    
    String simple-string-reply
  - clusterFlushslots
```
public RedisFuture<String> clusterFlushslots()
```
    Description copied from interface: RedisClusterAsyncConnection
    
    Delete all the slots associated with the specified node. The number of deleted slots is returned.
    
    Specified by:
    
    clusterFlushslots in interface RedisClusterAsyncConnection<K,V>
    
    Returns:
    
    String simple-string-reply
  - clusterSlaves
```
public RedisFuture<List<String>> clusterSlaves(String nodeId)
```
    Description copied from interface: RedisClusterAsyncConnection
    
    List slaves for a certain node identified by its nodeId. Can be parsed using ClusterPartitionParser.parse(java.lang.String)
    
    Specified by:
    
    clusterSlaves in interface RedisClusterAsyncConnection<K,V>
    
    Parameters:
    
    nodeId - node id of the master node
    
    Returns:
    
    List<String> array-reply list of slaves. The command returns data in the same format as RedisClusterAsyncConnection.clusterNodes() but one line per slave.
  - zlexcount
```
public RedisFuture<Long> zlexcount(K key,
                                   String min,
                                   String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Count the number of members in a sorted set between a given lexicographical range.
    
    Specified by:
    
    zlexcount in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements in the specified score range.
  - zremrangebylex
```
public RedisFuture<Long> zremrangebylex(K key,
                                        String min,
                                        String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Remove all members in a sorted set between the given lexicographical range.
    
    Specified by:
    
    zremrangebylex in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<Long> integer-reply the number of elements removed.
  - zrangebylex
```
public RedisFuture<List<V>> zrangebylex(K key,
                                        String min,
                                        String max)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by lexicographical range.
    
    Specified by:
    
    zrangebylex in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - zrangebylex
```
public RedisFuture<List<V>> zrangebylex(K key,
                                        String min,
                                        String max,
                                        long offset,
                                        long count)
```
    Description copied from interface: RedisSortedSetsAsyncConnection
    
    Return a range of members in a sorted set, by lexicographical range.
    
    Specified by:
    
    zrangebylex in interface RedisSortedSetsAsyncConnection<K,V>
    
    Parameters:
    
    key - the key
    
    min - min score
    
    max - max score
    
    offset - the offset
    
    count - the count
    
    Returns:
    
    RedisFuture<List<V>> array-reply list of elements in the specified score range.
  - geoadd
```
public RedisFuture<Long> geoadd(K key,
                                double longitude,
                                double latitude,
                                V member)
```
    Description copied from interface: RedisGeoAsyncConnection
    
    Single geo add.
    
    Specified by:
    
    geoadd in interface RedisGeoAsyncConnection<K,V>
    
    Parameters:
    
    key - the key of the geo set
    
    longitude - the longitude coordinate according to WGS84
    
    latitude - the latitude coordinate according to WGS84
    
    member - the member to add
    
    Returns:
    
    Long integer-reply the number of elements that were added to the set
  - geoadd
```
public RedisFuture<Long> geoadd(K key,
                                Object... lngLatMember)
```
    Description copied from interface: RedisGeoAsyncConnection
    
    Multi geo add.
    
    Specified by:
    
    geoadd in interface RedisGeoAsyncConnection<K,V>
    
    Parameters:
    
    key - the key of the geo set
    
    lngLatMember - triplets of double longitude, double latitude and V member
    
    Returns:
    
    Long integer-reply the number of elements that were added to the set
  - georadius
```
public RedisFuture<Set<V>> georadius(K key,
                                     double longitude,
                                     double latitude,
                                     double distance,
                                     GeoArgs.Unit unit)
```
    Description copied from interface: RedisGeoAsyncConnection
    
    Retrieve members selected by distance with the center of longitude and latitude.
    
    Specified by:
    
    georadius in interface RedisGeoAsyncConnection<K,V>
    
    Parameters:
    
    key - the key of the geo set
    
    longitude - the longitude coordinate according to WGS84
    
    latitude - the latitude coordinate according to WGS84
    
    distance - radius distance
    
    unit - distance unit
    
    Returns:
    
    bulk reply
  - georadius
```
public RedisFuture<List<GeoWithin<V>>> georadius(K key,
                                                 double longitude,
                                                 double latitude,
                                                 double distance,
                                                 GeoArgs.Unit unit,
                                                 GeoArgs geoArgs)
```
    Description copied from interface: RedisGeoAsyncConnection
    
    Retrieve members selected by distance with the center of longitude and latitude.
    
    Specified by:
    
    georadius in interface RedisGeoAsyncConnection<K,V>
    
    Parameters:
    
    key - the key of the geo set
    
    longitude - the longitude coordinate according to WGS84
    
    latitude - the latitude coordinate according to WGS84
    
    distance - radius distance
    
    unit - distance unit
    
    geoArgs - args to control the result
    
    Returns:
    
    nested multi-bulk reply. The GeoWithin contains only fields which were requested by GeoArgs
  - georadiusbymember
```
public RedisFuture<Set<V>> georadiusbymember(K key,
                                             V member,
                                             double distance,
                                             GeoArgs.Unit unit)
```
    Description copied from interface: RedisGeoAsyncConnection
    
    Retrieve members selected by distance with the center of member. The member itself is always contained in the results.
    
    Specified by:
    
    georadiusbymember in interface RedisGeoAsyncConnection<K,V>
    
    Parameters:
    
    key - the key of the geo set
    
    member - reference member
    
    distance - radius distance
    
    unit - distance unit
    
    Returns:
    
    set of members
  - georadiusbymember
```
public RedisFuture<List<GeoWithin<V>>> georadiusbymember(K key,
                                                         V member,
                                                         double distance,
                                                         GeoArgs.Unit unit,
                                                         GeoArgs geoArgs)
```
    Description copied from interface: RedisGeoAsyncConnection
    
    Retrieve members selected by distance with the center of member. The member itself is always contained in the results.
    
    Specified by:
    
    georadiusbymember in interface RedisGeoAsyncConnection<K,V>
    
    Parameters:
    
    key - the key of the geo set
    
    member - reference member
    
    distance - radius distance
    
    unit - distance unit
    
    geoArgs - args to control the result
    
    Returns:
    
    nested multi-bulk reply. The GeoWithin contains only fields which were requested by GeoArgs
  - geopos
```
public RedisFuture<List<GeoCoordinates>> geopos(K key,
                                                V... members)
```
    Description copied from interface: RedisGeoAsyncConnection
    
    Get geo coordinates for the members.
    
    Specified by:
    
    geopos in interface RedisGeoAsyncConnection<K,V>
    
    Parameters:
    
    key - the key of the geo set
    
    members - the members
    
    Returns:
    
    a list of GeoCoordinatess representing the x,y position of each element specified in the arguments. For missing elements null is returned.
  - geodist
```
public RedisFuture<Double> geodist(K key,
                                   V from,
                                   V to,
                                   GeoArgs.Unit unit)
```
    Description copied from interface: RedisGeoAsyncConnection
    
    Retrieve distance between points from and to. If one or more elements are missing null is returned. Default in meters by , otherwise according to unit
    
    Specified by:
    
    geodist in interface RedisGeoAsyncConnection<K,V>
    
    Parameters:
    
    key - the key of the geo set
    
    from - from member
    
    to - to member
    
    unit - distance unit
    
    Returns:
    
    distance between points from and to. If one or more elements are missing null is returned.
  - dispatch
```
protected <T> RedisCommand<K,V,T> dispatch(CommandType type,
                                           CommandOutput<K,V,T> output)
```
  - dispatch
```
protected <T> RedisCommand<K,V,T> dispatch(CommandType type,
                                           CommandOutput<K,V,T> output,
                                           CommandArgs<K,V> args)
```
  - dispatch
```
public <T> RedisCommand<K,V,T> dispatch(RedisCommand<K,V,T> cmd)
```
    Overrides:
    
    dispatch in class RedisChannelHandler<K,V>
  - string
```
public static String string(double n)
```
  - isMulti
```
protected boolean isMulti()
```
  - activated
```
public void activated()
```
    Description copied from class: RedisChannelHandler
    
    Notification when the connection becomes active (connected).
    
    Overrides:
    
    activated in class RedisChannelHandler<K,V>

Class RedisAsyncConnectionImpl<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface io.netty.channel.ChannelHandler

Field Summary

Fields inherited from class com.lambdaworks.redis.RedisChannelHandler

Constructor Summary

Method Summary

Methods inherited from class com.lambdaworks.redis.RedisChannelHandler

Methods inherited from class io.netty.channel.ChannelInboundHandlerAdapter

Methods inherited from class io.netty.channel.ChannelHandlerAdapter

Methods inherited from class java.lang.Object

Methods inherited from interface com.lambdaworks.redis.RedisAsyncConnection

Methods inherited from interface com.lambdaworks.redis.RedisClusterAsyncConnection

Methods inherited from interface com.lambdaworks.redis.BaseRedisAsyncConnection

Methods inherited from interface io.netty.channel.ChannelHandler

Field Detail

multi

commandBuilder

codec

Constructor Detail

RedisAsyncConnectionImpl

Method Detail

append

auth

bgrewriteaof

bgsave

bitcount

bitcount

bitpos

bitpos

bitopAnd

bitopNot

bitopOr

bitopXor

blpop

brpop

brpoplpush

clientGetname

clientSetname

clientKill

clientKill

clientPause

clientList

command

commandInfo

commandInfo

commandCount

configGet

configResetstat

configSet

configRewrite

dbsize

debugObject

debugSegfault

debugOom

debugHtstats

decr

decrby

del

unlink

discard

dump

echo

eval

eval

evalsha

evalsha

exists

exists

expire

expireat

expireat

exec

flushall

flushallAsync

flushdb

flushdbAsync

get

getbit

getrange