JedisClusterConnection (Spring Data Redis 1.8.8.RELEASE API)

java.lang.Object
- org.springframework.data.redis.connection.jedis.JedisClusterConnection

All Implemented Interfaces:

HyperLogLogCommands, RedisClusterCommands, RedisClusterConnection, RedisCommands, RedisConnection, RedisConnectionCommands, RedisGeoCommands, RedisHashCommands, RedisKeyCommands, RedisListCommands, RedisPubSubCommands, RedisScriptingCommands, RedisServerCommands, RedisSetCommands, RedisStringCommands, RedisTxCommands, RedisZSetCommands
```
public class JedisClusterConnection
extends Object
implements RedisClusterConnection
```
RedisClusterConnection implementation on top of JedisCluster.
Uses the native JedisCluster api where possible and falls back to direct node communication using Jedis where needed.

Since:

1.7

Author:

Christoph Strobl, Mark Paluch, Ninad Divadkar

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static interface`	`JedisClusterConnection.JedisClusterCommandCallback<T>` `Jedis` specific `ClusterCommandExecutor.ClusterCommandCallback`.
`protected static interface`	`JedisClusterConnection.JedisMultiKeyClusterCommandCallback<T>` `Jedis` specific `ClusterCommandExecutor.MultiKeyClusterCommandCallback`.

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStringCommands
RedisStringCommands.BitOperation, RedisStringCommands.SetOption

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisListCommands
RedisListCommands.Position

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisZSetCommands
RedisZSetCommands.Aggregate, RedisZSetCommands.Limit, RedisZSetCommands.Range, RedisZSetCommands.Tuple

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisServerCommands
RedisServerCommands.MigrateOption, RedisServerCommands.ShutdownOption

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisGeoCommands
RedisGeoCommands.DistanceUnit, RedisGeoCommands.GeoLocation<T>, RedisGeoCommands.GeoRadiusCommandArgs

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisClusterCommands
RedisClusterCommands.AddSlots

Constructor Summary

Constructors
Constructor and Description
`JedisClusterConnection(redis.clients.jedis.JedisCluster cluster)` Create new `JedisClusterConnection` utilizing native connections via `JedisCluster`.
`JedisClusterConnection(redis.clients.jedis.JedisCluster cluster, ClusterCommandExecutor executor)` Create new `JedisClusterConnection` utilizing native connections via `JedisCluster` running commands across the cluster via given `ClusterCommandExecutor`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Long`	`append(byte[] key, byte[] value)` Append a `value` to `key`.
`void`	`bgReWriteAof()` Start an Append Only File rewrite process on server.
`void`	`bgReWriteAof(RedisClusterNode node)`
`void`	`bgSave()` Start background saving of db on server.
`void`	`bgSave(RedisClusterNode node)`
`void`	`bgWriteAof()` Start an Append Only File rewrite process on server.
`Long`	`bitCount(byte[] key)` Count the number of set bits (population counting) in value stored at `key`.
`Long`	`bitCount(byte[] key, long begin, long end)` Count the number of set bits (population counting) of value stored at `key` between `begin` and `end`.
`Long`	`bitOp(RedisStringCommands.BitOperation op, byte[] destination, byte[]... keys)` Perform bitwise operations between strings.
`List<byte[]>`	`bLPop(int timeout, byte[]... keys)` Removes and returns first element from lists stored at `keys`.
`List<byte[]>`	`bRPop(int timeout, byte[]... keys)` Removes and returns last element from lists stored at `keys`.
`byte[]`	`bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey)` Remove the last element from list at `srcKey`, append it to `dstKey` and return its value.
`void`	`close()` Closes (or quits) the connection.
`List<Object>`	`closePipeline()` Executes the commands in the pipeline and returns their result.
`void`	`clusterAddSlots(RedisClusterNode node, int... slots)` Assign slots to given `RedisClusterNode`.
`void`	`clusterAddSlots(RedisClusterNode node, RedisClusterNode.SlotRange range)` Assign `RedisClusterNode.SlotRange.getSlotsArray()` to given `RedisClusterNode`.
`Long`	`clusterCountKeysInSlot(int slot)` Count the number of keys assigned to one slot.
`void`	`clusterDeleteSlots(RedisClusterNode node, int... slots)` Remove slots from `RedisClusterNode`.
`void`	`clusterDeleteSlotsInRange(RedisClusterNode node, RedisClusterNode.SlotRange range)` Removes `RedisClusterNode.SlotRange.getSlotsArray()` from given `RedisClusterNode`.
`void`	`clusterForget(RedisClusterNode node)` Remove given node from cluster.
`ClusterInfo`	`clusterGetClusterInfo()` Get cluster information.
`List<byte[]>`	`clusterGetKeysInSlot(int slot, Integer count)` Get keys served by slot.
`Map<RedisClusterNode,Collection<RedisClusterNode>>`	`clusterGetMasterSlaveMap()` Retrieve information about masters and their connected slaves.
`RedisClusterNode`	`clusterGetNodeForKey(byte[] key)` Find the `RedisClusterNode` serving given key.
`RedisClusterNode`	`clusterGetNodeForSlot(int slot)` Find the `RedisClusterNode` serving given slot.
`Set<RedisClusterNode>`	`clusterGetNodes()` Retrieve cluster node information such as id, host, port and slots.
`Set<RedisClusterNode>`	`clusterGetSlaves(RedisClusterNode master)` Retrieve information about connected slaves for given master node.
`Integer`	`clusterGetSlotForKey(byte[] key)` Find the slot for a given `key`.
`void`	`clusterMeet(RedisClusterNode node)` Add given node to cluster.
`void`	`clusterReplicate(RedisClusterNode master, RedisClusterNode slave)` Assign a slave to given master.
`void`	`clusterSetSlot(RedisClusterNode node, int slot, RedisClusterCommands.AddSlots mode)`
`protected org.springframework.dao.DataAccessException`	`convertJedisAccessException(Exception ex)`
`Long`	`dbSize()` Get the total number of available keys in currently selected database.
`Long`	`dbSize(RedisClusterNode node)`
`Long`	`decr(byte[] key)` Decrement an integer value stored as string value of `key` by 1.
`Long`	`decrBy(byte[] key, long value)` Decrement an integer value stored as string value of `key` by `value`.
`Long`	`del(byte[]... keys)` Delete given `keys`.
`void`	`discard()` Discard all commands issued after `RedisTxCommands.multi()`.
`byte[]`	`dump(byte[] key)` Retrieve serialized version of the value stored at `key`.
`byte[]`	`echo(byte[] message)` Returns `message` via server roundtrip.
`<T> T`	`eval(byte[] script, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `script`.
`<T> T`	`evalSha(byte[] scriptSha, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `scriptSha`.
`<T> T`	`evalSha(String scriptSha, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `scriptSha`.
`List<Object>`	`exec()` Executes all queued commands in a transaction started with `RedisTxCommands.multi()`.
`Object`	`execute(String command, byte[]... args)` 'Native' or 'raw' execution of the given command along-side the given arguments.
`Boolean`	`exists(byte[] key)` Determine if given `key` exists.
`Boolean`	`expire(byte[] key, long seconds)` Set time to live for given `key` in seconds.
`Boolean`	`expireAt(byte[] key, long unixTime)` Set the expiration for given `key` as a UNIX timestamp.
`void`	`flushAll()` Delete all all keys from all databases.
`void`	`flushAll(RedisClusterNode node)`
`void`	`flushDb()` Delete all keys of the currently selected database.
`void`	`flushDb(RedisClusterNode node)`
`Long`	`geoAdd(byte[] key, Iterable<RedisGeoCommands.GeoLocation<byte[]>> locations)` Add `RedisGeoCommands.GeoLocation`s to key
`Long`	`geoAdd(byte[] key, Map<byte[],org.springframework.data.geo.Point> memberCoordinateMap)` Add `Map` of member / `Point` pairs to key.
`Long`	`geoAdd(byte[] key, org.springframework.data.geo.Point point, byte[] member)` Add `Point` with given member name to key.
`Long`	`geoAdd(byte[] key, RedisGeoCommands.GeoLocation<byte[]> location)` Add `RedisGeoCommands.GeoLocation` to key.
`org.springframework.data.geo.Distance`	`geoDist(byte[] key, byte[] member1, byte[] member2)` Get the `Distance` between member1 and member2.
`org.springframework.data.geo.Distance`	`geoDist(byte[] key, byte[] member1, byte[] member2, org.springframework.data.geo.Metric metric)` Get the `Distance` between member1 and member2 in the given `Metric`.
`List<String>`	`geoHash(byte[] key, byte[]... members)` Get Geohash representation of the position for one or more members.
`List<org.springframework.data.geo.Point>`	`geoPos(byte[] key, byte[]... members)` Get the `Point` representation of positions for one or more members.
`org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadius(byte[] key, org.springframework.data.geo.Circle within)` Get the members within the boundaries of a given `Circle`.
`org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadius(byte[] key, org.springframework.data.geo.Circle within, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the boundaries of a given `Circle` applying `RedisGeoCommands.GeoRadiusCommandArgs`.
`org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, org.springframework.data.geo.Distance radius)` Get the members within the circle defined by the members coordinates and given `Distance`.
`org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, org.springframework.data.geo.Distance radius, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the circle defined by the members coordinates, given `Distance` and `RedisGeoCommands.GeoRadiusCommandArgs`.
`org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, double radius)` Get the members within the circle defined by the members coordinates and given radius.
`Long`	`geoRemove(byte[] key, byte[]... members)` Remove the members.
`byte[]`	`get(byte[] key)` Get the value of `key`.
`Boolean`	`getBit(byte[] key, long offset)` Get the bit value at `offset` of value at `key`.
`List<RedisClientInfo>`	`getClientList()` Request information and statistics about connected clients.
`List<RedisClientInfo>`	`getClientList(RedisClusterNode node)`
`String`	`getClientName()` Returns the name of the current connection.
`List<String>`	`getConfig(RedisClusterNode node, String pattern)`
`List<String>`	`getConfig(String pattern)` Load configuration parameters for given `pattern` from server.
`redis.clients.jedis.JedisCluster`	`getNativeConnection()` Returns the native connection (the underlying library/driver object).
`byte[]`	`getRange(byte[] key, long begin, long end)` Get a substring of value of `key` between `begin` and `end`.
`RedisSentinelConnection`	`getSentinelConnection()`
`byte[]`	`getSet(byte[] key, byte[] value)` Set `value` of `key` and return its old value.
`Subscription`	`getSubscription()` Returns the current subscription for this connection or null if the connection is not subscribed.
`Long`	`hDel(byte[] key, byte[]... fields)` Delete given hash `fields`.
`Boolean`	`hExists(byte[] key, byte[] field)` Determine if given hash `field` exists.
`byte[]`	`hGet(byte[] key, byte[] field)` Get value for given `field` from hash at `key`.
`Map<byte[],byte[]>`	`hGetAll(byte[] key)` Get entire hash stored at `key`.
`Double`	`hIncrBy(byte[] key, byte[] field, double delta)` Increment `value` of a hash `field` by the given `delta`.
`Long`	`hIncrBy(byte[] key, byte[] field, long delta)` Increment `value` of a hash `field` by the given `delta`.
`Set<byte[]>`	`hKeys(byte[] key)` Get key set (fields) of hash at `key`.
`Long`	`hLen(byte[] key)` Get size of hash at `key`.
`List<byte[]>`	`hMGet(byte[] key, byte[]... fields)` Get values for given `fields` from hash at `key`.
`void`	`hMSet(byte[] key, Map<byte[],byte[]> hashes)` Set multiple hash fields to multiple values using data provided in `hashes`
`Cursor<Map.Entry<byte[],byte[]>>`	`hScan(byte[] key, ScanOptions options)` Use a `Cursor` to iterate over entries in hash at `key`.
`Boolean`	`hSet(byte[] key, byte[] field, byte[] value)` Set the `value` of a hash `field`.
`Boolean`	`hSetNX(byte[] key, byte[] field, byte[] value)` Set the `value` of a hash `field` only if `field` does not exist.
`List<byte[]>`	`hVals(byte[] key)` Get entry set (values) of hash at `field`.
`Long`	`incr(byte[] key)` Increment an integer value stored as string value of `key` by 1.
`Double`	`incrBy(byte[] key, double value)` Increment a floating point number value of `key` by `delta`.
`Long`	`incrBy(byte[] key, long value)` Increment an integer value stored of `key` by `delta`.
`Properties`	`info()` Load default server information like memory cpu utilization replication
`Properties`	`info(RedisClusterNode node)`
`Properties`	`info(RedisClusterNode node, String section)`
`Properties`	`info(String section)` Load server information for given `selection`.
`boolean`	`isClosed()` Indicates whether the underlying connection is closed or not.
`boolean`	`isPipelined()` Indicates whether the connection is currently pipelined or not.
`boolean`	`isQueueing()` Indicates whether the connection is in "queue"(or "MULTI") mode or not.
`boolean`	`isSubscribed()` Indicates whether the current connection is subscribed (to at least one channel) or not.
`Set<byte[]>`	`keys(byte[] pattern)` Find all keys matching the given `pattern`.
`Set<byte[]>`	`keys(RedisClusterNode node, byte[] pattern)`
`void`	`killClient(String host, int port)` Closes a given client connection identified by host:port.
`Long`	`lastSave()` Get time of last `RedisServerCommands.bgSave()` operation in seconds.
`Long`	`lastSave(RedisClusterNode node)`
`byte[]`	`lIndex(byte[] key, long index)` Get element at `index` form list at `key`.
`Long`	`lInsert(byte[] key, RedisListCommands.Position where, byte[] pivot, byte[] value)` Insert `value` `RedisListCommands.Position.BEFORE` or `RedisListCommands.Position.AFTER` existing `pivot` for `key`.
`Long`	`lLen(byte[] key)` Get the size of list stored at `key`.
`byte[]`	`lPop(byte[] key)` Removes and returns first element in list stored at `key`.
`Long`	`lPush(byte[] key, byte[]... values)` Prepend `values` to `key`.
`Long`	`lPushX(byte[] key, byte[] value)` Prepend `values` to `key` only if the list exists.
`List<byte[]>`	`lRange(byte[] key, long begin, long end)` Get elements between `start` and `end` from list at `key`.
`Long`	`lRem(byte[] key, long count, byte[] value)` Removes the first `count` occurrences of `value` from the list stored at `key`.
`void`	`lSet(byte[] key, long index, byte[] value)` Set the `value` list element at `index`.
`void`	`lTrim(byte[] key, long begin, long end)` Trim list at `key` to elements between `start` and `end`.
`List<byte[]>`	`mGet(byte[]... keys)` Get multiple `keys`.
`void`	`migrate(byte[] key, RedisNode target, int dbIndex, RedisServerCommands.MigrateOption option)` Atomically transfer a key from a source Redis instance to a destination Redis instance.
`void`	`migrate(byte[] key, RedisNode target, int dbIndex, RedisServerCommands.MigrateOption option, long timeout)` Atomically transfer a key from a source Redis instance to a destination Redis instance.
`Boolean`	`move(byte[] key, int dbIndex)` Move given `key` to database with `index`.
`void`	`mSet(Map<byte[],byte[]> tuples)` Set multiple keys to multiple values using key-value pairs provided in `tuple`.
`Boolean`	`mSetNX(Map<byte[],byte[]> tuples)` Set multiple keys to multiple values using key-value pairs provided in `tuple` only if the provided key does not exist.
`void`	`multi()` Mark the start of a transaction block.
`void`	`openPipeline()` Activates the pipeline mode for this connection.
`Boolean`	`persist(byte[] key)` Remove the expiration from given `key`.
`Boolean`	`pExpire(byte[] key, long millis)` Set time to live for given `key` in milliseconds.
`Boolean`	`pExpireAt(byte[] key, long unixTimeInMillis)` Set the expiration for given `key` as a UNIX timestamp in milliseconds.
`Long`	`pfAdd(byte[] key, byte[]... values)` Adds given values to the HyperLogLog stored at given key.
`Long`	`pfCount(byte[]... keys)` Return the approximated cardinality of the structures observed by the HyperLogLog at key(s).
`void`	`pfMerge(byte[] destinationKey, byte[]... sourceKeys)` Merge N different HyperLogLogs at sourceKeys into a single destinationKey.
`String`	`ping()` Test connection.
`String`	`ping(RedisClusterNode node)`
`void`	`pSetEx(byte[] key, long milliseconds, byte[] value)` Set the `value` and expiration in `milliseconds` for `key`.
`void`	`pSubscribe(MessageListener listener, byte[]... patterns)` Subscribes the connection to all channels matching the given patterns.
`Long`	`pTtl(byte[] key)` Get the precise time to live for `key` in milliseconds.
`Long`	`pTtl(byte[] key, TimeUnit timeUnit)` Get the precise time to live for `key` in and convert it to the given `TimeUnit`.
`Long`	`publish(byte[] channel, byte[] message)` Publishes the given message to the given channel.
`byte[]`	`randomKey()` Return a random key from the keyspace.
`byte[]`	`randomKey(RedisClusterNode node)`
`void`	`rename(byte[] sourceKey, byte[] targetKey)` Rename key `oldName` to `newName`.
`Boolean`	`renameNX(byte[] sourceKey, byte[] targetKey)` Rename key `oldName` to `newName` only if `newName` does not exist.
`void`	`resetConfigStats()` Reset statistic counters on server.
`void`	`resetConfigStats(RedisClusterNode node)`
`void`	`restore(byte[] key, long ttlInMillis, byte[] serializedValue)` Create `key` using the `serializedValue`, previously obtained using `RedisKeyCommands.dump(byte[])`.
`byte[]`	`rPop(byte[] key)` Removes and returns last element in list stored at `key`.
`byte[]`	`rPopLPush(byte[] srcKey, byte[] dstKey)` Remove the last element from list at `srcKey`, append it to `dstKey` and return its value.
`Long`	`rPush(byte[] key, byte[]... values)` Append `values` to `key`.
`Long`	`rPushX(byte[] key, byte[] value)` Append `values` to `key` only if the list exists.
`Long`	`sAdd(byte[] key, byte[]... values)` Add given `values` to set at `key`.
`void`	`save()` Synchronous save current db snapshot on server.
`void`	`save(RedisClusterNode node)`
`Cursor<byte[]>`	`scan(ScanOptions options)` Use a `Cursor` to iterate over keys.
`Long`	`sCard(byte[] key)` Get size of set at `key`.
`List<Boolean>`	`scriptExists(String... scriptShas)` Check if given `scriptShas` exist in script cache.
`void`	`scriptFlush()` Flush lua script cache.
`void`	`scriptKill()` Kill current lua script execution.
`String`	`scriptLoad(byte[] script)` Load lua script into scripts cache, without executing it.
`Set<byte[]>`	`sDiff(byte[]... keys)` Diff all sets for given `keys`.
`Long`	`sDiffStore(byte[] destKey, byte[]... keys)` Diff all sets for given `keys` and store result in `destKey`.
`void`	`select(int dbIndex)` Select the DB with given positive `dbIndex`.
`void`	`set(byte[] key, byte[] value)` Set `value` for `key`.
`void`	`set(byte[] key, byte[] value, Expiration expiration, RedisStringCommands.SetOption option)` Set `value` for `key` applying timeouts from `expiration` if set and inserting/updating values depending on `option`.
`Boolean`	`setBit(byte[] key, long offset, boolean value)` Sets the bit at `offset` in value stored at `key`.
`void`	`setClientName(byte[] name)` Assign given name to current connection.
`void`	`setConfig(RedisClusterNode node, String param, String value)`
`void`	`setConfig(String param, String value)` Set server configuration for `param` to `value`.
`void`	`setEx(byte[] key, long seconds, byte[] value)` Set the `value` and expiration in `seconds` for `key`.
`Boolean`	`setNX(byte[] key, byte[] value)` Set `value` for `key`, only if `key` does not exist.
`void`	`setRange(byte[] key, byte[] value, long offset)` Overwrite parts of `key` starting at the specified `offset` with given `value`.
`void`	`shutdown()` Shutdown server.
`void`	`shutdown(RedisClusterNode node)`
`void`	`shutdown(RedisServerCommands.ShutdownOption option)` Shutdown server.
`Set<byte[]>`	`sInter(byte[]... keys)` Returns the members intersecting all given sets at `keys`.
`Long`	`sInterStore(byte[] destKey, byte[]... keys)` Intersect all given sets at `keys` and store result in `destKey`.
`Boolean`	`sIsMember(byte[] key, byte[] value)` Check if set at `key` contains `value`.
`void`	`slaveOf(String host, int port)` Change redis replication setting to new master.
`void`	`slaveOfNoOne()` Change server into master.
`Set<byte[]>`	`sMembers(byte[] key)` Get all elements of set at `key`.
`Boolean`	`sMove(byte[] srcKey, byte[] destKey, byte[] value)` Move `value` from `srcKey` to `destKey`
`List<byte[]>`	`sort(byte[] key, SortParameters params)` Sort the elements for `key`.
`Long`	`sort(byte[] key, SortParameters params, byte[] storeKey)` Sort the elements for `key` and store result in `storeKey`.
`byte[]`	`sPop(byte[] key)` Remove and return a random member from set at `key`.
`byte[]`	`sRandMember(byte[] key)` Get random element from set at `key`.
`List<byte[]>`	`sRandMember(byte[] key, long count)` Get `count` random elements from set at `key`.
`Long`	`sRem(byte[] key, byte[]... values)` Remove given `values` from set at `key` and return the number of removed elements.
`Cursor<byte[]>`	`sScan(byte[] key, ScanOptions options)` Use a `Cursor` to iterate over elements in set at `key`.
`Long`	`strLen(byte[] key)` Get the length of the value stored at `key`.
`void`	`subscribe(MessageListener listener, byte[]... channels)` Subscribes the connection to the given channels.
`Set<byte[]>`	`sUnion(byte[]... keys)` Union all sets at given `keys`.
`Long`	`sUnionStore(byte[] destKey, byte[]... keys)` Union all sets at given `keys` and store result in `destKey`.
`Long`	`time()` Request server timestamp using `TIME` command.
`Long`	`time(RedisClusterNode node)`
`Long`	`ttl(byte[] key)` Get the time to live for `key` in seconds.
`Long`	`ttl(byte[] key, TimeUnit timeUnit)` Get the time to live for `key` in and convert it to the given `TimeUnit`.
`DataType`	`type(byte[] key)` Determine the type stored at `key`.
`void`	`unwatch()` Flushes all the previously `#watch(byte[]...)` keys.
`void`	`watch(byte[]... keys)` Watch given `keys` for modifications during transaction started with `RedisTxCommands.multi()`.
`Boolean`	`zAdd(byte[] key, double score, byte[] value)` Add `value` to a sorted set at `key`, or update its `score` if it already exists.
`Long`	`zAdd(byte[] key, Set<RedisZSetCommands.Tuple> tuples)` Add `tuples` to a sorted set at `key`, or update its `score` if it already exists.
`Long`	`zCard(byte[] key)` Get the size of sorted set with `key`.
`Long`	`zCount(byte[] key, double min, double max)` Count number of elements within sorted set with scores between `min` and `max`.
`Long`	`zCount(byte[] key, RedisZSetCommands.Range range)` Count number of elements within sorted set with scores between `Range#min` and `Range#max`.
`Double`	`zIncrBy(byte[] key, double increment, byte[] value)` Increment the score of element with `value` in sorted set by `increment`.
`Long`	`zInterStore(byte[] destKey, byte[]... sets)` Intersect sorted `sets` and store result in destination `key`.
`Long`	`zInterStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets)` Intersect sorted `sets` and store result in destination `key`.
`Set<byte[]>`	`zRange(byte[] key, long begin, long end)` Get elements between `start` and `end` from sorted set.
`Set<byte[]>`	`zRangeByLex(byte[] key)` Get all the elements in the sorted set at key in lexicographical ordering.
`Set<byte[]>`	`zRangeByLex(byte[] key, RedisZSetCommands.Range range)` Get all the elements in `RedisZSetCommands.Range` from the sorted set at key in lexicographical ordering.
`Set<byte[]>`	`zRangeByLex(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)` Get all the elements in `RedisZSetCommands.Range` from the sorted set at key in lexicographical ordering.
`Set<byte[]>`	`zRangeByScore(byte[] key, double min, double max)` Get elements where score is between `min` and `max` from sorted set.
`Set<byte[]>`	`zRangeByScore(byte[] key, double min, double max, long offset, long count)` Get elements in range from `start` to `end` where score is between `min` and `max` from sorted set.
`Set<byte[]>`	`zRangeByScore(byte[] key, RedisZSetCommands.Range range)` Get elements where score is between `Range#min` and `Range#max` from sorted set.
`Set<byte[]>`	`zRangeByScore(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)` Get elements in range from `Limit#count` to `Limit#offset` where score is between `Range#min` and `Range#max` from sorted set.
`Set<byte[]>`	`zRangeByScore(byte[] key, String min, String max)` Get elements where score is between `min` and `max` from sorted set.
`Set<byte[]>`	`zRangeByScore(byte[] key, String min, String max, long offset, long count)` Get elements in range from `start` to `end` where score is between `min` and `max` from sorted set.
`Set<RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, double min, double max)` Get set of `RedisZSetCommands.Tuple`s where score is between `min` and `max` from sorted set.
`Set<RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count)` Get set of `RedisZSetCommands.Tuple`s in range from `start` to `end` where score is between `min` and `max` from sorted set.
`Set<RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range)` Get set of `RedisZSetCommands.Tuple`s where score is between `Range#min` and `Range#max` from sorted set.
`Set<RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)` Get set of `RedisZSetCommands.Tuple`s in range from `Limit#offset` to `Limit#offset + Limit#count` where score is between `Range#min` and `Range#max` from sorted set.
`Set<RedisZSetCommands.Tuple>`	`zRangeWithScores(byte[] key, long begin, long end)` Get set of `RedisZSetCommands.Tuple`s between `start` and `end` from sorted set.
`Long`	`zRank(byte[] key, byte[] value)` Determine the index of element with `value` in a sorted set.
`Long`	`zRem(byte[] key, byte[]... values)` Remove `values` from sorted set.
`Long`	`zRemRange(byte[] key, long begin, long end)` Remove elements in range between `start` and `end` from sorted set with `key`.
`Long`	`zRemRangeByScore(byte[] key, double min, double max)` Remove elements with scores between `min` and `max` from sorted set with `key`.
`Long`	`zRemRangeByScore(byte[] key, RedisZSetCommands.Range range)` Remove elements with scores between `Range#min` and `Range#max` from sorted set with `key`.
`Set<byte[]>`	`zRevRange(byte[] key, long begin, long end)` Get elements in range from `start` to `end` from sorted set ordered from high to low.
`Set<byte[]>`	`zRevRangeByScore(byte[] key, double min, double max)` Get elements where score is between `min` and `max` from sorted set ordered from high to low.
`Set<byte[]>`	`zRevRangeByScore(byte[] key, double min, double max, long offset, long count)` Get elements in range from `start` to `end` where score is between `min` and `max` from sorted set ordered high -> low.
`Set<byte[]>`	`zRevRangeByScore(byte[] key, RedisZSetCommands.Range range)` Get elements where score is between `Range#min` and `Range#max` from sorted set ordered from high to low.
`Set<byte[]>`	`zRevRangeByScore(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)` Get elements in range from `Limit#offset` to `Limit#offset + Limit#count` where score is between `Range#min` and `Range#max` from sorted set ordered high -> low.
`Set<RedisZSetCommands.Tuple>`	`zRevRangeByScoreWithScores(byte[] key, double min, double max)` Get set of `RedisZSetCommands.Tuple` where score is between `min` and `max` from sorted set ordered from high to low.
`Set<RedisZSetCommands.Tuple>`	`zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count)` Get set of `RedisZSetCommands.Tuple` in range from `start` to `end` where score is between `min` and `max` from sorted set ordered high -> low.
`Set<RedisZSetCommands.Tuple>`	`zRevRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range)` Get set of `RedisZSetCommands.Tuple` where score is between `Range#min` and `Range#max` from sorted set ordered from high to low.
`Set<RedisZSetCommands.Tuple>`	`zRevRangeByScoreWithScores(byte[] key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)` Get set of `RedisZSetCommands.Tuple` in range from `Limit#offset` to `Limit#count` where score is between `Range#min` and `Range#max` from sorted set ordered high -> low.
`Set<RedisZSetCommands.Tuple>`	`zRevRangeWithScores(byte[] key, long begin, long end)` Get set of `RedisZSetCommands.Tuple`s in range from `start` to `end` from sorted set ordered from high to low.
`Long`	`zRevRank(byte[] key, byte[] value)` Determine the index of element with `value` in a sorted set when scored high to low.
`Cursor<RedisZSetCommands.Tuple>`	`zScan(byte[] key, ScanOptions options)` Use a `Cursor` to iterate over elements in sorted set at `key`.
`Double`	`zScore(byte[] key, byte[] value)` Get the score of element with `value` from sorted set with key `key`.
`Long`	`zUnionStore(byte[] destKey, byte[]... sets)` Union sorted `sets` and store result in destination `key`.
`Long`	`zUnionStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets)` Union sorted `sets` and store result in destination `key`.

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

- Constructor Detail
  - JedisClusterConnection
```
public JedisClusterConnection(redis.clients.jedis.JedisCluster cluster)
```
    Create new JedisClusterConnection utilizing native connections via JedisCluster.
    
    Parameters:
    
    cluster - must not be null.
  - JedisClusterConnection
```
public JedisClusterConnection(redis.clients.jedis.JedisCluster cluster,
                              ClusterCommandExecutor executor)
```
    Create new JedisClusterConnection utilizing native connections via JedisCluster running commands across the cluster via given ClusterCommandExecutor.
    
    Parameters:
    
    cluster - must not be null.
    
    executor - must not be null.
- Method Detail
  - execute
```
public Object execute(String command,
                      byte[]... args)
```
    Description copied from interface: RedisCommands
    
    'Native' or 'raw' execution of the given command along-side the given arguments. The command is executed as is, with as little 'interpretation' as possible - it is up to the caller to take care of any processing of arguments or the result.
    
    Specified by:
    
    execute in interface RedisCommands
    
    Parameters:
    
    command - Command to execute
    
    args - Possible command arguments (may be null)
    
    Returns:
    
    execution result.
  - del
```
public Long del(byte[]... keys)
```
    Description copied from interface: RedisKeyCommands
    
    Delete given keys.
    
    Specified by:
    
    del in interface RedisKeyCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    The number of keys that were removed.
    
    See Also:
    
    Redis Documentation: DEL
  - type
```
public DataType type(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Determine the type stored at key.
    
    Specified by:
    
    type in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: TYPE
  - keys
```
public Set<byte[]> keys(byte[] pattern)
```
    Description copied from interface: RedisKeyCommands
    
    Find all keys matching the given pattern.
    
    Specified by:
    
    keys in interface RedisKeyCommands
    
    Parameters:
    
    pattern - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: KEYS
  - keys
```
public Set<byte[]> keys(RedisClusterNode node,
                        byte[] pattern)
```
    Specified by:
    
    keys in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    pattern - must not be null.
    
    Returns:
    
    See Also:
    
    RedisKeyCommands.keys(byte[])
  - scan
```
public Cursor<byte[]> scan(ScanOptions options)
```
    Description copied from interface: RedisKeyCommands
    
    Use a Cursor to iterate over keys.
    
    Specified by:
    
    scan in interface RedisKeyCommands
    
    Parameters:
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SCAN
  - randomKey
```
public byte[] randomKey()
```
    Description copied from interface: RedisKeyCommands
    
    Return a random key from the keyspace.
    
    Specified by:
    
    randomKey in interface RedisKeyCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: RANDOMKEY
  - randomKey
```
public byte[] randomKey(RedisClusterNode node)
```
    Specified by:
    
    randomKey in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisKeyCommands.randomKey()
  - rename
```
public void rename(byte[] sourceKey,
                   byte[] targetKey)
```
    Description copied from interface: RedisKeyCommands
    
    Rename key oldName to newName.
    
    Specified by:
    
    rename in interface RedisKeyCommands
    
    Parameters:
    
    sourceKey - must not be null.
    
    targetKey - must not be null.
    
    See Also:
    
    Redis Documentation: RENAME
  - renameNX
```
public Boolean renameNX(byte[] sourceKey,
                        byte[] targetKey)
```
    Description copied from interface: RedisKeyCommands
    
    Rename key oldName to newName only if newName does not exist.
    
    Specified by:
    
    renameNX in interface RedisKeyCommands
    
    Parameters:
    
    sourceKey - must not be null.
    
    targetKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RENAMENX
  - expire
```
public Boolean expire(byte[] key,
                      long seconds)
```
    Description copied from interface: RedisKeyCommands
    
    Set time to live for given key in seconds.
    
    Specified by:
    
    expire in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EXPIRE
  - pExpire
```
public Boolean pExpire(byte[] key,
                       long millis)
```
    Description copied from interface: RedisKeyCommands
    
    Set time to live for given key in milliseconds.
    
    Specified by:
    
    pExpire in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PEXPIRE
  - expireAt
```
public Boolean expireAt(byte[] key,
                        long unixTime)
```
    Description copied from interface: RedisKeyCommands
    
    Set the expiration for given key as a UNIX timestamp.
    
    Specified by:
    
    expireAt in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EXPIREAT
  - pExpireAt
```
public Boolean pExpireAt(byte[] key,
                         long unixTimeInMillis)
```
    Description copied from interface: RedisKeyCommands
    
    Set the expiration for given key as a UNIX timestamp in milliseconds.
    
    Specified by:
    
    pExpireAt in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PEXPIREAT
  - persist
```
public Boolean persist(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Remove the expiration from given key.
    
    Specified by:
    
    persist in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PERSIST
  - move
```
public Boolean move(byte[] key,
                    int dbIndex)
```
    Description copied from interface: RedisKeyCommands
    
    Move given key to database with index.
    
    Specified by:
    
    move in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: MOVE
  - ttl
```
public Long ttl(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the time to live for key in seconds.
    
    Specified by:
    
    ttl in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: TTL
  - ttl
```
public Long ttl(byte[] key,
                TimeUnit timeUnit)
```
    Description copied from interface: RedisKeyCommands
    
    Get the time to live for key in and convert it to the given TimeUnit.
    
    Specified by:
    
    ttl in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    timeUnit - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: TTL
  - pTtl
```
public Long pTtl(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the precise time to live for key in milliseconds.
    
    Specified by:
    
    pTtl in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PTTL
  - pTtl
```
public Long pTtl(byte[] key,
                 TimeUnit timeUnit)
```
    Description copied from interface: RedisKeyCommands
    
    Get the precise time to live for key in and convert it to the given TimeUnit.
    
    Specified by:
    
    pTtl in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    timeUnit - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PTTL
  - sort
```
public List<byte[]> sort(byte[] key,
                         SortParameters params)
```
    Description copied from interface: RedisKeyCommands
    
    Sort the elements for key.
    
    Specified by:
    
    sort in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    params - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SORT
  - sort
```
public Long sort(byte[] key,
                 SortParameters params,
                 byte[] storeKey)
```
    Description copied from interface: RedisKeyCommands
    
    Sort the elements for key and store result in storeKey.
    
    Specified by:
    
    sort in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    params - must not be null.
    
    storeKey - must not be null.
    
    Returns:
    
    number of values.
    
    See Also:
    
    Redis Documentation: SORT
  - dump
```
public byte[] dump(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Retrieve serialized version of the value stored at key.
    
    Specified by:
    
    dump in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: DUMP
  - restore
```
public void restore(byte[] key,
                    long ttlInMillis,
                    byte[] serializedValue)
```
    Description copied from interface: RedisKeyCommands
    
    Create key using the serializedValue, previously obtained using RedisKeyCommands.dump(byte[]).
    
    Specified by:
    
    restore in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    serializedValue - must not be null.
    
    See Also:
    
    Redis Documentation: RESTORE
  - get
```
public byte[] get(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Get the value of key.
    
    Specified by:
    
    get in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: GET
  - getSet
```
public byte[] getSet(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value of key and return its old value.
    
    Specified by:
    
    getSet in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: GETSET
  - mGet
```
public List<byte[]> mGet(byte[]... keys)
```
    Description copied from interface: RedisStringCommands
    
    Get multiple keys. Values are returned in the order of the requested keys.
    
    Specified by:
    
    mGet in interface RedisStringCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: MGET
  - set
```
public void set(byte[] key,
                byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value for key.
    
    Specified by:
    
    set in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    See Also:
    
    Redis Documentation: SET
  - set
```
public void set(byte[] key,
                byte[] value,
                Expiration expiration,
                RedisStringCommands.SetOption option)
```
    Description copied from interface: RedisStringCommands
    
    Set value for key applying timeouts from expiration if set and inserting/updating values depending on option.
    
    Specified by:
    
    set in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    expiration - can be null. Defaulted to Expiration.persistent().
    
    option - can be null. Defaulted to RedisStringCommands.SetOption.UPSERT.
    
    See Also:
    
    Redis Documentation: SET
  - setNX
```
public Boolean setNX(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value for key, only if key does not exist.
    
    Specified by:
    
    setNX in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SETNX
  - setEx
```
public void setEx(byte[] key,
                  long seconds,
                  byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set the value and expiration in seconds for key.
    
    Specified by:
    
    setEx in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    See Also:
    
    Redis Documentation: SETEX
  - pSetEx
```
public void pSetEx(byte[] key,
                   long milliseconds,
                   byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set the value and expiration in milliseconds for key.
    
    Specified by:
    
    pSetEx in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    See Also:
    
    Redis Documentation: PSETEX
  - mSet
```
public void mSet(Map<byte[],byte[]> tuples)
```
    Description copied from interface: RedisStringCommands
    
    Set multiple keys to multiple values using key-value pairs provided in tuple.
    
    Specified by:
    
    mSet in interface RedisStringCommands
    
    Parameters:
    
    tuples - must not be null.
    
    See Also:
    
    Redis Documentation: MSET
  - mSetNX
```
public Boolean mSetNX(Map<byte[],byte[]> tuples)
```
    Description copied from interface: RedisStringCommands
    
    Set multiple keys to multiple values using key-value pairs provided in tuple only if the provided key does not exist.
    
    Specified by:
    
    mSetNX in interface RedisStringCommands
    
    Parameters:
    
    tuples - must not be null.
    
    See Also:
    
    Redis Documentation: MSETNX
  - incr
```
public Long incr(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Increment an integer value stored as string value of key by 1.
    
    Specified by:
    
    incr in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: INCR
  - incrBy
```
public Long incrBy(byte[] key,
                   long value)
```
    Description copied from interface: RedisStringCommands
    
    Increment an integer value stored of key by delta.
    
    Specified by:
    
    incrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: INCRBY
  - incrBy
```
public Double incrBy(byte[] key,
                     double value)
```
    Description copied from interface: RedisStringCommands
    
    Increment a floating point number value of key by delta.
    
    Specified by:
    
    incrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: INCRBYFLOAT
  - decr
```
public Long decr(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Decrement an integer value stored as string value of key by 1.
    
    Specified by:
    
    decr in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: DECR
  - decrBy
```
public Long decrBy(byte[] key,
                   long value)
```
    Description copied from interface: RedisStringCommands
    
    Decrement an integer value stored as string value of key by value.
    
    Specified by:
    
    decrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: DECRBY
  - append
```
public Long append(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Append a value to key.
    
    Specified by:
    
    append in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: APPEND
  - getRange
```
public byte[] getRange(byte[] key,
                       long begin,
                       long end)
```
    Description copied from interface: RedisStringCommands
    
    Get a substring of value of key between begin and end.
    
    Specified by:
    
    getRange in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: GETRANGE
  - setRange
```
public void setRange(byte[] key,
                     byte[] value,
                     long offset)
```
    Description copied from interface: RedisStringCommands
    
    Overwrite parts of key starting at the specified offset with given value.
    
    Specified by:
    
    setRange in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: SETRANGE
  - getBit
```
public Boolean getBit(byte[] key,
                      long offset)
```
    Description copied from interface: RedisStringCommands
    
    Get the bit value at offset of value at key.
    
    Specified by:
    
    getBit in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: GETBIT
  - setBit
```
public Boolean setBit(byte[] key,
                      long offset,
                      boolean value)
```
    Description copied from interface: RedisStringCommands
    
    Sets the bit at offset in value stored at key.
    
    Specified by:
    
    setBit in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    the original bit value stored at offset.
    
    See Also:
    
    Redis Documentation: SETBIT
  - bitCount
```
public Long bitCount(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Count the number of set bits (population counting) in value stored at key.
    
    Specified by:
    
    bitCount in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BITCOUNT
  - bitCount
```
public Long bitCount(byte[] key,
                     long begin,
                     long end)
```
    Description copied from interface: RedisStringCommands
    
    Count the number of set bits (population counting) of value stored at key between begin and end.
    
    Specified by:
    
    bitCount in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BITCOUNT
  - bitOp
```
public Long bitOp(RedisStringCommands.BitOperation op,
                  byte[] destination,
                  byte[]... keys)
```
    Description copied from interface: RedisStringCommands
    
    Perform bitwise operations between strings.
    
    Specified by:
    
    bitOp in interface RedisStringCommands
    
    Parameters:
    
    op - must not be null.
    
    destination - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BITOP
  - strLen
```
public Long strLen(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Get the length of the value stored at key.
    
    Specified by:
    
    strLen in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: STRLEN
  - rPush
```
public Long rPush(byte[] key,
                  byte[]... values)
```
    Description copied from interface: RedisListCommands
    
    Append values to key.
    
    Specified by:
    
    rPush in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPUSH
  - lPush
```
public Long lPush(byte[] key,
                  byte[]... values)
```
    Description copied from interface: RedisListCommands
    
    Prepend values to key.
    
    Specified by:
    
    lPush in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LPUSH
  - rPushX
```
public Long rPushX(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Append values to key only if the list exists.
    
    Specified by:
    
    rPushX in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPUSHX
  - lPushX
```
public Long lPushX(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Prepend values to key only if the list exists.
    
    Specified by:
    
    lPushX in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LPUSHX
  - lLen
```
public Long lLen(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Get the size of list stored at key.
    
    Specified by:
    
    lLen in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LLEN
  - lRange
```
public List<byte[]> lRange(byte[] key,
                           long begin,
                           long end)
```
    Description copied from interface: RedisListCommands
    
    Get elements between start and end from list at key.
    
    Specified by:
    
    lRange in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LRANGE
  - lTrim
```
public void lTrim(byte[] key,
                  long begin,
                  long end)
```
    Description copied from interface: RedisListCommands
    
    Trim list at key to elements between start and end.
    
    Specified by:
    
    lTrim in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: LTRIM
  - lIndex
```
public byte[] lIndex(byte[] key,
                     long index)
```
    Description copied from interface: RedisListCommands
    
    Get element at index form list at key.
    
    Specified by:
    
    lIndex in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LINDEX
  - lInsert
```
public Long lInsert(byte[] key,
                    RedisListCommands.Position where,
                    byte[] pivot,
                    byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Insert value RedisListCommands.Position.BEFORE or RedisListCommands.Position.AFTER existing pivot for key.
    
    Specified by:
    
    lInsert in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    where - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LINSERT
  - lSet
```
public void lSet(byte[] key,
                 long index,
                 byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Set the value list element at index.
    
    Specified by:
    
    lSet in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    See Also:
    
    Redis Documentation: LSET
  - lRem
```
public Long lRem(byte[] key,
                 long count,
                 byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Removes the first count occurrences of value from the list stored at key.
    
    Specified by:
    
    lRem in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LREM
  - lPop
```
public byte[] lPop(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns first element in list stored at key.
    
    Specified by:
    
    lPop in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: LPOP
  - rPop
```
public byte[] rPop(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns last element in list stored at key.
    
    Specified by:
    
    rPop in interface RedisListCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPOP
  - bLPop
```
public List<byte[]> bLPop(int timeout,
                          byte[]... keys)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns first element from lists stored at keys.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bLPop in interface RedisListCommands
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BLPOP, RedisListCommands.lPop(byte[])
  - bRPop
```
public List<byte[]> bRPop(int timeout,
                          byte[]... keys)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns last element from lists stored at keys.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bRPop in interface RedisListCommands
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BRPOP, RedisListCommands.rPop(byte[])
  - rPopLPush
```
public byte[] rPopLPush(byte[] srcKey,
                        byte[] dstKey)
```
    Description copied from interface: RedisListCommands
    
    Remove the last element from list at srcKey, append it to dstKey and return its value.
    
    Specified by:
    
    rPopLPush in interface RedisListCommands
    
    Parameters:
    
    srcKey - must not be null.
    
    dstKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: RPOPLPUSH
  - bRPopLPush
```
public byte[] bRPopLPush(int timeout,
                         byte[] srcKey,
                         byte[] dstKey)
```
    Description copied from interface: RedisListCommands
    
    Remove the last element from list at srcKey, append it to dstKey and return its value.
    Blocks connection until element available or timeout reached.
    
    Specified by:
    
    bRPopLPush in interface RedisListCommands
    
    srcKey - must not be null.
    
    dstKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: BRPOPLPUSH, RedisListCommands.rPopLPush(byte[], byte[])
  - sAdd
```
public Long sAdd(byte[] key,
                 byte[]... values)
```
    Description copied from interface: RedisSetCommands
    
    Add given values to set at key.
    
    Specified by:
    
    sAdd in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SADD
  - sRem
```
public Long sRem(byte[] key,
                 byte[]... values)
```
    Description copied from interface: RedisSetCommands
    
    Remove given values from set at key and return the number of removed elements.
    
    Specified by:
    
    sRem in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SREM
  - sPop
```
public byte[] sPop(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Remove and return a random member from set at key.
    
    Specified by:
    
    sPop in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SPOP
  - sMove
```
public Boolean sMove(byte[] srcKey,
                     byte[] destKey,
                     byte[] value)
```
    Description copied from interface: RedisSetCommands
    
    Move value from srcKey to destKey
    
    Specified by:
    
    sMove in interface RedisSetCommands
    
    Parameters:
    
    srcKey - must not be null.
    
    destKey - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SMOVE
  - sCard
```
public Long sCard(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get size of set at key.
    
    Specified by:
    
    sCard in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SCARD
  - sIsMember
```
public Boolean sIsMember(byte[] key,
                         byte[] value)
```
    Description copied from interface: RedisSetCommands
    
    Check if set at key contains value.
    
    Specified by:
    
    sIsMember in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SISMEMBER
  - sInter
```
public Set<byte[]> sInter(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Returns the members intersecting all given sets at keys.
    
    Specified by:
    
    sInter in interface RedisSetCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SINTER
  - sInterStore
```
public Long sInterStore(byte[] destKey,
                        byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Intersect all given sets at keys and store result in destKey.
    
    Specified by:
    
    sInterStore in interface RedisSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SINTERSTORE
  - sUnion
```
public Set<byte[]> sUnion(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Union all sets at given keys.
    
    Specified by:
    
    sUnion in interface RedisSetCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SUNION
  - sUnionStore
```
public Long sUnionStore(byte[] destKey,
                        byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Union all sets at given keys and store result in destKey.
    
    Specified by:
    
    sUnionStore in interface RedisSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SUNIONSTORE
  - sDiff
```
public Set<byte[]> sDiff(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Diff all sets for given keys.
    
    Specified by:
    
    sDiff in interface RedisSetCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SDIFF
  - sDiffStore
```
public Long sDiffStore(byte[] destKey,
                       byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Diff all sets for given keys and store result in destKey.
    
    Specified by:
    
    sDiffStore in interface RedisSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SDIFFSTORE
  - sMembers
```
public Set<byte[]> sMembers(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get all elements of set at key.
    
    Specified by:
    
    sMembers in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SMEMBERS
  - sRandMember
```
public byte[] sRandMember(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get random element from set at key.
    
    Specified by:
    
    sRandMember in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SRANDMEMBER
  - sRandMember
```
public List<byte[]> sRandMember(byte[] key,
                                long count)
```
    Description copied from interface: RedisSetCommands
    
    Get count random elements from set at key.
    
    Specified by:
    
    sRandMember in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SRANDMEMBER
  - sScan
```
public Cursor<byte[]> sScan(byte[] key,
                            ScanOptions options)
```
    Description copied from interface: RedisSetCommands
    
    Use a Cursor to iterate over elements in set at key.
    
    Specified by:
    
    sScan in interface RedisSetCommands
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SCAN
  - zAdd
```
public Boolean zAdd(byte[] key,
                    double score,
                    byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Add value to a sorted set at key, or update its score if it already exists.
    
    Specified by:
    
    zAdd in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    score - the score.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZADD
  - zAdd
```
public Long zAdd(byte[] key,
                 Set<RedisZSetCommands.Tuple> tuples)
```
    Description copied from interface: RedisZSetCommands
    
    Add tuples to a sorted set at key, or update its score if it already exists.
    
    Specified by:
    
    zAdd in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    tuples - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZADD
  - zRem
```
public Long zRem(byte[] key,
                 byte[]... values)
```
    Description copied from interface: RedisZSetCommands
    
    Remove values from sorted set. Return number of removed elements.
    
    Specified by:
    
    zRem in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREM
  - zIncrBy
```
public Double zIncrBy(byte[] key,
                      double increment,
                      byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Increment the score of element with value in sorted set by increment.
    
    Specified by:
    
    zIncrBy in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZINCRBY
  - zRank
```
public Long zRank(byte[] key,
                  byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Determine the index of element with value in a sorted set.
    
    Specified by:
    
    zRank in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANK
  - zRevRank
```
public Long zRevRank(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Determine the index of element with value in a sorted set when scored high to low.
    
    Specified by:
    
    zRevRank in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANK
  - zRange
```
public Set<byte[]> zRange(byte[] key,
                          long begin,
                          long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements between start and end from sorted set.
    
    Specified by:
    
    zRange in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGE
  - zRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                            RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples where score is between Range#min and Range#max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                            RedisZSetCommands.Range range,
                                                            RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples in range from Limit#offset to Limit#offset + Limit#count where score is between Range#min and Range#max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRevRangeByScore
```
public Set<byte[]> zRevRangeByScore(byte[] key,
                                    RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between Range#min and Range#max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScore
```
public Set<byte[]> zRevRangeByScore(byte[] key,
                                    RedisZSetCommands.Range range,
                                    RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from Limit#offset to Limit#offset + Limit#count where score is between Range#min and Range#max from sorted set ordered high -> low.
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                               RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuple where score is between Range#min and Range#max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                               RedisZSetCommands.Range range,
                                                               RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuple in range from Limit#offset to Limit#count where score is between Range#min and Range#max from sorted set ordered high -> low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zCount
```
public Long zCount(byte[] key,
                   RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Count number of elements within sorted set with scores between Range#min and Range#max.
    
    Specified by:
    
    zCount in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZCOUNT
  - zRemRangeByScore
```
public Long zRemRangeByScore(byte[] key,
                             RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Remove elements with scores between Range#min and Range#max from sorted set with key.
    
    Specified by:
    
    zRemRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYSCORE
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between Range#min and Range#max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 RedisZSetCommands.Range range,
                                 RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from Limit#count to Limit#offset where score is between Range#min and Range#max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByLex
```
public Set<byte[]> zRangeByLex(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Get all the elements in the sorted set at key in lexicographical ordering.
    
    Specified by:
    
    zRangeByLex in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX
  - zRangeByLex
```
public Set<byte[]> zRangeByLex(byte[] key,
                               RedisZSetCommands.Range range)
```
    Description copied from interface: RedisZSetCommands
    
    Get all the elements in RedisZSetCommands.Range from the sorted set at key in lexicographical ordering.
    
    Specified by:
    
    zRangeByLex in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX
  - zRangeByLex
```
public Set<byte[]> zRangeByLex(byte[] key,
                               RedisZSetCommands.Range range,
                               RedisZSetCommands.Limit limit)
```
    Description copied from interface: RedisZSetCommands
    
    Get all the elements in RedisZSetCommands.Range from the sorted set at key in lexicographical ordering. Result is limited via RedisZSetCommands.Limit.
    
    Specified by:
    
    zRangeByLex in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYLEX
  - zRangeWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeWithScores(byte[] key,
                                                     long begin,
                                                     long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples between start and end from sorted set.
    
    Specified by:
    
    zRangeWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGE
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 double min,
                                 double max)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                            double min,
                                                            double max)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                            double min,
                                                            double max,
                                                            long offset,
                                                            long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRevRange
```
public Set<byte[]> zRevRange(byte[] key,
                             long begin,
                             long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from start to end from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRange in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGE
  - zRevRangeWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key,
                                                        long begin,
                                                        long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples in range from start to end from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGE
  - zRevRangeByScore
```
public Set<byte[]> zRevRangeByScore(byte[] key,
                                    double min,
                                    double max)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between min and max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGE
  - zRevRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                               double min,
                                                               double max)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuple where score is between min and max from sorted set ordered from high to low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScore
```
public Set<byte[]> zRevRangeByScore(byte[] key,
                                    double min,
                                    double max,
                                    long offset,
                                    long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from start to end where score is between min and max from sorted set ordered high -> low.
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zRevRangeByScoreWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                               double min,
                                                               double max,
                                                               long offset,
                                                               long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuple in range from start to end where score is between min and max from sorted set ordered high -> low.
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREVRANGEBYSCORE
  - zCount
```
public Long zCount(byte[] key,
                   double min,
                   double max)
```
    Description copied from interface: RedisZSetCommands
    
    Count number of elements within sorted set with scores between min and max.
    
    Specified by:
    
    zCount in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZCOUNT
  - zCard
```
public Long zCard(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Get the size of sorted set with key.
    
    Specified by:
    
    zCard in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZCARD
  - zScore
```
public Double zScore(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Get the score of element with value from sorted set with key key.
    
    Specified by:
    
    zScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    value - the value.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZSCORE
  - zRemRange
```
public Long zRemRange(byte[] key,
                      long begin,
                      long end)
```
    Description copied from interface: RedisZSetCommands
    
    Remove elements in range between start and end from sorted set with key.
    
    Specified by:
    
    zRemRange in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYRANK
  - zRemRangeByScore
```
public Long zRemRangeByScore(byte[] key,
                             double min,
                             double max)
```
    Description copied from interface: RedisZSetCommands
    
    Remove elements with scores between min and max from sorted set with key.
    
    Specified by:
    
    zRemRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZREMRANGEBYSCORE
  - zUnionStore
```
public Long zUnionStore(byte[] destKey,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Union sorted sets and store result in destination key.
    
    Specified by:
    
    zUnionStore in interface RedisZSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZUNIONSTORE
  - zUnionStore
```
public Long zUnionStore(byte[] destKey,
                        RedisZSetCommands.Aggregate aggregate,
                        int[] weights,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Union sorted sets and store result in destination key.
    
    Specified by:
    
    zUnionStore in interface RedisZSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    aggregate - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZUNIONSTORE
  - zInterStore
```
public Long zInterStore(byte[] destKey,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Intersect sorted sets and store result in destination key.
    
    Specified by:
    
    zInterStore in interface RedisZSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZINTERSTORE
  - zInterStore
```
public Long zInterStore(byte[] destKey,
                        RedisZSetCommands.Aggregate aggregate,
                        int[] weights,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Intersect sorted sets and store result in destination key.
    
    Specified by:
    
    zInterStore in interface RedisZSetCommands
    
    Parameters:
    
    destKey - must not be null.
    
    aggregate - must not be null.
    
    sets - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZINTERSTORE
  - zScan
```
public Cursor<RedisZSetCommands.Tuple> zScan(byte[] key,
                                             ScanOptions options)
```
    Description copied from interface: RedisZSetCommands
    
    Use a Cursor to iterate over elements in sorted set at key.
    
    Specified by:
    
    zScan in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZSCAN
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 String min,
                                 String max)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(byte[] key,
                                 String min,
                                 String max,
                                 long offset,
                                 long count)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from start to end where score is between min and max from sorted set.
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Parameters:
    
    key - must not be null.
    
    min - must not be null.
    
    max - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ZRANGEBYSCORE
  - hSet
```
public Boolean hSet(byte[] key,
                    byte[] field,
                    byte[] value)
```
    Description copied from interface: RedisHashCommands
    
    Set the value of a hash field.
    
    Specified by:
    
    hSet in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HSET
  - hSetNX
```
public Boolean hSetNX(byte[] key,
                      byte[] field,
                      byte[] value)
```
    Description copied from interface: RedisHashCommands
    
    Set the value of a hash field only if field does not exist.
    
    Specified by:
    
    hSetNX in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HSETNX
  - hGet
```
public byte[] hGet(byte[] key,
                   byte[] field)
```
    Description copied from interface: RedisHashCommands
    
    Get value for given field from hash at key.
    
    Specified by:
    
    hGet in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HGET
  - hMGet
```
public List<byte[]> hMGet(byte[] key,
                          byte[]... fields)
```
    Description copied from interface: RedisHashCommands
    
    Get values for given fields from hash at key.
    
    Specified by:
    
    hMGet in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    fields - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HMGET
  - hMSet
```
public void hMSet(byte[] key,
                  Map<byte[],byte[]> hashes)
```
    Description copied from interface: RedisHashCommands
    
    Set multiple hash fields to multiple values using data provided in hashes
    
    Specified by:
    
    hMSet in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    hashes - must not be null.
    
    See Also:
    
    Redis Documentation: HMSET
  - hIncrBy
```
public Long hIncrBy(byte[] key,
                    byte[] field,
                    long delta)
```
    Description copied from interface: RedisHashCommands
    
    Increment value of a hash field by the given delta.
    
    Specified by:
    
    hIncrBy in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HINCRBY
  - hIncrBy
```
public Double hIncrBy(byte[] key,
                      byte[] field,
                      double delta)
```
    Description copied from interface: RedisHashCommands
    
    Increment value of a hash field by the given delta.
    
    Specified by:
    
    hIncrBy in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HINCRBYFLOAT
  - hExists
```
public Boolean hExists(byte[] key,
                       byte[] field)
```
    Description copied from interface: RedisHashCommands
    
    Determine if given hash field exists.
    
    Specified by:
    
    hExists in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    field - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HEXISTS
  - hDel
```
public Long hDel(byte[] key,
                 byte[]... fields)
```
    Description copied from interface: RedisHashCommands
    
    Delete given hash fields.
    
    Specified by:
    
    hDel in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    fields - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HDEL
  - hLen
```
public Long hLen(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get size of hash at key.
    
    Specified by:
    
    hLen in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HLEN
  - hKeys
```
public Set<byte[]> hKeys(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get key set (fields) of hash at key.
    
    Specified by:
    
    hKeys in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HKEYS?
  - hVals
```
public List<byte[]> hVals(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get entry set (values) of hash at field.
    
    Specified by:
    
    hVals in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HVALS
  - hGetAll
```
public Map<byte[],byte[]> hGetAll(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get entire hash stored at key.
    
    Specified by:
    
    hGetAll in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HGETALL
  - hScan
```
public Cursor<Map.Entry<byte[],byte[]>> hScan(byte[] key,
                                              ScanOptions options)
```
    Description copied from interface: RedisHashCommands
    
    Use a Cursor to iterate over entries in hash at key.
    
    Specified by:
    
    hScan in interface RedisHashCommands
    
    Parameters:
    
    key - must not be null.
    
    options - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: HSCAN
  - multi
```
public void multi()
```
    Description copied from interface: RedisTxCommands
    
    Mark the start of a transaction block.
    Commands will be queued and can then be executed by calling RedisTxCommands.exec() or rolled back using RedisTxCommands.discard()
    
    Specified by:
    
    multi in interface RedisTxCommands
    
    See Also:
    
    Redis Documentation: MULTI
  - exec
```
public List<Object> exec()
```
    Description copied from interface: RedisTxCommands
    
    Executes all queued commands in a transaction started with RedisTxCommands.multi().
    If used along with #watch(byte[]...) the operation will fail if any of watched keys has been modified.
    
    Specified by:
    
    exec in interface RedisTxCommands
    
    Returns:
    
    List of replies for each executed command.
    
    See Also:
    
    Redis Documentation: EXEC
  - discard
```
public void discard()
```
    Description copied from interface: RedisTxCommands
    
    Discard all commands issued after RedisTxCommands.multi().
    
    Specified by:
    
    discard in interface RedisTxCommands
    
    See Also:
    
    Redis Documentation: DISCARD
  - watch
```
public void watch(byte[]... keys)
```
    Description copied from interface: RedisTxCommands
    
    Watch given keys for modifications during transaction started with RedisTxCommands.multi().
    
    Specified by:
    
    watch in interface RedisTxCommands
    
    Parameters:
    
    keys - must not be null.
    
    See Also:
    
    Redis Documentation: WATCH
  - unwatch
```
public void unwatch()
```
    Description copied from interface: RedisTxCommands
    
    Flushes all the previously #watch(byte[]...) keys.
    
    Specified by:
    
    unwatch in interface RedisTxCommands
    
    See Also:
    
    Redis Documentation: UNWATCH
  - isSubscribed
```
public boolean isSubscribed()
```
    Description copied from interface: RedisPubSubCommands
    
    Indicates whether the current connection is subscribed (to at least one channel) or not.
    
    Specified by:
    
    isSubscribed in interface RedisPubSubCommands
    
    Returns:
    
    true if the connection is subscribed, false otherwise
  - getSubscription
```
public Subscription getSubscription()
```
    Description copied from interface: RedisPubSubCommands
    
    Returns the current subscription for this connection or null if the connection is not subscribed.
    
    Specified by:
    
    getSubscription in interface RedisPubSubCommands
    
    Returns:
    
    the current subscription, null if none is available
  - publish
```
public Long publish(byte[] channel,
                    byte[] message)
```
    Description copied from interface: RedisPubSubCommands
    
    Publishes the given message to the given channel.
    
    Specified by:
    
    publish in interface RedisPubSubCommands
    
    Parameters:
    
    channel - the channel to publish to, must not be null.
    
    message - message to publish
    
    Returns:
    
    the number of clients that received the message
    
    See Also:
    
    Redis Documentation: PUBLISH
  - subscribe
```
public void subscribe(MessageListener listener,
                      byte[]... channels)
```
    Description copied from interface: RedisPubSubCommands
    
    Subscribes the connection to the given channels. Once subscribed, a connection enters listening mode and can only subscribe to other channels or unsubscribe. No other commands are accepted until the connection is unsubscribed.
    Note that this operation is blocking and the current thread starts waiting for new messages immediately.
    
    Specified by:
    
    subscribe in interface RedisPubSubCommands
    
    Parameters:
    
    listener - message listener, must not be null.
    
    channels - channel names, must not be null.
    
    See Also:
    
    Redis Documentation: SUBSCRIBE
  - pSubscribe
```
public void pSubscribe(MessageListener listener,
                       byte[]... patterns)
```
    Description copied from interface: RedisPubSubCommands
    
    Subscribes the connection to all channels matching the given patterns. Once subscribed, a connection enters listening mode and can only subscribe to other channels or unsubscribe. No other commands are accepted until the connection is unsubscribed.
    Note that this operation is blocking and the current thread starts waiting for new messages immediately.
    
    Specified by:
    
    pSubscribe in interface RedisPubSubCommands
    
    Parameters:
    
    listener - message listener, must not be null.
    
    patterns - channel name patterns, must not be null.
    
    See Also:
    
    Redis Documentation: PSUBSCRIBE
  - geoAdd
```
public Long geoAdd(byte[] key,
                   org.springframework.data.geo.Point point,
                   byte[] member)
```
    Description copied from interface: RedisGeoCommands
    
    Add Point with given member name to key.
    
    Specified by:
    
    geoAdd in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    point - must not be null.
    
    member - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    Redis Documentation: GEOADD
  - geoAdd
```
public Long geoAdd(byte[] key,
                   RedisGeoCommands.GeoLocation<byte[]> location)
```
    Description copied from interface: RedisGeoCommands
    
    Add RedisGeoCommands.GeoLocation to key.
    
    Specified by:
    
    geoAdd in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    location - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    Redis Documentation: GEOADD
  - geoAdd
```
public Long geoAdd(byte[] key,
                   Map<byte[],org.springframework.data.geo.Point> memberCoordinateMap)
```
    Description copied from interface: RedisGeoCommands
    
    Add Map of member / Point pairs to key.
    
    Specified by:
    
    geoAdd in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    memberCoordinateMap - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    Redis Documentation: GEOADD
  - geoAdd
```
public Long geoAdd(byte[] key,
                   Iterable<RedisGeoCommands.GeoLocation<byte[]>> locations)
```
    Description copied from interface: RedisGeoCommands
    
    Add RedisGeoCommands.GeoLocations to key
    
    Specified by:
    
    geoAdd in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    locations - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    Redis Documentation: GEOADD
  - geoDist
```
public org.springframework.data.geo.Distance geoDist(byte[] key,
                                                     byte[] member1,
                                                     byte[] member2)
```
    Description copied from interface: RedisGeoCommands
    
    Get the Distance between member1 and member2.
    
    Specified by:
    
    geoDist in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member1 - must not be null.
    
    member2 - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: GEODIST
  - geoDist
```
public org.springframework.data.geo.Distance geoDist(byte[] key,
                                                     byte[] member1,
                                                     byte[] member2,
                                                     org.springframework.data.geo.Metric metric)
```
    Description copied from interface: RedisGeoCommands
    
    Get the Distance between member1 and member2 in the given Metric.
    
    Specified by:
    
    geoDist in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member1 - must not be null.
    
    member2 - must not be null.
    
    metric - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    Redis Documentation: GEODIST
  - geoHash
```
public List<String> geoHash(byte[] key,
                            byte[]... members)
```
    Description copied from interface: RedisGeoCommands
    
    Get Geohash representation of the position for one or more members.
    
    Specified by:
    
    geoHash in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEOHASH
  - geoPos
```
public List<org.springframework.data.geo.Point> geoPos(byte[] key,
                                                       byte[]... members)
```
    Description copied from interface: RedisGeoCommands
    
    Get the Point representation of positions for one or more members.
    
    Specified by:
    
    geoPos in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEOPOS
  - geoRadius
```
public org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key,
                                                                                               org.springframework.data.geo.Circle within)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the boundaries of a given Circle.
    
    Specified by:
    
    geoRadius in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    within - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUS
  - geoRadius
```
public org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key,
                                                                                               org.springframework.data.geo.Circle within,
                                                                                               RedisGeoCommands.GeoRadiusCommandArgs args)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the boundaries of a given Circle applying RedisGeoCommands.GeoRadiusCommandArgs.
    
    Specified by:
    
    geoRadius in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    within - must not be null.
    
    args - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUS
  - geoRadiusByMember
```
public org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                                                       byte[] member,
                                                                                                       double radius)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the circle defined by the members coordinates and given radius.
    
    Specified by:
    
    geoRadiusByMember in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER
  - geoRadiusByMember
```
public org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                                                       byte[] member,
                                                                                                       org.springframework.data.geo.Distance radius)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the circle defined by the members coordinates and given Distance.
    
    Specified by:
    
    geoRadiusByMember in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    radius - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER
  - geoRadiusByMember
```
public org.springframework.data.geo.GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                                                       byte[] member,
                                                                                                       org.springframework.data.geo.Distance radius,
                                                                                                       RedisGeoCommands.GeoRadiusCommandArgs args)
```
    Description copied from interface: RedisGeoCommands
    
    Get the members within the circle defined by the members coordinates, given Distance and RedisGeoCommands.GeoRadiusCommandArgs.
    
    Specified by:
    
    geoRadiusByMember in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    radius - must not be null.
    
    args - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: GEORADIUSBYMEMBER
  - geoRemove
```
public Long geoRemove(byte[] key,
                      byte[]... members)
```
    Description copied from interface: RedisGeoCommands
    
    Remove the members.
    
    Specified by:
    
    geoRemove in interface RedisGeoCommands
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    Number of elements removed.
    
    See Also:
    
    Redis Documentation: ZREM
  - select
```
public void select(int dbIndex)
```
    Description copied from interface: RedisConnectionCommands
    
    Select the DB with given positive dbIndex.
    
    Specified by:
    
    select in interface RedisConnectionCommands
    
    Parameters:
    
    dbIndex - the database index.
    
    See Also:
    
    Redis Documentation: SELECT
  - echo
```
public byte[] echo(byte[] message)
```
    Description copied from interface: RedisConnectionCommands
    
    Returns message via server roundtrip.
    
    Specified by:
    
    echo in interface RedisConnectionCommands
    
    Parameters:
    
    message - the message to echo.
    
    Returns:
    
    See Also:
    
    Redis Documentation: ECHO
  - ping
```
public String ping()
```
    Description copied from interface: RedisConnectionCommands
    
    Test connection.
    
    Specified by:
    
    ping in interface RedisConnectionCommands
    
    Returns:
    
    Server response message - usually PONG.
    
    See Also:
    
    Redis Documentation: PING
  - ping
```
public String ping(RedisClusterNode node)
```
    Specified by:
    
    ping in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisConnectionCommands.ping()
  - bgWriteAof
```
public void bgWriteAof()
```
    Description copied from interface: RedisServerCommands
    
    Start an Append Only File rewrite process on server.
    
    Specified by:
    
    bgWriteAof in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: BGREWRITEAOF
  - bgReWriteAof
```
public void bgReWriteAof(RedisClusterNode node)
```
    Specified by:
    
    bgReWriteAof in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    RedisServerCommands.bgReWriteAof()
  - bgReWriteAof
```
public void bgReWriteAof()
```
    Description copied from interface: RedisServerCommands
    
    Start an Append Only File rewrite process on server.
    
    Specified by:
    
    bgReWriteAof in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: BGREWRITEAOF
  - bgSave
```
public void bgSave()
```
    Description copied from interface: RedisServerCommands
    
    Start background saving of db on server.
    
    Specified by:
    
    bgSave in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: BGSAVE
  - bgSave
```
public void bgSave(RedisClusterNode node)
```
    Specified by:
    
    bgSave in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    RedisServerCommands.bgSave()
  - lastSave
```
public Long lastSave()
```
    Description copied from interface: RedisServerCommands
    
    Get time of last RedisServerCommands.bgSave() operation in seconds.
    
    Specified by:
    
    lastSave in interface RedisServerCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: LASTSAVE
  - lastSave
```
public Long lastSave(RedisClusterNode node)
```
    Specified by:
    
    lastSave in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisServerCommands.lastSave()
  - save
```
public void save()
```
    Description copied from interface: RedisServerCommands
    
    Synchronous save current db snapshot on server.
    
    Specified by:
    
    save in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: SAVE
  - save
```
public void save(RedisClusterNode node)
```
    Specified by:
    
    save in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    RedisServerCommands.save()
  - dbSize
```
public Long dbSize()
```
    Description copied from interface: RedisServerCommands
    
    Get the total number of available keys in currently selected database.
    
    Specified by:
    
    dbSize in interface RedisServerCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: DBSIZE
  - dbSize
```
public Long dbSize(RedisClusterNode node)
```
    Specified by:
    
    dbSize in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisServerCommands.dbSize()
  - flushDb
```
public void flushDb()
```
    Description copied from interface: RedisServerCommands
    
    Delete all keys of the currently selected database.
    
    Specified by:
    
    flushDb in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: FLUSHDB
  - flushDb
```
public void flushDb(RedisClusterNode node)
```
    Specified by:
    
    flushDb in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    RedisServerCommands.flushDb()
  - flushAll
```
public void flushAll()
```
    Description copied from interface: RedisServerCommands
    
    Delete all all keys from all databases.
    
    Specified by:
    
    flushAll in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: FLUSHALL
  - flushAll
```
public void flushAll(RedisClusterNode node)
```
    Specified by:
    
    flushAll in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    RedisServerCommands.flushAll()
  - info
```
public Properties info()
```
    Description copied from interface: RedisServerCommands
    Load default server information like
    - memory
    - cpu utilization
    - replication
    Specified by:
    
    info in interface RedisServerCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: INFO
  - info
```
public Properties info(RedisClusterNode node)
```
    Specified by:
    
    info in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisServerCommands.info()
  - info
```
public Properties info(String section)
```
    Description copied from interface: RedisServerCommands
    
    Load server information for given selection.
    
    Specified by:
    
    info in interface RedisServerCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: INFO
  - info
```
public Properties info(RedisClusterNode node,
                       String section)
```
    Specified by:
    
    info in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisServerCommands.info(String)
  - shutdown
```
public void shutdown()
```
    Description copied from interface: RedisServerCommands
    
    Shutdown server.
    
    Specified by:
    
    shutdown in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: SHUTDOWN
  - shutdown
```
public void shutdown(RedisClusterNode node)
```
    Specified by:
    
    shutdown in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    RedisServerCommands.shutdown()
  - shutdown
```
public void shutdown(RedisServerCommands.ShutdownOption option)
```
    Description copied from interface: RedisServerCommands
    
    Shutdown server.
    
    Specified by:
    
    shutdown in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: SHUTDOWN
  - getConfig
```
public List<String> getConfig(String pattern)
```
    Description copied from interface: RedisServerCommands
    
    Load configuration parameters for given pattern from server.
    
    Specified by:
    
    getConfig in interface RedisServerCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: CONFIG GET
  - getConfig
```
public List<String> getConfig(RedisClusterNode node,
                              String pattern)
```
    Specified by:
    
    getConfig in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisServerCommands.getConfig(String)
  - setConfig
```
public void setConfig(String param,
                      String value)
```
    Description copied from interface: RedisServerCommands
    
    Set server configuration for param to value.
    
    Specified by:
    
    setConfig in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: CONFIG SET
  - setConfig
```
public void setConfig(RedisClusterNode node,
                      String param,
                      String value)
```
    Specified by:
    
    setConfig in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    RedisServerCommands.setConfig(String, String)
  - resetConfigStats
```
public void resetConfigStats()
```
    Description copied from interface: RedisServerCommands
    
    Reset statistic counters on server.
    Counters can be retrieved using RedisServerCommands.info().
    
    Specified by:
    
    resetConfigStats in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: CONFIG RESETSTAT
  - resetConfigStats
```
public void resetConfigStats(RedisClusterNode node)
```
    Specified by:
    
    resetConfigStats in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    RedisServerCommands.resetConfigStats()
  - time
```
public Long time()
```
    Description copied from interface: RedisServerCommands
    
    Request server timestamp using TIME command.
    
    Specified by:
    
    time in interface RedisServerCommands
    
    Returns:
    
    current server time in milliseconds.
    
    See Also:
    
    Redis Documentation: TIME
  - time
```
public Long time(RedisClusterNode node)
```
    Specified by:
    
    time in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisServerCommands.time()
  - killClient
```
public void killClient(String host,
                       int port)
```
    Description copied from interface: RedisServerCommands
    
    Closes a given client connection identified by host:port.
    
    Specified by:
    
    killClient in interface RedisServerCommands
    
    Parameters:
    
    host - of connection to close.
    
    port - of connection to close
    
    See Also:
    
    Redis Documentation: CLIENT KILL
  - setClientName
```
public void setClientName(byte[] name)
```
    Description copied from interface: RedisServerCommands
    
    Assign given name to current connection.
    
    Specified by:
    
    setClientName in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: CLIENT SETNAME
  - getClientName
```
public String getClientName()
```
    Description copied from interface: RedisServerCommands
    
    Returns the name of the current connection.
    
    Specified by:
    
    getClientName in interface RedisServerCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: CLIENT GETNAME
  - getClientList
```
public List<RedisClientInfo> getClientList()
```
    Description copied from interface: RedisServerCommands
    
    Request information and statistics about connected clients.
    
    Specified by:
    
    getClientList in interface RedisServerCommands
    
    Returns:
    
    List of RedisClientInfo objects.
    
    See Also:
    
    Redis Documentation: CLIENT LIST
  - getClientList
```
public List<RedisClientInfo> getClientList(RedisClusterNode node)
```
    Specified by:
    
    getClientList in interface RedisClusterConnection
    
    Parameters:
    
    node - must not be null.
    
    Returns:
    
    See Also:
    
    RedisServerCommands.getClientList()
  - slaveOf
```
public void slaveOf(String host,
                    int port)
```
    Description copied from interface: RedisServerCommands
    
    Change redis replication setting to new master.
    
    Specified by:
    
    slaveOf in interface RedisServerCommands
    
    Parameters:
    
    host - must not be null.
    
    See Also:
    
    Redis Documentation: SLAVEOF
  - slaveOfNoOne
```
public void slaveOfNoOne()
```
    Description copied from interface: RedisServerCommands
    
    Change server into master.
    
    Specified by:
    
    slaveOfNoOne in interface RedisServerCommands
    
    See Also:
    
    Redis Documentation: SLAVEOF
  - scriptFlush
```
public void scriptFlush()
```
    Description copied from interface: RedisScriptingCommands
    
    Flush lua script cache.
    
    Specified by:
    
    scriptFlush in interface RedisScriptingCommands
    
    See Also:
    
    Redis Documentation: SCRIPT FLUSH
  - scriptKill
```
public void scriptKill()
```
    Description copied from interface: RedisScriptingCommands
    
    Kill current lua script execution.
    
    Specified by:
    
    scriptKill in interface RedisScriptingCommands
    
    See Also:
    
    Redis Documentation: SCRIPT KILL
  - scriptLoad
```
public String scriptLoad(byte[] script)
```
    Description copied from interface: RedisScriptingCommands
    
    Load lua script into scripts cache, without executing it.
    Execute the script by calling #evalSha(byte[], ReturnType, int, byte[]...).
    
    Specified by:
    
    scriptLoad in interface RedisScriptingCommands
    
    Parameters:
    
    script - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: SCRIPT LOAD
  - scriptExists
```
public List<Boolean> scriptExists(String... scriptShas)
```
    Description copied from interface: RedisScriptingCommands
    
    Check if given scriptShas exist in script cache.
    
    Specified by:
    
    scriptExists in interface RedisScriptingCommands
    
    Returns:
    
    one entry per given scriptSha in returned list.
    
    See Also:
    
    Redis Documentation: SCRIPT EXISTS
  - eval
```
public <T> T eval(byte[] script,
                  ReturnType returnType,
                  int numKeys,
                  byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given script.
    
    Specified by:
    
    eval in interface RedisScriptingCommands
    
    Parameters:
    
    script - must not be null.
    
    returnType - must not be null.
    
    keysAndArgs - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EVAL
  - evalSha
```
public <T> T evalSha(String scriptSha,
                     ReturnType returnType,
                     int numKeys,
                     byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given scriptSha.
    
    Specified by:
    
    evalSha in interface RedisScriptingCommands
    
    Parameters:
    
    scriptSha - must not be null.
    
    returnType - must not be null.
    
    keysAndArgs - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EVALSHA
  - evalSha
```
public <T> T evalSha(byte[] scriptSha,
                     ReturnType returnType,
                     int numKeys,
                     byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given scriptSha.
    
    Specified by:
    
    evalSha in interface RedisScriptingCommands
    
    Parameters:
    
    scriptSha - must not be null.
    
    returnType - must not be null.
    
    keysAndArgs - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EVALSHA
  - pfAdd
```
public Long pfAdd(byte[] key,
                  byte[]... values)
```
    Description copied from interface: HyperLogLogCommands
    
    Adds given values to the HyperLogLog stored at given key.
    
    Specified by:
    
    pfAdd in interface HyperLogLogCommands
    
    Parameters:
    
    key - must not be null.
    
    values - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PFADD
  - pfCount
```
public Long pfCount(byte[]... keys)
```
    Description copied from interface: HyperLogLogCommands
    
    Return the approximated cardinality of the structures observed by the HyperLogLog at key(s).
    
    Specified by:
    
    pfCount in interface HyperLogLogCommands
    
    Parameters:
    
    keys - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: PFCOUNT
  - pfMerge
```
public void pfMerge(byte[] destinationKey,
                    byte[]... sourceKeys)
```
    Description copied from interface: HyperLogLogCommands
    
    Merge N different HyperLogLogs at sourceKeys into a single destinationKey.
    
    Specified by:
    
    pfMerge in interface HyperLogLogCommands
    
    Parameters:
    
    destinationKey - must not be null.
    
    sourceKeys - must not be null.
    
    See Also:
    
    Redis Documentation: PFMERGE
  - exists
```
public Boolean exists(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Determine if given key exists.
    
    Specified by:
    
    exists in interface RedisKeyCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: EXISTS
  - clusterSetSlot
```
public void clusterSetSlot(RedisClusterNode node,
                           int slot,
                           RedisClusterCommands.AddSlots mode)
```
    Specified by:
    
    clusterSetSlot in interface RedisClusterCommands
    
    Parameters:
    
    node - must not be null.
    
    mode - must not benull.
    
    See Also:
    
    Redis Documentation: CLUSTER SETSLOT
  - clusterGetKeysInSlot
```
public List<byte[]> clusterGetKeysInSlot(int slot,
                                         Integer count)
```
    Description copied from interface: RedisClusterCommands
    
    Get keys served by slot.
    
    Specified by:
    
    clusterGetKeysInSlot in interface RedisClusterCommands
    
    count - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: CLUSTER GETKEYSINSLOT
  - clusterAddSlots
```
public void clusterAddSlots(RedisClusterNode node,
                            int... slots)
```
    Description copied from interface: RedisClusterCommands
    
    Assign slots to given RedisClusterNode.
    
    Specified by:
    
    clusterAddSlots in interface RedisClusterCommands
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    Redis Documentation: CLUSTER ADDSLOTS
  - clusterAddSlots
```
public void clusterAddSlots(RedisClusterNode node,
                            RedisClusterNode.SlotRange range)
```
    Description copied from interface: RedisClusterCommands
    
    Assign RedisClusterNode.SlotRange.getSlotsArray() to given RedisClusterNode.
    
    Specified by:
    
    clusterAddSlots in interface RedisClusterCommands
    
    Parameters:
    
    node - must not be null.
    
    range - must not be null.
    
    See Also:
    
    Redis Documentation: CLUSTER ADDSLOTS
  - clusterCountKeysInSlot
```
public Long clusterCountKeysInSlot(int slot)
```
    Description copied from interface: RedisClusterCommands
    
    Count the number of keys assigned to one slot.
    
    Specified by:
    
    clusterCountKeysInSlot in interface RedisClusterCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: CLUSTER COUNTKEYSINSLOT
  - clusterDeleteSlots
```
public void clusterDeleteSlots(RedisClusterNode node,
                               int... slots)
```
    Description copied from interface: RedisClusterCommands
    
    Remove slots from RedisClusterNode.
    
    Specified by:
    
    clusterDeleteSlots in interface RedisClusterCommands
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    Redis Documentation: CLUSTER DELSLOTS
  - clusterDeleteSlotsInRange
```
public void clusterDeleteSlotsInRange(RedisClusterNode node,
                                      RedisClusterNode.SlotRange range)
```
    Description copied from interface: RedisClusterCommands
    
    Removes RedisClusterNode.SlotRange.getSlotsArray() from given RedisClusterNode.
    
    Specified by:
    
    clusterDeleteSlotsInRange in interface RedisClusterCommands
    
    Parameters:
    
    node - must not be null.
    
    range - must not be null.
    
    See Also:
    
    Redis Documentation: CLUSTER DELSLOTS
  - clusterForget
```
public void clusterForget(RedisClusterNode node)
```
    Description copied from interface: RedisClusterCommands
    
    Remove given node from cluster.
    
    Specified by:
    
    clusterForget in interface RedisClusterCommands
    
    Parameters:
    
    node - must not be null.
    
    See Also:
    
    Redis Documentation: CLUSTER FORGET
  - clusterMeet
```
public void clusterMeet(RedisClusterNode node)
```
    Description copied from interface: RedisClusterCommands
    
    Add given node to cluster.
    
    Specified by:
    
    clusterMeet in interface RedisClusterCommands
    
    Parameters:
    
    node - must contain host and RedisNode.getPort() and must not be null.
    
    See Also:
    
    Redis Documentation: CLUSTER MEET
  - clusterReplicate
```
public void clusterReplicate(RedisClusterNode master,
                             RedisClusterNode slave)
```
    Description copied from interface: RedisClusterCommands
    
    Assign a slave to given master.
    
    Specified by:
    
    clusterReplicate in interface RedisClusterCommands
    
    Parameters:
    
    master - must not be null.
    
    slave - must not be null.
    
    See Also:
    
    Redis Documentation: CLUSTER REPLICATE
  - clusterGetSlotForKey
```
public Integer clusterGetSlotForKey(byte[] key)
```
    Description copied from interface: RedisClusterCommands
    
    Find the slot for a given key.
    
    Specified by:
    
    clusterGetSlotForKey in interface RedisClusterCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    Redis Documentation: CLUSTER KEYSLOT
  - clusterGetNodeForSlot
```
public RedisClusterNode clusterGetNodeForSlot(int slot)
```
    Description copied from interface: RedisClusterCommands
    
    Find the RedisClusterNode serving given slot.
    
    Specified by:
    
    clusterGetNodeForSlot in interface RedisClusterCommands
    
    Returns:
  - clusterGetNodes
```
public Set<RedisClusterNode> clusterGetNodes()
```
    Description copied from interface: RedisClusterCommands
    
    Retrieve cluster node information such as id, host, port and slots.
    
    Specified by:
    
    clusterGetNodes in interface RedisClusterCommands
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: CLUSTER NODES
  - clusterGetSlaves
```
public Set<RedisClusterNode> clusterGetSlaves(RedisClusterNode master)
```
    Description copied from interface: RedisClusterCommands
    
    Retrieve information about connected slaves for given master node.
    
    Specified by:
    
    clusterGetSlaves in interface RedisClusterCommands
    
    Parameters:
    
    master - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: CLUSTER SLAVES
  - clusterGetMasterSlaveMap
```
public Map<RedisClusterNode,Collection<RedisClusterNode>> clusterGetMasterSlaveMap()
```
    Description copied from interface: RedisClusterCommands
    
    Retrieve information about masters and their connected slaves.
    
    Specified by:
    
    clusterGetMasterSlaveMap in interface RedisClusterCommands
    
    Returns:
    
    never null.
    
    See Also:
    
    Redis Documentation: CLUSTER SLAVES
  - clusterGetNodeForKey
```
public RedisClusterNode clusterGetNodeForKey(byte[] key)
```
    Description copied from interface: RedisClusterCommands
    
    Find the RedisClusterNode serving given key.
    
    Specified by:
    
    clusterGetNodeForKey in interface RedisClusterCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - clusterGetClusterInfo
```
public ClusterInfo clusterGetClusterInfo()
```
    Description copied from interface: RedisClusterCommands
    
    Get cluster information.
    
    Specified by:
    
    clusterGetClusterInfo in interface RedisClusterCommands
    
    Returns:
    
    See Also:
    
    Redis Documentation: CLUSTER INFO
  - migrate
```
public void migrate(byte[] key,
                    RedisNode target,
                    int dbIndex,
                    RedisServerCommands.MigrateOption option)
```
    Description copied from interface: RedisServerCommands
    
    Atomically transfer a key from a source Redis instance to a destination Redis instance. On success the key is deleted from the original instance and is guaranteed to exist in the target instance.
    
    Specified by:
    
    migrate in interface RedisServerCommands
    
    Parameters:
    
    key - must not be null.
    
    target - must not be null.
    
    option - can be null. Defaulted to RedisServerCommands.MigrateOption.COPY.
    
    See Also:
    
    Redis Documentation: MIGRATE
  - migrate
```
public void migrate(byte[] key,
                    RedisNode target,
                    int dbIndex,
                    RedisServerCommands.MigrateOption option,
                    long timeout)
```
    Description copied from interface: RedisServerCommands
    
    Atomically transfer a key from a source Redis instance to a destination Redis instance. On success the key is deleted from the original instance and is guaranteed to exist in the target instance.
    
    Specified by:
    
    migrate in interface RedisServerCommands
    
    Parameters:
    
    key - must not be null.
    
    target - must not be null.
    
    option - can be null. Defaulted to RedisServerCommands.MigrateOption.COPY.
    
    See Also:
    
    Redis Documentation: MIGRATE
  - convertJedisAccessException
```
protected org.springframework.dao.DataAccessException convertJedisAccessException(Exception ex)
```
  - close
```
public void close()
           throws org.springframework.dao.DataAccessException
```
    Description copied from interface: RedisConnection
    
    Closes (or quits) the connection.
    
    Specified by:
    
    close in interface RedisConnection
    
    Throws:
    
    org.springframework.dao.DataAccessException
  - isClosed
```
public boolean isClosed()
```
    Description copied from interface: RedisConnection
    
    Indicates whether the underlying connection is closed or not.
    
    Specified by:
    
    isClosed in interface RedisConnection
    
    Returns:
    
    true if the connection is closed, false otherwise.
  - getNativeConnection
```
public redis.clients.jedis.JedisCluster getNativeConnection()
```
    Description copied from interface: RedisConnection
    
    Returns the native connection (the underlying library/driver object).
    
    Specified by:
    
    getNativeConnection in interface RedisConnection
    
    Returns:
    
    underlying, native object
  - isQueueing
```
public boolean isQueueing()
```
    Description copied from interface: RedisConnection
    
    Indicates whether the connection is in "queue"(or "MULTI") mode or not. When queueing, all commands are postponed until EXEC or DISCARD commands are issued. Since in queueing no results are returned, the connection will return NULL on all operations that interact with the data.
    
    Specified by:
    
    isQueueing in interface RedisConnection
    
    Returns:
    
    true if the connection is in queue/MULTI mode, false otherwise
  - isPipelined
```
public boolean isPipelined()
```
    Description copied from interface: RedisConnection
    
    Indicates whether the connection is currently pipelined or not.
    
    Specified by:
    
    isPipelined in interface RedisConnection
    
    Returns:
    
    true if the connection is pipelined, false otherwise
    
    See Also:
    
    RedisConnection.openPipeline(), RedisConnection.isQueueing()
  - openPipeline
```
public void openPipeline()
```
    Description copied from interface: RedisConnection
    
    Activates the pipeline mode for this connection. When pipelined, all commands return null (the reply is read at the end through RedisConnection.closePipeline(). Calling this method when the connection is already pipelined has no effect. Pipelining is used for issuing commands without requesting the response right away but rather at the end of the batch. While somewhat similar to MULTI, pipelining does not guarantee atomicity - it only tries to improve performance when issuing a lot of commands (such as in batching scenarios).
    Note:
    Consider doing some performance testing before using this feature since in many cases the performance benefits are minimal yet the impact on usage are not.
    
    Specified by:
    
    openPipeline in interface RedisConnection
    
    See Also:
    
    RedisTxCommands.multi()
  - closePipeline
```
public List<Object> closePipeline()
                           throws RedisPipelineException
```
    Description copied from interface: RedisConnection
    
    Executes the commands in the pipeline and returns their result. If the connection is not pipelined, an empty collection is returned.
    
    Specified by:
    
    closePipeline in interface RedisConnection
    
    Returns:
    
    the result of the executed commands.
    
    Throws:
    
    RedisPipelineException - if the pipeline contains any incorrect/invalid statements
  - getSentinelConnection
```
public RedisSentinelConnection getSentinelConnection()
```
    Specified by:
    
    getSentinelConnection in interface RedisConnection
    
    Returns:

Class JedisClusterConnection

Nested Class Summary

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStringCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisListCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisZSetCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisServerCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisGeoCommands

Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisClusterCommands

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

JedisClusterConnection

JedisClusterConnection

Method Detail

execute

del

type

keys

keys

scan

randomKey

randomKey

rename

renameNX

expire

pExpire

expireAt

pExpireAt

persist

move

ttl

ttl

pTtl

pTtl

sort

sort

dump

restore

get

getSet

mGet

set

set

setNX

setEx

pSetEx

mSet

mSetNX

incr

incrBy

incrBy

decr

decrBy

append

getRange

setRange

getBit

setBit

bitCount

bitCount

bitOp

strLen

rPush

lPush

rPushX

lPushX

lLen

lRange

lTrim

lIndex

lInsert

lSet

lRem

lPop

rPop

bLPop

bRPop

rPopLPush

bRPopLPush