DefaultStringRedisConnection (Spring Data Redis 2.0.0.M1 API)

java.lang.Object
- org.springframework.data.redis.connection.DefaultStringRedisConnection

All Implemented Interfaces:

DecoratedRedisConnection, HyperLogLogCommands, RedisCommands, RedisConnection, RedisConnectionCommands, RedisGeoCommands, RedisHashCommands, RedisKeyCommands, RedisListCommands, RedisPubSubCommands, RedisScriptingCommands, RedisServerCommands, RedisSetCommands, RedisStringCommands, RedisTxCommands, RedisZSetCommands, StringRedisConnection
```
public class DefaultStringRedisConnection
extends Object
implements StringRedisConnection, DecoratedRedisConnection
```
Default implementation of StringRedisConnection.

Author:

Costin Leau, Jennifer Hickey, Christoph Strobl, Thomas Darimont, Mark Paluch, Ninad Divadkar

Nested Class Summary
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.StringRedisConnection
  StringRedisConnection.StringTuple
- 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

Constructor Summary

Constructors
Constructor and Description
`DefaultStringRedisConnection(RedisConnection connection)` Constructs a new `DefaultStringRedisConnection` instance.
`DefaultStringRedisConnection(RedisConnection connection, RedisSerializer<String> serializer)` Constructs a new `DefaultStringRedisConnection` instance.

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Long`	`append(byte[] key, byte[] value)` Append a `value` to `key`.
`Long`	`append(String key, String value)` Append a `value` to `key`.
`void`	`bgReWriteAof()` Start an Append Only File rewrite process on server.
`void`	`bgSave()` Start background saving of db on server.
`void`	`bgWriteAof()` Deprecated. As of 1.3, use `bgReWriteAof()`.
`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`	`bitCount(String key)` Count the number of set bits (population counting) in value stored at `key`.
`Long`	`bitCount(String 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.
`Long`	`bitOp(RedisStringCommands.BitOperation op, String destination, String... keys)` Perform bitwise operations between strings.
`List<byte[]>`	`bLPop(int timeout, byte[]... keys)` Removes and returns first element from lists stored at `keys` (see: `RedisListCommands.lPop(byte[])`).
`List<String>`	`bLPop(int timeout, String... keys)`
`List<byte[]>`	`bRPop(int timeout, byte[]... keys)` Removes and returns last element from lists stored at `keys` (see: `RedisListCommands.rPop(byte[])`).
`List<String>`	`bRPop(int timeout, String... 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 (see `RedisListCommands.rPopLPush(byte[], byte[])`).
`String`	`bRPopLPush(int timeout, String srcKey, String dstKey)`
`void`	`close()` Closes (or quits) the connection.
`List<Object>`	`closePipeline()` Executes the commands in the pipeline and returns their result.
`Long`	`dbSize()` Get the total number of available keys in currently selected database.
`Long`	`decr(byte[] key)` Decrement value of `key` by 1.
`Long`	`decr(String key)` Decrement value of `key` by 1.
`Long`	`decrBy(byte[] key, long value)` Increment value of `key` by `value`.
`Long`	`decrBy(String key, long value)` Increment value of `key` by `value`.
`Long`	`del(byte[]... keys)` Delete given `keys`.
`Long`	`del(String... 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.
`String`	`echo(String message)`
`<T> T`	`eval(byte[] script, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `script`.
`<T> T`	`eval(String script, ReturnType returnType, int numKeys, String... keysAndArgs)` NOTE: This method will not deserialize Strings returned by Lua scripts, as they may not be encoded with the same serializer used here.
`<T> T`	`evalSha(byte[] scriptSha1, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `scriptSha`.
`<T> T`	`evalSha(String scriptSha1, ReturnType returnType, int numKeys, byte[]... keysAndArgs)` Evaluate given `scriptSha`.
`<T> T`	`evalSha(String scriptSha1, ReturnType returnType, int numKeys, String... keysAndArgs)` NOTE: This method will not deserialize Strings returned by Lua scripts, as they may not be encoded with the same serializer used here.
`List<Object>`	`exec()` Executes all queued commands in a transaction started with `RedisTxCommands.multi()`.
`Object`	`execute(String command)`
`Object`	`execute(String command, byte[]... args)` 'Native' or 'raw' execution of the given command along-side the given arguments.
`Object`	`execute(String command, String... args)`
`Boolean`	`exists(byte[] key)` Determine if given `key` exists.
`Boolean`	`exists(String key)` Determine if given `key` exists.
`Boolean`	`expire(byte[] key, long seconds)` Set time to live for given `key` in seconds.
`Boolean`	`expire(String 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.
`Boolean`	`expireAt(String key, long unixTime)` Set the expiration for given `key` as a UNIX timestamp.
`void`	`flushAll()` Delete all all keys from all databases.
`void`	`flushDb()` Delete all keys of the currently selected database.
`Long`	`geoAdd(byte[] key, Iterable<RedisGeoCommands.GeoLocation<byte[]>> locations)` Add `RedisGeoCommands.GeoLocation`s to key
`Long`	`geoAdd(byte[] key, Map<byte[],Point> memberCoordinateMap)` Add `Map` of member / `Point` pairs to key.
`Long`	`geoAdd(byte[] key, 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.
`Long`	`geoAdd(String key, Iterable<RedisGeoCommands.GeoLocation<String>> locations)` Add `GeoLocation`s to key
`Long`	`geoAdd(String key, Map<String,Point> memberCoordinateMap)` Add `Map` of member / `Point` pairs to key.
`Long`	`geoAdd(String key, Point point, String member)` Add `Point` with given member name to key.
`Long`	`geoAdd(String key, RedisGeoCommands.GeoLocation<String> location)` Add `GeoLocation` to key.
`Distance`	`geoDist(byte[] key, byte[] member1, byte[] member2)` Get the `Distance` between member1 and member2.
`Distance`	`geoDist(byte[] key, byte[] member1, byte[] member2, Metric metric)` Get the `Distance` between member1 and member2 in the given `Metric`.
`Distance`	`geoDist(String key, String member1, String member2)` Get the `Distance` between member1 and member2.
`Distance`	`geoDist(String key, String member1, String member2, 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<String>`	`geoHash(String key, String... members)` Get geohash representation of the position for one or more members.
`List<Point>`	`geoPos(byte[] key, byte[]... members)` Get the `Point` representation of positions for one or more members.
`List<Point>`	`geoPos(String key, String... members)` Get the `Point` representation of positions for one or more members.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadius(byte[] key, Circle within)` Get the members within the boundaries of a given `Circle`.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadius(byte[] key, Circle within, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the boundaries of a given `Circle` applying `RedisGeoCommands.GeoRadiusCommandArgs`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadius(String key, Circle within)` Get the members within the boundaries of a given `Circle`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadius(String key, Circle within, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the boundaries of a given `Circle` applying `GeoRadiusCommandArgs`.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, Distance radius)` Get the members within the circle defined by the members coordinates and given `Distance`.
`GeoResults<RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, Distance radius, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the circle defined by the members coordinates, given `Distance` and `RedisGeoCommands.GeoRadiusCommandArgs`.
`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.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadiusByMember(String key, String member, Distance radius)` Get the members within the circle defined by the members coordinates and given `Distance`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadiusByMember(String key, String member, Distance radius, RedisGeoCommands.GeoRadiusCommandArgs args)` Get the members within the circle defined by the members coordinates and given `Distance` and `GeoRadiusCommandArgs`.
`GeoResults<RedisGeoCommands.GeoLocation<String>>`	`geoRadiusByMember(String key, String 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.
`Long`	`geoRemove(String key, String... members)` Remove the members.
`byte[]`	`get(byte[] key)` Get the value of `key`.
`String`	`get(String key)` Get the value of `key`.
`Boolean`	`getBit(byte[] key, long offset)` Get the bit value at `offset` of value at `key`.
`Boolean`	`getBit(String key, long offset)` Get the bit value at `offset` of value at `key`.
`List<RedisClientInfo>`	`getClientList()` Request information and statistics about connected clients.
`String`	`getClientName()` Returns the name of the current connection.
`List<String>`	`getConfig(String pattern)` Load configuration parameters for given `pattern` from server.
`RedisConnection`	`getDelegate()` Gets the underlying `RedisConnection`.
`Object`	`getNativeConnection()` Returns the native connection (the underlying library/driver object).
`byte[]`	`getRange(byte[] key, long start, long end)` Get a substring of value of `key` between `begin` and `end`.
`String`	`getRange(String key, long start, 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.
`String`	`getSet(String key, String 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`.
`Long`	`hDel(String key, String... fields)`
`Boolean`	`hExists(byte[] key, byte[] field)` Determine if given hash `field` exists.
`Boolean`	`hExists(String key, String field)`
`byte[]`	`hGet(byte[] key, byte[] field)` Get value for given `field` from hash at `key`.
`String`	`hGet(String key, String field)`
`Map<byte[],byte[]>`	`hGetAll(byte[] key)` Get entire hash stored at `key`.
`Map<String,String>`	`hGetAll(String 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`.
`Double`	`hIncrBy(String key, String field, double delta)`
`Long`	`hIncrBy(String key, String field, long delta)`
`Set<byte[]>`	`hKeys(byte[] key)` Get key set (fields) of hash at `key`.
`Set<String>`	`hKeys(String key)`
`Long`	`hLen(byte[] key)` Get size of hash at `key`.
`Long`	`hLen(String key)`
`List<byte[]>`	`hMGet(byte[] key, byte[]... fields)` Get values for given `fields` from hash at `key`.
`List<String>`	`hMGet(String key, String... fields)`
`void`	`hMSet(byte[] key, Map<byte[],byte[]> hashes)` Set multiple hash fields to multiple values using data provided in `hashes`
`void`	`hMSet(String key, Map<String,String> hashes)`
`Cursor<Map.Entry<byte[],byte[]>>`	`hScan(byte[] key, ScanOptions options)` Use a `Cursor` to iterate over entries in hash at `key`.
`Cursor<Map.Entry<String,String>>`	`hScan(String key, ScanOptions options)`
`Boolean`	`hSet(byte[] key, byte[] field, byte[] value)` Set the `value` of a hash `field`.
`Boolean`	`hSet(String key, String field, String value)`
`Boolean`	`hSetNX(byte[] key, byte[] field, byte[] value)` Set the `value` of a hash `field` only if `field` does not exist.
`Boolean`	`hSetNX(String key, String field, String value)`
`List<byte[]>`	`hVals(byte[] key)` Get entry set (values) of hash at `field`.
`List<String>`	`hVals(String key)`
`Long`	`incr(byte[] key)` Increment value of `key` by 1.
`Long`	`incr(String key)` Increment value of `key` by 1.
`Double`	`incrBy(byte[] key, double value)` Increment value of `key` by `value`.
`Long`	`incrBy(byte[] key, long value)` Increment value of `key` by `value`.
`Double`	`incrBy(String key, double value)` Increment value of `key` by `value`.
`Long`	`incrBy(String key, long value)` Increment value of `key` by `value`.
`Properties`	`info()` Load default server information like mempory cpu utilization replication See http://redis.io/commands/info
`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`.
`Collection<String>`	`keys(String pattern)` Find all keys matching the given `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.
`byte[]`	`lIndex(byte[] key, long index)` Get element at `index` form list at `key`.
`String`	`lIndex(String key, long index)`
`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`	`lInsert(String key, RedisListCommands.Position where, String pivot, String value)`
`Long`	`lLen(byte[] key)` Get the size of list stored at `key`.
`Long`	`lLen(String key)`
`byte[]`	`lPop(byte[] key)` Removes and returns first element in list stored at `key`.
`String`	`lPop(String key)`
`Long`	`lPush(byte[] key, byte[]... values)` Prepend `values` to `key`.
`Long`	`lPush(String key, String... values)`
`Long`	`lPushX(byte[] key, byte[] value)` Prepend `values` to `key` only if the list exists.
`Long`	`lPushX(String key, String value)`
`List<byte[]>`	`lRange(byte[] key, long start, long end)` Get elements between `begin` and `end` from list at `key`.
`List<String>`	`lRange(String key, long start, long end)`
`Long`	`lRem(byte[] key, long count, byte[] value)` Removes the first `count` occurrences of `value` from the list stored at `key`.
`Long`	`lRem(String key, long count, String value)`
`void`	`lSet(byte[] key, long index, byte[] value)` Set the `value` list element at `index`.
`void`	`lSet(String key, long index, String value)`
`void`	`lTrim(byte[] key, long start, long end)` Trim list at `key` to elements between `begin` and `end`.
`void`	`lTrim(String key, long start, long end)`
`List<byte[]>`	`mGet(byte[]... keys)` Get the values of all given `keys`.
`List<String>`	`mGet(String... keys)` Get the values of all given `keys`.
`void`	`migrate(byte[] key, RedisNode target, int dbIndex, RedisServerCommands.MigrateOption option)`
`void`	`migrate(byte[] key, RedisNode target, int dbIndex, RedisServerCommands.MigrateOption option, long timeout)`
`Boolean`	`move(byte[] key, int dbIndex)` Move given `key` to database with `index`.
`Boolean`	`move(String key, int dbIndex)` Move given `key` to database with `index`.
`void`	`mSet(Map<byte[],byte[]> tuple)` Set multiple keys to multiple values using key-value pairs provided in `tuple`.
`Boolean`	`mSetNX(Map<byte[],byte[]> tuple)` Set multiple keys to multiple values using key-value pairs provided in `tuple` only if the provided key does not exist.
`Boolean`	`mSetNXString(Map<String,String> tuple)` Set multiple keys to multiple values using key-value pairs provided in `tuple` only if the provided key does not exist.
`void`	`mSetString(Map<String,String> tuple)` Set multiple keys to multiple values using key-value pairs provided in `tuple`.
`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`	`persist(String key)` Remove the expiration from given `key`.
`Boolean`	`pExpire(byte[] key, long millis)` Set time to live for given `key` in milliseconds.
`Boolean`	`pExpire(String 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.
`Boolean`	`pExpireAt(String 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`	`pfAdd(String key, String... 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).
`Long`	`pfCount(String... keys)`
`void`	`pfMerge(byte[] destinationKey, byte[]... sourceKeys)` Merge N different HyperLogLogs at sourceKeys into a single destinationKey.
`void`	`pfMerge(String destinationKey, String... sourceKeys)`
`String`	`ping()` Test connection.
`void`	`pSetEx(byte[] key, long milliseconds, byte[] value)` Set the `value` and expiration in `milliseconds` for `key`.
`void`	`pSetEx(String key, long seconds, String 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.
`void`	`pSubscribe(MessageListener listener, String... 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`	`pTtl(String key)` Get the precise time to live for `key` in milliseconds.
`Long`	`pTtl(String 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.
`Long`	`publish(String channel, String message)`
`byte[]`	`randomKey()` Return a random key from the keyspace.
`void`	`rename(byte[] oldName, byte[] newName)` Rename key `oleName` to `newName`.
`void`	`rename(String oldName, String newName)` Rename key `oleName` to `newName`.
`Boolean`	`renameNX(byte[] oldName, byte[] newName)` Rename key `oleName` to `newName` only if `newName` does not exist.
`Boolean`	`renameNX(String oldName, String newName)` Rename key `oleName` to `newName` only if `newName` does not exist.
`void`	`resetConfigStats()` Reset statistic counters on server.
`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`.
`String`	`rPop(String key)`
`byte[]`	`rPopLPush(byte[] srcKey, byte[] dstKey)` Remove the last element from list at `srcKey`, append it to `dstKey` and return its value.
`String`	`rPopLPush(String srcKey, String dstKey)`
`Long`	`rPush(byte[] key, byte[]... values)` Append `values` to `key`.
`Long`	`rPush(String key, String... values)`
`Long`	`rPushX(byte[] key, byte[] value)` Append values to `key` only if the list exists.
`Long`	`rPushX(String key, String value)`
`Long`	`sAdd(byte[] key, byte[]... values)` Add given `values` to set at `key`.
`Long`	`sAdd(String key, String... values)`
`void`	`save()` Synchronous save current db snapshot on server.
`Cursor<byte[]>`	`scan(ScanOptions options)` Use a `Cursor` to iterate over keys.
`Long`	`sCard(byte[] key)` Get size of set at `key`.
`Long`	`sCard(String key)`
`List<Boolean>`	`scriptExists(String... scriptSha1)` 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.
`String`	`scriptLoad(String script)`
`Set<byte[]>`	`sDiff(byte[]... keys)` Diff all sets for given `keys`.
`Set<String>`	`sDiff(String... keys)`
`Long`	`sDiffStore(byte[] destKey, byte[]... keys)` Diff all sets for given `keys` and store result in `destKey` See http://redis.io/commands/sdiffstore
`Long`	`sDiffStore(String destKey, String... keys)`
`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`.
`void`	`set(String key, String value)` Set `value` for `key`.
`void`	`set(String key, String 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`.
`Boolean`	`setBit(String 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`	`setClientName(String name)` Assign given `name` to connection using registered `RedisSerializer` for name conversion.
`void`	`setConfig(String param, String value)` Set server configuration for `param` to `value`.
`void`	`setDeserializePipelineAndTxResults(boolean deserializePipelineAndTxResults)` Specifies if pipelined and tx results should be deserialized to Strings.
`void`	`setEx(byte[] key, long seconds, byte[] value)` Set the `value` and expiration in `seconds` for `key`.
`void`	`setEx(String key, long seconds, String 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.
`Boolean`	`setNX(String key, String value)` Set `value` for `key`, only if `key` does not exist.
`void`	`setRange(byte[] key, byte[] value, long start)` Overwrite parts of `key` starting at the specified `offset` with given `value`.
`void`	`setRange(String key, String value, long start)` Overwrite parts of `key` starting at the specified `offset` with given `value`.
`void`	`shutdown()` Shutdown server.
`void`	`shutdown(RedisServerCommands.ShutdownOption option)` Shutdown server.
`Set<byte[]>`	`sInter(byte[]... keys)` Returns the members intersecting all given sets at `keys`.
`Set<String>`	`sInter(String... keys)`
`Long`	`sInterStore(byte[] destKey, byte[]... keys)` Intersect all given sets at `keys` and store result in `destKey`.
`Long`	`sInterStore(String destKey, String... keys)`
`Boolean`	`sIsMember(byte[] key, byte[] value)` Check if set at `key` contains `value`.
`Boolean`	`sIsMember(String key, String 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`.
`Set<String>`	`sMembers(String key)`
`Boolean`	`sMove(byte[] srcKey, byte[] destKey, byte[] value)` Move `value` from `srcKey` to `destKey` See http://redis.io/commands/smove
`Boolean`	`sMove(String srcKey, String destKey, String value)`
`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`.
`List<String>`	`sort(String key, SortParameters params)`
`Long`	`sort(String key, SortParameters params, String storeKey)`
`byte[]`	`sPop(byte[] key)` Remove and return a random member from set at `key`.
`String`	`sPop(String 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`.
`String`	`sRandMember(String key)`
`List<String>`	`sRandMember(String key, long count)`
`Long`	`sRem(byte[] key, byte[]... values)` Remove given `values` from set at `key` and return the number of removed elements.
`Long`	`sRem(String key, String... values)`
`Cursor<byte[]>`	`sScan(byte[] key, ScanOptions options)` Use a `Cursor` to iterate over elements in set at `key`.
`Cursor<String>`	`sScan(String key, ScanOptions options)`
`Long`	`strLen(byte[] key)` Get the length of the value stored at `key`.
`Long`	`strLen(String key)` Get the length of the value stored at `key`.
`void`	`subscribe(MessageListener listener, byte[]... channels)` Subscribes the connection to the given channels.
`void`	`subscribe(MessageListener listener, String... channels)`
`Set<byte[]>`	`sUnion(byte[]... keys)` Union all sets at given `keys`.
`Set<String>`	`sUnion(String... keys)`
`Long`	`sUnionStore(byte[] destKey, byte[]... keys)` Union all sets at given `keys` and store result in `destKey`.
`Long`	`sUnionStore(String destKey, String... keys)`
`Long`	`time()` Request server timestamp using `TIME` command.
`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`.
`Long`	`ttl(String key)` Get the time to live for `key` in seconds.
`Long`	`ttl(String 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`.
`DataType`	`type(String 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.
`Boolean`	`zAdd(String key, double score, String value)`
`Long`	`zAdd(String key, Set<StringRedisConnection.StringTuple> tuples)`
`Long`	`zCard(byte[] key)` Get the size of sorted set with `key`.
`Long`	`zCard(String 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`.
`Long`	`zCount(String key, double min, double max)`
`Double`	`zIncrBy(byte[] key, double increment, byte[] value)` Increment the score of element with `value` in sorted set by `increment`.
`Double`	`zIncrBy(String key, double increment, String value)`
`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`.
`Long`	`zInterStore(String destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, String... sets)`
`Long`	`zInterStore(String destKey, String... sets)`
`Set<byte[]>`	`zRange(byte[] key, long start, long end)` Get elements between `begin` and `end` from sorted set.
`Set<String>`	`zRange(String key, long start, long end)`
`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<String>`	`zRangeByLex(String key)` Get all elements in the sorted set at key in lexicographical ordering.
`Set<String>`	`zRangeByLex(String key, RedisZSetCommands.Range range)` Get the elements in `Range` from the sorted set at key in lexicographical ordering
`Set<String>`	`zRangeByLex(String key, RedisZSetCommands.Range range, RedisZSetCommands.Limit limit)` Get the elements in `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 `begin` 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 `begin` to `end` where score is between `min` and `max` from sorted set.
`Set<String>`	`zRangeByScore(String key, double min, double max)`
`Set<String>`	`zRangeByScore(String key, double min, double max, long offset, long count)`
`Set<byte[]>`	`zRangeByScore(String key, String min, String max)`
`Set<byte[]>`	`zRangeByScore(String key, String min, String max, long offset, long count)`
`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 `begin` 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<StringRedisConnection.StringTuple>`	`zRangeByScoreWithScores(String key, double min, double max)`
`Set<StringRedisConnection.StringTuple>`	`zRangeByScoreWithScores(String key, double min, double max, long offset, long count)`
`Set<RedisZSetCommands.Tuple>`	`zRangeWithScores(byte[] key, long start, long end)` Get set of `RedisZSetCommands.Tuple`s between `begin` and `end` from sorted set.
`Set<StringRedisConnection.StringTuple>`	`zRangeWithScores(String key, long start, long end)`
`Long`	`zRank(byte[] key, byte[] value)` Determine the index of element with `value` in a sorted set.
`Long`	`zRank(String key, String value)`
`Long`	`zRem(byte[] key, byte[]... values)` Remove `values` from sorted set.
`Long`	`zRem(String key, String... values)`
`Long`	`zRemRange(byte[] key, long start, long end)` Remove elements in range between `begin` and `end` from sorted set with `key`.
`Long`	`zRemRange(String key, long start, long end)`
`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`.
`Long`	`zRemRangeByScore(String key, double min, double max)`
`Set<byte[]>`	`zRevRange(byte[] key, long start, long end)` Get elements in range from `begin` to `end` from sorted set ordered from high to low.
`Set<String>`	`zRevRange(String key, long start, long end)`
`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 `begin` 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<String>`	`zRevRangeByScore(String key, double min, double max)`
`Set<String>`	`zRevRangeByScore(String key, double min, double max, long offset, long count)`
`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 `begin` 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<StringRedisConnection.StringTuple>`	`zRevRangeByScoreWithScores(String key, double min, double max)`
`Set<StringRedisConnection.StringTuple>`	`zRevRangeByScoreWithScores(String key, double min, double max, long offset, long count)`
`Set<RedisZSetCommands.Tuple>`	`zRevRangeWithScores(byte[] key, long start, long end)` Get set of `RedisZSetCommands.Tuple`s in range from `begin` to `end` from sorted set ordered from high to low.
`Set<StringRedisConnection.StringTuple>`	`zRevRangeWithScores(String key, long start, long end)`
`Long`	`zRevRank(byte[] key, byte[] value)` Determine the index of element with `value` in a sorted set when scored high to low.
`Long`	`zRevRank(String key, String value)`
`Cursor<RedisZSetCommands.Tuple>`	`zScan(byte[] key, ScanOptions options)` Use a `Cursor` to iterate over elements in sorted set at `key`.
`Cursor<StringRedisConnection.StringTuple>`	`zScan(String key, ScanOptions options)`
`Double`	`zScore(byte[] key, byte[] value)` Get the score of element with `value` from sorted set with key `key`.
`Double`	`zScore(String key, String value)`
`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`.
`Long`	`zUnionStore(String destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, String... sets)`
`Long`	`zUnionStore(String destKey, String... sets)`

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

- Constructor Detail
  - DefaultStringRedisConnection
```
public DefaultStringRedisConnection(RedisConnection connection)
```
    Constructs a new DefaultStringRedisConnection instance. Uses StringRedisSerializer as underlying serializer.
    
    Parameters:
    
    connection - Redis connection
  - DefaultStringRedisConnection
```
public DefaultStringRedisConnection(RedisConnection connection,
                                    RedisSerializer<String> serializer)
```
    Constructs a new DefaultStringRedisConnection instance.
    
    Parameters:
    
    connection - Redis connection
    
    serializer - String serializer
- Method Detail
  - append
```
public Long append(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Append a value to key.
    See http://redis.io/commands/append
    
    Specified by:
    
    append in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - bgSave
```
public void bgSave()
```
    Description copied from interface: RedisServerCommands
    
    Start background saving of db on server.
    See http://redis.io/commands/bgsave
    
    Specified by:
    
    bgSave in interface RedisServerCommands
  - bgReWriteAof
```
public void bgReWriteAof()
```
    Description copied from interface: RedisServerCommands
    
    Start an Append Only File rewrite process on server.
    See http://redis.io/commands/bgrewriteaof
    
    Specified by:
    
    bgReWriteAof in interface RedisServerCommands
  - bgWriteAof
```
@Deprecated
public void bgWriteAof()
```
    Deprecated. As of 1.3, use bgReWriteAof().
    
    Description copied from interface: RedisServerCommands
    
    Start an Append Only File rewrite process on server.
    See http://redis.io/commands/bgrewriteaof
    
    Specified by:
    
    bgWriteAof in interface RedisServerCommands
  - bLPop
```
public List<byte[]> bLPop(int timeout,
                          byte[]... keys)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns first element from lists stored at keys (see: RedisListCommands.lPop(byte[])).
    Blocks connection until element available or timeout reached.
    See http://redis.io/commands/blpop
    
    Specified by:
    
    bLPop in interface RedisListCommands
    
    Returns:
  - bRPop
```
public List<byte[]> bRPop(int timeout,
                          byte[]... keys)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns last element from lists stored at keys (see: RedisListCommands.rPop(byte[])).
    Blocks connection until element available or timeout reached.
    See http://redis.io/commands/brpop
    
    Specified by:
    
    bRPop in interface RedisListCommands
    
    Returns:
  - 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 (see RedisListCommands.rPopLPush(byte[], byte[])).
    Blocks connection until element available or timeout reached.
    See http://redis.io/commands/brpoplpush
    
    Specified by:
    
    bRPopLPush in interface RedisListCommands
    
    Returns:
  - close
```
public void close()
           throws RedisSystemException
```
    Description copied from interface: RedisConnection
    
    Closes (or quits) the connection.
    
    Specified by:
    
    close in interface RedisConnection
    
    Throws:
    
    RedisSystemException
  - dbSize
```
public Long dbSize()
```
    Description copied from interface: RedisServerCommands
    
    Get the total number of available keys in currently selected database.
    See http://redis.io/commands/dbsize
    
    Specified by:
    
    dbSize in interface RedisServerCommands
    
    Returns:
  - decr
```
public Long decr(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Decrement value of key by 1.
    See http://redis.io/commands/decr
    
    Specified by:
    
    decr in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - decrBy
```
public Long decrBy(byte[] key,
                   long value)
```
    Description copied from interface: RedisStringCommands
    
    Increment value of key by value.
    See http://redis.io/commands/decrby
    
    Specified by:
    
    decrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - del
```
public Long del(byte[]... keys)
```
    Description copied from interface: RedisKeyCommands
    
    Delete given keys.
    See http://redis.io/commands/del
    
    Specified by:
    
    del in interface RedisKeyCommands
    
    Returns:
    
    The number of keys that were removed.
  - discard
```
public void discard()
```
    Description copied from interface: RedisTxCommands
    
    Discard all commands issued after RedisTxCommands.multi().
    See http://redis.io/commands/discard
    
    Specified by:
    
    discard in interface RedisTxCommands
  - echo
```
public byte[] echo(byte[] message)
```
    Description copied from interface: RedisConnectionCommands
    
    Returns message via server roundtrip.
    See http://redis.io/commands/echo
    
    Specified by:
    
    echo in interface RedisConnectionCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/exec
    
    Specified by:
    
    exec in interface RedisTxCommands
    
    Returns:
    
    List of replies for each executed command.
  - exists
```
public Boolean exists(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Determine if given key exists.
    See http://redis.io/commands/exists
    
    Specified by:
    
    exists in interface RedisKeyCommands
    
    Returns:
  - expire
```
public Boolean expire(byte[] key,
                      long seconds)
```
    Description copied from interface: RedisKeyCommands
    
    Set time to live for given key in seconds.
    See http://redis.io/commands/expire
    
    Specified by:
    
    expire in interface RedisKeyCommands
    
    Returns:
  - expireAt
```
public Boolean expireAt(byte[] key,
                        long unixTime)
```
    Description copied from interface: RedisKeyCommands
    
    Set the expiration for given key as a UNIX timestamp.
    See http://redis.io/commands/expireat
    
    Specified by:
    
    expireAt in interface RedisKeyCommands
    
    Returns:
  - flushAll
```
public void flushAll()
```
    Description copied from interface: RedisServerCommands
    
    Delete all all keys from all databases.
    See http://redis.io/commands/flushall
    
    Specified by:
    
    flushAll in interface RedisServerCommands
  - flushDb
```
public void flushDb()
```
    Description copied from interface: RedisServerCommands
    
    Delete all keys of the currently selected database.
    See http://redis.io/commands/flushdb
    
    Specified by:
    
    flushDb in interface RedisServerCommands
  - get
```
public byte[] get(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Get the value of key.
    See http://redis.io/commands/get
    
    Specified by:
    
    get in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - getBit
```
public Boolean getBit(byte[] key,
                      long offset)
```
    Description copied from interface: RedisStringCommands
    
    Get the bit value at offset of value at key.
    See http://redis.io/commands/getbit
    
    Specified by:
    
    getBit in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - getConfig
```
public List<String> getConfig(String pattern)
```
    Description copied from interface: RedisServerCommands
    
    Load configuration parameters for given pattern from server.
    See http://redis.io/commands/config-get
    
    Specified by:
    
    getConfig in interface RedisServerCommands
    
    Returns:
  - getNativeConnection
```
public Object 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
  - getRange
```
public byte[] getRange(byte[] key,
                       long start,
                       long end)
```
    Description copied from interface: RedisStringCommands
    
    Get a substring of value of key between begin and end.
    See http://redis.io/commands/getrange
    
    Specified by:
    
    getRange in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - getSet
```
public byte[] getSet(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value of key and return its old value.
    See http://redis.io/commands/getset
    
    Specified by:
    
    getSet in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - 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
  - hDel
```
public Long hDel(byte[] key,
                 byte[]... fields)
```
    Description copied from interface: RedisHashCommands
    
    Delete given hash fields.
    
    Specified by:
    
    hDel in interface RedisHashCommands
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/hdel
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/hexits
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/hget
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/hgetall
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/hincrbyfloat
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/h?
  - hLen
```
public Long hLen(byte[] key)
```
    Description copied from interface: RedisHashCommands
    
    Get size of hash at key.
    
    Specified by:
    
    hLen in interface RedisHashCommands
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/hlen
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/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
    
    See Also:
    
    http://redis.io/commands/hmset
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/hsetnx
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/hvals
  - incr
```
public Long incr(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Increment value of key by 1.
    See http://redis.io/commands/incr
    
    Specified by:
    
    incr in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - incrBy
```
public Long incrBy(byte[] key,
                   long value)
```
    Description copied from interface: RedisStringCommands
    
    Increment value of key by value.
    See http://redis.io/commands/incrby
    
    Specified by:
    
    incrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - incrBy
```
public Double incrBy(byte[] key,
                     double value)
```
    Description copied from interface: RedisStringCommands
    
    Increment value of key by value.
    See http://redis.io/commands/incrbyfloat
    
    Specified by:
    
    incrBy in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - info
```
public Properties info()
```
    Description copied from interface: RedisServerCommands
    Load default server information like
    - mempory
    - cpu utilization
    - replication
    See http://redis.io/commands/info
    Specified by:
    
    info in interface RedisServerCommands
    
    Returns:
  - info
```
public Properties info(String section)
```
    Description copied from interface: RedisServerCommands
    
    Load server information for given selection.
    See http://redis.io/commands/info
    
    Specified by:
    
    info in interface RedisServerCommands
    
    Returns:
  - 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.
  - 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
  - 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
  - keys
```
public Set<byte[]> keys(byte[] pattern)
```
    Description copied from interface: RedisKeyCommands
    
    Find all keys matching the given pattern.
    See http://redis.io/commands/keys
    
    Specified by:
    
    keys in interface RedisKeyCommands
    
    Returns:
  - lastSave
```
public Long lastSave()
```
    Description copied from interface: RedisServerCommands
    
    Get time of last RedisServerCommands.bgSave() operation in seconds.
    See http://redis.io/commands/lastsave
    
    Specified by:
    
    lastSave in interface RedisServerCommands
    
    Returns:
  - lIndex
```
public byte[] lIndex(byte[] key,
                     long index)
```
    Description copied from interface: RedisListCommands
    
    Get element at index form list at key.
    See http://redis.io/commands/lindex
    
    Specified by:
    
    lIndex in interface RedisListCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/linsert
    
    Specified by:
    
    lInsert in interface RedisListCommands
    
    Returns:
  - lLen
```
public Long lLen(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Get the size of list stored at key.
    See http://redis.io/commands/llen
    
    Specified by:
    
    lLen in interface RedisListCommands
    
    Returns:
  - lPop
```
public byte[] lPop(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns first element in list stored at key.
    See http://redis.io/commands/lpop
    
    Specified by:
    
    lPop in interface RedisListCommands
    
    Returns:
  - lPush
```
public Long lPush(byte[] key,
                  byte[]... values)
```
    Description copied from interface: RedisListCommands
    
    Prepend values to key.
    See http://redis.io/commands/lpush
    
    Specified by:
    
    lPush in interface RedisListCommands
    
    Returns:
  - lPushX
```
public Long lPushX(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Prepend values to key only if the list exists.
    See http://redis.io/commands/lpushx
    
    Specified by:
    
    lPushX in interface RedisListCommands
    
    Returns:
  - lRange
```
public List<byte[]> lRange(byte[] key,
                           long start,
                           long end)
```
    Description copied from interface: RedisListCommands
    
    Get elements between begin and end from list at key.
    See http://redis.io/commands/lrange
    
    Specified by:
    
    lRange in interface RedisListCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/lrem
    
    Specified by:
    
    lRem in interface RedisListCommands
    
    Returns:
  - lSet
```
public void lSet(byte[] key,
                 long index,
                 byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Set the value list element at index.
    See http://redis.io/commands/lset
    
    Specified by:
    
    lSet in interface RedisListCommands
  - lTrim
```
public void lTrim(byte[] key,
                  long start,
                  long end)
```
    Description copied from interface: RedisListCommands
    
    Trim list at key to elements between begin and end.
    See http://redis.io/commands/ltrim
    
    Specified by:
    
    lTrim in interface RedisListCommands
  - mGet
```
public List<byte[]> mGet(byte[]... keys)
```
    Description copied from interface: RedisStringCommands
    
    Get the values of all given keys.
    See http://redis.io/commands/mget
    
    Specified by:
    
    mGet in interface RedisStringCommands
    
    Returns:
  - mSet
```
public void mSet(Map<byte[],byte[]> tuple)
```
    Description copied from interface: RedisStringCommands
    
    Set multiple keys to multiple values using key-value pairs provided in tuple.
    See http://redis.io/commands/mset
    
    Specified by:
    
    mSet in interface RedisStringCommands
  - mSetNX
```
public Boolean mSetNX(Map<byte[],byte[]> tuple)
```
    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.
    See http://redis.io/commands/msetnx
    
    Specified by:
    
    mSetNX in interface RedisStringCommands
  - 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()
    See http://redis.io/commands/multi
    
    Specified by:
    
    multi in interface RedisTxCommands
  - persist
```
public Boolean persist(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Remove the expiration from given key.
    See http://redis.io/commands/persist
    
    Specified by:
    
    persist in interface RedisKeyCommands
    
    Returns:
  - move
```
public Boolean move(byte[] key,
                    int dbIndex)
```
    Description copied from interface: RedisKeyCommands
    
    Move given key to database with index.
    See http://redis.io/commands/move
    
    Specified by:
    
    move in interface RedisKeyCommands
    
    Returns:
  - ping
```
public String ping()
```
    Description copied from interface: RedisConnectionCommands
    
    Test connection.
    See http://redis.io/commands/ping
    
    Specified by:
    
    ping in interface RedisConnectionCommands
    
    Returns:
    
    Server response message - usually PONG.
  - 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
    
    patterns - channel name patterns
  - 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
    
    message - message to publish
    
    Returns:
    
    the number of clients that received the message
  - randomKey
```
public byte[] randomKey()
```
    Description copied from interface: RedisKeyCommands
    
    Return a random key from the keyspace.
    See http://redis.io/commands/randomkey
    
    Specified by:
    
    randomKey in interface RedisKeyCommands
    
    Returns:
  - rename
```
public void rename(byte[] oldName,
                   byte[] newName)
```
    Description copied from interface: RedisKeyCommands
    
    Rename key oleName to newName.
    See http://redis.io/commands/rename
    
    Specified by:
    
    rename in interface RedisKeyCommands
  - renameNX
```
public Boolean renameNX(byte[] oldName,
                        byte[] newName)
```
    Description copied from interface: RedisKeyCommands
    
    Rename key oleName to newName only if newName does not exist.
    See http://redis.io/commands/renamenx
    
    Specified by:
    
    renameNX in interface RedisKeyCommands
    
    Returns:
  - resetConfigStats
```
public void resetConfigStats()
```
    Description copied from interface: RedisServerCommands
    
    Reset statistic counters on server.
    Counters can be retrieved using RedisServerCommands.info().
    See http://redis.io/commands/config-resetstat
    
    Specified by:
    
    resetConfigStats in interface RedisServerCommands
  - rPop
```
public byte[] rPop(byte[] key)
```
    Description copied from interface: RedisListCommands
    
    Removes and returns last element in list stored at key.
    See http://redis.io/commands/rpop
    
    Specified by:
    
    rPop in interface RedisListCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/rpoplpush
    
    Specified by:
    
    rPopLPush in interface RedisListCommands
    
    Returns:
  - rPush
```
public Long rPush(byte[] key,
                  byte[]... values)
```
    Description copied from interface: RedisListCommands
    
    Append values to key.
    See http://redis.io/commands/rpush
    
    Specified by:
    
    rPush in interface RedisListCommands
    
    Returns:
  - rPushX
```
public Long rPushX(byte[] key,
                   byte[] value)
```
    Description copied from interface: RedisListCommands
    
    Append values to key only if the list exists.
    See http://redis.io/commands/rpushx
    
    Specified by:
    
    rPushX in interface RedisListCommands
    
    Returns:
  - sAdd
```
public Long sAdd(byte[] key,
                 byte[]... values)
```
    Description copied from interface: RedisSetCommands
    
    Add given values to set at key.
    See http://redis.io/commands/sadd
    
    Specified by:
    
    sAdd in interface RedisSetCommands
    
    Returns:
  - save
```
public void save()
```
    Description copied from interface: RedisServerCommands
    
    Synchronous save current db snapshot on server.
    See http://redis.io/commands/save
    
    Specified by:
    
    save in interface RedisServerCommands
  - sCard
```
public Long sCard(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get size of set at key.
    See http://redis.io/commands/scard
    
    Specified by:
    
    sCard in interface RedisSetCommands
    
    Returns:
  - sDiff
```
public Set<byte[]> sDiff(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Diff all sets for given keys.
    See http://redis.io/commands/sdiff
    
    Specified by:
    
    sDiff in interface RedisSetCommands
    
    Returns:
  - sDiffStore
```
public Long sDiffStore(byte[] destKey,
                       byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Diff all sets for given keys and store result in destKey
    See http://redis.io/commands/sdiffstore
    
    Specified by:
    
    sDiffStore in interface RedisSetCommands
    
    Returns:
  - select
```
public void select(int dbIndex)
```
    Description copied from interface: RedisConnectionCommands
    
    Select the DB with given positive dbIndex.
    See http://redis.io/commands/select
    
    Specified by:
    
    select in interface RedisConnectionCommands
  - set
```
public void set(byte[] key,
                byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value for key.
    See http://redis.io/commands/set
    
    Specified by:
    
    set in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
  - 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.
    See http://redis.io/commands/set
    
    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.
  - 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.
    See http://redis.io/commands/setbit
    
    Specified by:
    
    setBit in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    the original bit value stored at offset.
  - setConfig
```
public void setConfig(String param,
                      String value)
```
    Description copied from interface: RedisServerCommands
    
    Set server configuration for param to value.
    See http://redis.io/commands/config-set
    
    Specified by:
    
    setConfig in interface RedisServerCommands
  - setEx
```
public void setEx(byte[] key,
                  long seconds,
                  byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set the value and expiration in seconds for key.
    See http://redis.io/commands/setex
    
    Specified by:
    
    setEx in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
  - pSetEx
```
public void pSetEx(byte[] key,
                   long milliseconds,
                   byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set the value and expiration in milliseconds for key.
    See http://redis.io/commands/psetex
    
    Specified by:
    
    pSetEx in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
  - setNX
```
public Boolean setNX(byte[] key,
                     byte[] value)
```
    Description copied from interface: RedisStringCommands
    
    Set value for key, only if key does not exist.
    See http://redis.io/commands/setnx
    
    Specified by:
    
    setNX in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
  - setRange
```
public void setRange(byte[] key,
                     byte[] value,
                     long start)
```
    Description copied from interface: RedisStringCommands
    
    Overwrite parts of key starting at the specified offset with given value.
    See http://redis.io/commands/setrange
    
    Specified by:
    
    setRange in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
  - shutdown
```
public void shutdown()
```
    Description copied from interface: RedisServerCommands
    
    Shutdown server.
    See http://redis.io/commands/shutdown
    
    Specified by:
    
    shutdown in interface RedisServerCommands
  - shutdown
```
public void shutdown(RedisServerCommands.ShutdownOption option)
```
    Description copied from interface: RedisServerCommands
    
    Shutdown server.
    See http://redis.io/commands/shutdown
    
    Specified by:
    
    shutdown in interface RedisServerCommands
  - sInter
```
public Set<byte[]> sInter(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Returns the members intersecting all given sets at keys.
    See http://redis.io/commands/sinter
    
    Specified by:
    
    sInter in interface RedisSetCommands
    
    Returns:
  - sInterStore
```
public Long sInterStore(byte[] destKey,
                        byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Intersect all given sets at keys and store result in destKey.
    See http://redis.io/commands/sinterstore
    
    Specified by:
    
    sInterStore in interface RedisSetCommands
    
    Returns:
  - sIsMember
```
public Boolean sIsMember(byte[] key,
                         byte[] value)
```
    Description copied from interface: RedisSetCommands
    
    Check if set at key contains value.
    See http://redis.io/commands/sismember
    
    Specified by:
    
    sIsMember in interface RedisSetCommands
    
    Returns:
  - sMembers
```
public Set<byte[]> sMembers(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get all elements of set at key.
    See http://redis.io/commands/smembers
    
    Specified by:
    
    sMembers in interface RedisSetCommands
    
    Returns:
  - sMove
```
public Boolean sMove(byte[] srcKey,
                     byte[] destKey,
                     byte[] value)
```
    Description copied from interface: RedisSetCommands
    
    Move value from srcKey to destKey
    See http://redis.io/commands/smove
    
    Specified by:
    
    sMove in interface RedisSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/sort
    
    Specified by:
    
    sort in interface RedisKeyCommands
    
    Returns:
  - sort
```
public List<byte[]> sort(byte[] key,
                         SortParameters params)
```
    Description copied from interface: RedisKeyCommands
    
    Sort the elements for key.
    See http://redis.io/commands/sort
    
    Specified by:
    
    sort in interface RedisKeyCommands
    
    Returns:
  - sPop
```
public byte[] sPop(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Remove and return a random member from set at key.
    See http://redis.io/commands/spop
    
    Specified by:
    
    sPop in interface RedisSetCommands
    
    Returns:
  - sRandMember
```
public byte[] sRandMember(byte[] key)
```
    Description copied from interface: RedisSetCommands
    
    Get random element from set at key.
    See http://redis.io/commands/srandmember
    
    Specified by:
    
    sRandMember in interface RedisSetCommands
    
    Returns:
  - sRandMember
```
public List<byte[]> sRandMember(byte[] key,
                                long count)
```
    Description copied from interface: RedisSetCommands
    
    Get count random elements from set at key.
    See http://redis.io/commands/srandmember
    
    Specified by:
    
    sRandMember in interface RedisSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/srem
    
    Specified by:
    
    sRem in interface RedisSetCommands
    
    Returns:
  - strLen
```
public Long strLen(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Get the length of the value stored at key.
    See http://redis.io/commands/strlen
    
    Specified by:
    
    strLen in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - bitCount
```
public Long bitCount(byte[] key)
```
    Description copied from interface: RedisStringCommands
    
    Count the number of set bits (population counting) in value stored at key.
    See http://redis.io/commands/bitcount
    
    Specified by:
    
    bitCount in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - 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.
    See http://redis.io/commands/bitcount
    
    Specified by:
    
    bitCount in interface RedisStringCommands
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - bitOp
```
public Long bitOp(RedisStringCommands.BitOperation op,
                  byte[] destination,
                  byte[]... keys)
```
    Description copied from interface: RedisStringCommands
    
    Perform bitwise operations between strings.
    See http://redis.io/commands/bitop
    
    Specified by:
    
    bitOp in interface RedisStringCommands
    
    Returns:
  - 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
    
    channels - channel names
  - sUnion
```
public Set<byte[]> sUnion(byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Union all sets at given keys.
    See http://redis.io/commands/sunion
    
    Specified by:
    
    sUnion in interface RedisSetCommands
    
    Returns:
  - sUnionStore
```
public Long sUnionStore(byte[] destKey,
                        byte[]... keys)
```
    Description copied from interface: RedisSetCommands
    
    Union all sets at given keys and store result in destKey.
    See http://redis.io/commands/sunionstore
    
    Specified by:
    
    sUnionStore in interface RedisSetCommands
    
    Returns:
  - ttl
```
public Long ttl(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the time to live for key in seconds.
    See http://redis.io/commands/ttl
    
    Specified by:
    
    ttl in interface RedisKeyCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/ttl
    
    Specified by:
    
    ttl in interface RedisKeyCommands
    
    Returns:
  - type
```
public DataType type(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Determine the type stored at key.
    See http://redis.io/commands/type
    
    Specified by:
    
    type in interface RedisKeyCommands
    
    Returns:
  - unwatch
```
public void unwatch()
```
    Description copied from interface: RedisTxCommands
    
    Flushes all the previously #watch(byte[]) keys.
    See http://redis.io/commands/unwatch
    
    Specified by:
    
    unwatch in interface RedisTxCommands
  - watch
```
public void watch(byte[]... keys)
```
    Description copied from interface: RedisTxCommands
    
    Watch given keys for modifications during transaction started with RedisTxCommands.multi().
    See http://redis.io/commands/watch
    
    Specified by:
    
    watch in interface RedisTxCommands
  - 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.
    See http://redis.io/commands/zadd
    
    Specified by:
    
    zAdd in interface RedisZSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/zadd
    
    Specified by:
    
    zAdd in interface RedisZSetCommands
    
    Returns:
  - zCard
```
public Long zCard(byte[] key)
```
    Description copied from interface: RedisZSetCommands
    
    Get the size of sorted set with key.
    See http://redis.io/commands/zcard
    
    Specified by:
    
    zCard in interface RedisZSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/zcount
    
    Specified by:
    
    zCount in interface RedisZSetCommands
    
    Returns:
  - 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
    
    Returns:
  - 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.
    See http://redis.io/commands/zincrby
    
    Specified by:
    
    zIncrBy in interface RedisZSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/zinterstore
    
    Specified by:
    
    zInterStore in interface RedisZSetCommands
    
    Returns:
  - zInterStore
```
public Long zInterStore(byte[] destKey,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Intersect sorted sets and store result in destination key.
    See http://redis.io/commands/zinterstore
    
    Specified by:
    
    zInterStore in interface RedisZSetCommands
    
    Returns:
  - zRange
```
public Set<byte[]> zRange(byte[] key,
                          long start,
                          long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements between begin and end from sorted set.
    See http://redis.io/commands/zrange
    
    Specified by:
    
    zRange in interface RedisZSetCommands
    
    Returns:
  - 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 begin to end where score is between min and max from sorted set.
    See http://redis.io/commands/zrangebyscore
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Returns:
  - 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
    
    Returns:
  - 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
    
    Returns:
  - 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
    
    Returns:
  - 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.
    See http://redis.io/commands/zrangebyscore
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Returns:
  - 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 begin to end where score is between min and max from sorted set.
    See http://redis.io/commands/zrangebyscore
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    Returns:
  - 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
    
    Returns:
  - 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.
    See http://redis.io/commands/zrangebyscore
    
    Specified by:
    
    zRangeByScoreWithScores in interface RedisZSetCommands
    
    Returns:
  - zRangeWithScores
```
public Set<RedisZSetCommands.Tuple> zRangeWithScores(byte[] key,
                                                     long start,
                                                     long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples between begin and end from sorted set.
    See http://redis.io/commands/zrange
    
    Specified by:
    
    zRangeWithScores in interface RedisZSetCommands
    
    Returns:
  - 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 begin to end where score is between min and max from sorted set ordered high -> low.
    See http://redis.io/commands/zrevrangebyscore
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Returns:
  - 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
    
    Returns:
  - 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.
    See http://redis.io/commands/zrevrange
    
    Specified by:
    
    zRevRangeByScore in interface RedisZSetCommands
    
    Returns:
  - 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
    
    Returns:
  - 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 begin to end where score is between min and max from sorted set ordered high -> low.
    See http://redis.io/commands/zrevrangebyscore
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Returns:
  - 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
    
    Returns:
  - 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
    
    Returns:
  - 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.
    See http://redis.io/commands/zrevrange
    
    Specified by:
    
    zRevRangeByScoreWithScores in interface RedisZSetCommands
    
    Returns:
  - zRank
```
public Long zRank(byte[] key,
                  byte[] value)
```
    Description copied from interface: RedisZSetCommands
    
    Determine the index of element with value in a sorted set.
    See http://redis.io/commands/zrank
    
    Specified by:
    
    zRank in interface RedisZSetCommands
    
    Returns:
  - zRem
```
public Long zRem(byte[] key,
                 byte[]... values)
```
    Description copied from interface: RedisZSetCommands
    
    Remove values from sorted set. Return number of removed elements.
    See http://redis.io/commands/zrem
    
    Specified by:
    
    zRem in interface RedisZSetCommands
    
    Returns:
  - zRemRange
```
public Long zRemRange(byte[] key,
                      long start,
                      long end)
```
    Description copied from interface: RedisZSetCommands
    
    Remove elements in range between begin and end from sorted set with key.
    See http://redis.io/commands/zremrange
    
    Specified by:
    
    zRemRange in interface RedisZSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/zremrangebyscore
    
    Specified by:
    
    zRemRangeByScore in interface RedisZSetCommands
    
    Returns:
  - 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
    
    Returns:
  - zRevRange
```
public Set<byte[]> zRevRange(byte[] key,
                             long start,
                             long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get elements in range from begin to end from sorted set ordered from high to low.
    See http://redis.io/commands/zrevrange
    
    Specified by:
    
    zRevRange in interface RedisZSetCommands
    
    Returns:
  - zRevRangeWithScores
```
public Set<RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key,
                                                        long start,
                                                        long end)
```
    Description copied from interface: RedisZSetCommands
    
    Get set of RedisZSetCommands.Tuples in range from begin to end from sorted set ordered from high to low.
    See http://redis.io/commands/zrevrange
    
    Specified by:
    
    zRevRangeWithScores in interface RedisZSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/zrevrank
    
    Specified by:
    
    zRevRank in interface RedisZSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/zrem
    
    Specified by:
    
    zScore in interface RedisZSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/zunionstore
    
    Specified by:
    
    zUnionStore in interface RedisZSetCommands
    
    Returns:
  - zUnionStore
```
public Long zUnionStore(byte[] destKey,
                        byte[]... sets)
```
    Description copied from interface: RedisZSetCommands
    
    Union sorted sets and store result in destination key.
    See http://redis.io/commands/zunionstore
    
    Specified by:
    
    zUnionStore in interface RedisZSetCommands
    
    Returns:
  - pExpire
```
public Boolean pExpire(byte[] key,
                       long millis)
```
    Description copied from interface: RedisKeyCommands
    
    Set time to live for given key in milliseconds.
    See http://redis.io/commands/pexpire
    
    Specified by:
    
    pExpire in interface RedisKeyCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/pexpireat
    
    Specified by:
    
    pExpireAt in interface RedisKeyCommands
    
    Returns:
  - pTtl
```
public Long pTtl(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Get the precise time to live for key in milliseconds.
    See http://redis.io/commands/pttl
    
    Specified by:
    
    pTtl in interface RedisKeyCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/pttl
    
    Specified by:
    
    pTtl in interface RedisKeyCommands
    
    Returns:
  - dump
```
public byte[] dump(byte[] key)
```
    Description copied from interface: RedisKeyCommands
    
    Retrieve serialized version of the value stored at key.
    See http://redis.io/commands/dump
    
    Specified by:
    
    dump in interface RedisKeyCommands
    
    Returns:
  - 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[]).
    See http://redis.io/commands/restore
    
    Specified by:
    
    restore in interface RedisKeyCommands
  - scriptFlush
```
public void scriptFlush()
```
    Description copied from interface: RedisScriptingCommands
    
    Flush lua script cache.
    See http://redis.io/commands/script-flush
    
    Specified by:
    
    scriptFlush in interface RedisScriptingCommands
  - scriptKill
```
public void scriptKill()
```
    Description copied from interface: RedisScriptingCommands
    
    Kill current lua script execution.
    See http://redis.io/commands/script-kill
    
    Specified by:
    
    scriptKill in interface RedisScriptingCommands
  - 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(String, ReturnType, int, byte[]).
    See http://redis.io/commands/script-load
    
    Specified by:
    
    scriptLoad in interface RedisScriptingCommands
    
    Returns:
  - scriptExists
```
public List<Boolean> scriptExists(String... scriptSha1)
```
    Description copied from interface: RedisScriptingCommands
    
    Check if given scriptShas exist in script cache.
    See http://redis.io/commands/script-exits
    
    Specified by:
    
    scriptExists in interface RedisScriptingCommands
    
    Returns:
    
    one entry per given scriptSha in returned list.
  - eval
```
public <T> T eval(byte[] script,
                  ReturnType returnType,
                  int numKeys,
                  byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given script.
    See http://redis.io/commands/eval
    
    Specified by:
    
    eval in interface RedisScriptingCommands
    
    Returns:
  - evalSha
```
public <T> T evalSha(String scriptSha1,
                     ReturnType returnType,
                     int numKeys,
                     byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given scriptSha.
    See http://redis.io/commands/evalsha
    
    Specified by:
    
    evalSha in interface RedisScriptingCommands
    
    Returns:
  - evalSha
```
public <T> T evalSha(byte[] scriptSha1,
                     ReturnType returnType,
                     int numKeys,
                     byte[]... keysAndArgs)
```
    Description copied from interface: RedisScriptingCommands
    
    Evaluate given scriptSha.
    See http://redis.io/commands/evalsha
    
    Specified by:
    
    evalSha in interface RedisScriptingCommands
    
    Returns:
  - append
```
public Long append(String key,
                   String value)
```
    Description copied from interface: StringRedisConnection
    
    Append a value to key.
    See http://redis.io/commands/append
    
    Specified by:
    
    append in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - bLPop
```
public List<String> bLPop(int timeout,
                          String... keys)
```
    Specified by:
    
    bLPop in interface StringRedisConnection
  - bRPop
```
public List<String> bRPop(int timeout,
                          String... keys)
```
    Specified by:
    
    bRPop in interface StringRedisConnection
  - bRPopLPush
```
public String bRPopLPush(int timeout,
                         String srcKey,
                         String dstKey)
```
    Specified by:
    
    bRPopLPush in interface StringRedisConnection
  - decr
```
public Long decr(String key)
```
    Description copied from interface: StringRedisConnection
    
    Decrement value of key by 1.
    See http://redis.io/commands/decr
    
    Specified by:
    
    decr in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - decrBy
```
public Long decrBy(String key,
                   long value)
```
    Description copied from interface: StringRedisConnection
    
    Increment value of key by value.
    See http://redis.io/commands/decrby
    
    Specified by:
    
    decrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - del
```
public Long del(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Delete given keys.
    See http://redis.io/commands/del
    
    Specified by:
    
    del in interface StringRedisConnection
    
    Returns:
    
    The number of keys that were removed.
  - echo
```
public String echo(String message)
```
    Specified by:
    
    echo in interface StringRedisConnection
  - exists
```
public Boolean exists(String key)
```
    Description copied from interface: StringRedisConnection
    
    Determine if given key exists.
    See http://redis.io/commands/exists
    
    Specified by:
    
    exists in interface StringRedisConnection
    
    Returns:
  - expire
```
public Boolean expire(String key,
                      long seconds)
```
    Description copied from interface: StringRedisConnection
    
    Set time to live for given key in seconds.
    See http://redis.io/commands/expire
    
    Specified by:
    
    expire in interface StringRedisConnection
    
    Returns:
  - expireAt
```
public Boolean expireAt(String key,
                        long unixTime)
```
    Description copied from interface: StringRedisConnection
    
    Set the expiration for given key as a UNIX timestamp.
    See http://redis.io/commands/expireat
    
    Specified by:
    
    expireAt in interface StringRedisConnection
    
    Returns:
  - get
```
public String get(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the value of key.
    See http://redis.io/commands/get
    
    Specified by:
    
    get in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - getBit
```
public Boolean getBit(String key,
                      long offset)
```
    Description copied from interface: StringRedisConnection
    
    Get the bit value at offset of value at key.
    See http://redis.io/commands/getbit
    
    Specified by:
    
    getBit in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - getRange
```
public String getRange(String key,
                       long start,
                       long end)
```
    Description copied from interface: StringRedisConnection
    
    Get a substring of value of key between begin and end.
    See http://redis.io/commands/getrange
    
    Specified by:
    
    getRange in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - getSet
```
public String getSet(String key,
                     String value)
```
    Description copied from interface: StringRedisConnection
    
    Set value of key and return its old value.
    See http://redis.io/commands/getset
    
    Specified by:
    
    getSet in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - hDel
```
public Long hDel(String key,
                 String... fields)
```
    Specified by:
    
    hDel in interface StringRedisConnection
  - hExists
```
public Boolean hExists(String key,
                       String field)
```
    Specified by:
    
    hExists in interface StringRedisConnection
  - hGet
```
public String hGet(String key,
                   String field)
```
    Specified by:
    
    hGet in interface StringRedisConnection
  - hGetAll
```
public Map<String,String> hGetAll(String key)
```
    Specified by:
    
    hGetAll in interface StringRedisConnection
  - hIncrBy
```
public Long hIncrBy(String key,
                    String field,
                    long delta)
```
    Specified by:
    
    hIncrBy in interface StringRedisConnection
  - hIncrBy
```
public Double hIncrBy(String key,
                      String field,
                      double delta)
```
    Specified by:
    
    hIncrBy in interface StringRedisConnection
  - hKeys
```
public Set<String> hKeys(String key)
```
    Specified by:
    
    hKeys in interface StringRedisConnection
  - hLen
```
public Long hLen(String key)
```
    Specified by:
    
    hLen in interface StringRedisConnection
  - hMGet
```
public List<String> hMGet(String key,
                          String... fields)
```
    Specified by:
    
    hMGet in interface StringRedisConnection
  - hMSet
```
public void hMSet(String key,
                  Map<String,String> hashes)
```
    Specified by:
    
    hMSet in interface StringRedisConnection
  - hSet
```
public Boolean hSet(String key,
                    String field,
                    String value)
```
    Specified by:
    
    hSet in interface StringRedisConnection
  - hSetNX
```
public Boolean hSetNX(String key,
                      String field,
                      String value)
```
    Specified by:
    
    hSetNX in interface StringRedisConnection
  - hVals
```
public List<String> hVals(String key)
```
    Specified by:
    
    hVals in interface StringRedisConnection
  - incr
```
public Long incr(String key)
```
    Description copied from interface: StringRedisConnection
    
    Increment value of key by 1.
    See http://redis.io/commands/incr
    
    Specified by:
    
    incr in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - incrBy
```
public Long incrBy(String key,
                   long value)
```
    Description copied from interface: StringRedisConnection
    
    Increment value of key by value.
    See http://redis.io/commands/incrby
    
    Specified by:
    
    incrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - incrBy
```
public Double incrBy(String key,
                     double value)
```
    Description copied from interface: StringRedisConnection
    
    Increment value of key by value.
    See http://redis.io/commands/incrbyfloat
    
    Specified by:
    
    incrBy in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - keys
```
public Collection<String> keys(String pattern)
```
    Description copied from interface: StringRedisConnection
    
    Find all keys matching the given pattern.
    See http://redis.io/commands/keys
    
    Specified by:
    
    keys in interface StringRedisConnection
    
    Returns:
  - lIndex
```
public String lIndex(String key,
                     long index)
```
    Specified by:
    
    lIndex in interface StringRedisConnection
  - lInsert
```
public Long lInsert(String key,
                    RedisListCommands.Position where,
                    String pivot,
                    String value)
```
    Specified by:
    
    lInsert in interface StringRedisConnection
  - lLen
```
public Long lLen(String key)
```
    Specified by:
    
    lLen in interface StringRedisConnection
  - lPop
```
public String lPop(String key)
```
    Specified by:
    
    lPop in interface StringRedisConnection
  - lPush
```
public Long lPush(String key,
                  String... values)
```
    Specified by:
    
    lPush in interface StringRedisConnection
  - lPushX
```
public Long lPushX(String key,
                   String value)
```
    Specified by:
    
    lPushX in interface StringRedisConnection
  - lRange
```
public List<String> lRange(String key,
                           long start,
                           long end)
```
    Specified by:
    
    lRange in interface StringRedisConnection
  - lRem
```
public Long lRem(String key,
                 long count,
                 String value)
```
    Specified by:
    
    lRem in interface StringRedisConnection
  - lSet
```
public void lSet(String key,
                 long index,
                 String value)
```
    Specified by:
    
    lSet in interface StringRedisConnection
  - lTrim
```
public void lTrim(String key,
                  long start,
                  long end)
```
    Specified by:
    
    lTrim in interface StringRedisConnection
  - mGet
```
public List<String> mGet(String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Get the values of all given keys.
    See http://redis.io/commands/mget
    
    Specified by:
    
    mGet in interface StringRedisConnection
    
    Returns:
  - mSetNXString
```
public Boolean mSetNXString(Map<String,String> tuple)
```
    Description copied from interface: StringRedisConnection
    
    Set multiple keys to multiple values using key-value pairs provided in tuple only if the provided key does not exist.
    See http://redis.io/commands/msetnx
    
    Specified by:
    
    mSetNXString in interface StringRedisConnection
  - mSetString
```
public void mSetString(Map<String,String> tuple)
```
    Description copied from interface: StringRedisConnection
    
    Set multiple keys to multiple values using key-value pairs provided in tuple.
    See http://redis.io/commands/mset
    
    Specified by:
    
    mSetString in interface StringRedisConnection
  - persist
```
public Boolean persist(String key)
```
    Description copied from interface: StringRedisConnection
    
    Remove the expiration from given key.
    See http://redis.io/commands/persist
    
    Specified by:
    
    persist in interface StringRedisConnection
    
    Returns:
  - move
```
public Boolean move(String key,
                    int dbIndex)
```
    Description copied from interface: StringRedisConnection
    
    Move given key to database with index.
    See http://redis.io/commands/move
    
    Specified by:
    
    move in interface StringRedisConnection
    
    Returns:
  - pSubscribe
```
public void pSubscribe(MessageListener listener,
                       String... patterns)
```
    Specified by:
    
    pSubscribe in interface StringRedisConnection
  - publish
```
public Long publish(String channel,
                    String message)
```
    Specified by:
    
    publish in interface StringRedisConnection
  - rename
```
public void rename(String oldName,
                   String newName)
```
    Description copied from interface: StringRedisConnection
    
    Rename key oleName to newName.
    See http://redis.io/commands/rename
    
    Specified by:
    
    rename in interface StringRedisConnection
  - renameNX
```
public Boolean renameNX(String oldName,
                        String newName)
```
    Description copied from interface: StringRedisConnection
    
    Rename key oleName to newName only if newName does not exist.
    See http://redis.io/commands/renamenx
    
    Specified by:
    
    renameNX in interface StringRedisConnection
    
    Returns:
  - rPop
```
public String rPop(String key)
```
    Specified by:
    
    rPop in interface StringRedisConnection
  - rPopLPush
```
public String rPopLPush(String srcKey,
                        String dstKey)
```
    Specified by:
    
    rPopLPush in interface StringRedisConnection
  - rPush
```
public Long rPush(String key,
                  String... values)
```
    Specified by:
    
    rPush in interface StringRedisConnection
  - rPushX
```
public Long rPushX(String key,
                   String value)
```
    Specified by:
    
    rPushX in interface StringRedisConnection
  - sAdd
```
public Long sAdd(String key,
                 String... values)
```
    Specified by:
    
    sAdd in interface StringRedisConnection
  - sCard
```
public Long sCard(String key)
```
    Specified by:
    
    sCard in interface StringRedisConnection
  - sDiff
```
public Set<String> sDiff(String... keys)
```
    Specified by:
    
    sDiff in interface StringRedisConnection
  - sDiffStore
```
public Long sDiffStore(String destKey,
                       String... keys)
```
    Specified by:
    
    sDiffStore in interface StringRedisConnection
  - set
```
public void set(String key,
                String value)
```
    Description copied from interface: StringRedisConnection
    
    Set value for key.
    See http://redis.io/commands/set
    
    Specified by:
    
    set in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
  - set
```
public void set(String key,
                String value,
                Expiration expiration,
                RedisStringCommands.SetOption option)
```
    Description copied from interface: StringRedisConnection
    
    Set value for key applying timeouts from expiration if set and inserting/updating values depending on option.
    See http://redis.io/commands/set
    
    Specified by:
    
    set in interface StringRedisConnection
    
    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 SetOption#UPSERT.
  - setBit
```
public Boolean setBit(String key,
                      long offset,
                      boolean value)
```
    Description copied from interface: StringRedisConnection
    
    Sets the bit at offset in value stored at key.
    See http://redis.io/commands/setbit
    
    Specified by:
    
    setBit in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    the original bit value stored at offset.
  - setEx
```
public void setEx(String key,
                  long seconds,
                  String value)
```
    Description copied from interface: StringRedisConnection
    
    Set the value and expiration in seconds for key.
    See http://redis.io/commands/setex
    
    Specified by:
    
    setEx in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
  - pSetEx
```
public void pSetEx(String key,
                   long seconds,
                   String value)
```
    Description copied from interface: StringRedisConnection
    
    Set the value and expiration in milliseconds for key.
    See http://redis.io/commands/psetex
    
    Specified by:
    
    pSetEx in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
  - setNX
```
public Boolean setNX(String key,
                     String value)
```
    Description copied from interface: StringRedisConnection
    
    Set value for key, only if key does not exist.
    See http://redis.io/commands/setnx
    
    Specified by:
    
    setNX in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    value - must not be null.
    
    Returns:
  - setRange
```
public void setRange(String key,
                     String value,
                     long start)
```
    Description copied from interface: StringRedisConnection
    
    Overwrite parts of key starting at the specified offset with given value.
    See http://redis.io/commands/setrange
    
    Specified by:
    
    setRange in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
  - sInter
```
public Set<String> sInter(String... keys)
```
    Specified by:
    
    sInter in interface StringRedisConnection
  - sInterStore
```
public Long sInterStore(String destKey,
                        String... keys)
```
    Specified by:
    
    sInterStore in interface StringRedisConnection
  - sIsMember
```
public Boolean sIsMember(String key,
                         String value)
```
    Specified by:
    
    sIsMember in interface StringRedisConnection
  - sMembers
```
public Set<String> sMembers(String key)
```
    Specified by:
    
    sMembers in interface StringRedisConnection
  - sMove
```
public Boolean sMove(String srcKey,
                     String destKey,
                     String value)
```
    Specified by:
    
    sMove in interface StringRedisConnection
  - sort
```
public Long sort(String key,
                 SortParameters params,
                 String storeKey)
```
    Specified by:
    
    sort in interface StringRedisConnection
  - sort
```
public List<String> sort(String key,
                         SortParameters params)
```
    Specified by:
    
    sort in interface StringRedisConnection
  - sPop
```
public String sPop(String key)
```
    Specified by:
    
    sPop in interface StringRedisConnection
  - sRandMember
```
public String sRandMember(String key)
```
    Specified by:
    
    sRandMember in interface StringRedisConnection
  - sRandMember
```
public List<String> sRandMember(String key,
                                long count)
```
    Specified by:
    
    sRandMember in interface StringRedisConnection
  - sRem
```
public Long sRem(String key,
                 String... values)
```
    Specified by:
    
    sRem in interface StringRedisConnection
  - strLen
```
public Long strLen(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the length of the value stored at key.
    See http://redis.io/commands/strlen
    
    Specified by:
    
    strLen in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - bitCount
```
public Long bitCount(String key)
```
    Description copied from interface: StringRedisConnection
    
    Count the number of set bits (population counting) in value stored at key.
    See http://redis.io/commands/bitcount
    
    Specified by:
    
    bitCount in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - bitCount
```
public Long bitCount(String key,
                     long begin,
                     long end)
```
    Description copied from interface: StringRedisConnection
    
    Count the number of set bits (population counting) of value stored at key between begin and end.
    See http://redis.io/commands/bitcount
    
    Specified by:
    
    bitCount in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - bitOp
```
public Long bitOp(RedisStringCommands.BitOperation op,
                  String destination,
                  String... keys)
```
    Description copied from interface: StringRedisConnection
    
    Perform bitwise operations between strings.
    See http://redis.io/commands/bitop
    
    Specified by:
    
    bitOp in interface StringRedisConnection
    
    Returns:
  - subscribe
```
public void subscribe(MessageListener listener,
                      String... channels)
```
    Specified by:
    
    subscribe in interface StringRedisConnection
  - sUnion
```
public Set<String> sUnion(String... keys)
```
    Specified by:
    
    sUnion in interface StringRedisConnection
  - sUnionStore
```
public Long sUnionStore(String destKey,
                        String... keys)
```
    Specified by:
    
    sUnionStore in interface StringRedisConnection
  - ttl
```
public Long ttl(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the time to live for key in seconds.
    See http://redis.io/commands/ttl
    
    Specified by:
    
    ttl in interface StringRedisConnection
    
    Returns:
  - ttl
```
public Long ttl(String key,
                TimeUnit timeUnit)
```
    Description copied from interface: StringRedisConnection
    
    Get the time to live for key in and convert it to the given TimeUnit.
    See http://redis.io/commands/ttl
    
    Specified by:
    
    ttl in interface StringRedisConnection
    
    Returns:
  - type
```
public DataType type(String key)
```
    Description copied from interface: StringRedisConnection
    
    Determine the type stored at key.
    See http://redis.io/commands/type
    
    Specified by:
    
    type in interface StringRedisConnection
    
    Returns:
  - zAdd
```
public Boolean zAdd(String key,
                    double score,
                    String value)
```
    Specified by:
    
    zAdd in interface StringRedisConnection
  - zAdd
```
public Long zAdd(String key,
                 Set<StringRedisConnection.StringTuple> tuples)
```
    Specified by:
    
    zAdd in interface StringRedisConnection
  - zCard
```
public Long zCard(String key)
```
    Specified by:
    
    zCard in interface StringRedisConnection
  - zCount
```
public Long zCount(String key,
                   double min,
                   double max)
```
    Specified by:
    
    zCount in interface StringRedisConnection
  - zIncrBy
```
public Double zIncrBy(String key,
                      double increment,
                      String value)
```
    Specified by:
    
    zIncrBy in interface StringRedisConnection
  - zInterStore
```
public Long zInterStore(String destKey,
                        RedisZSetCommands.Aggregate aggregate,
                        int[] weights,
                        String... sets)
```
    Specified by:
    
    zInterStore in interface StringRedisConnection
  - zInterStore
```
public Long zInterStore(String destKey,
                        String... sets)
```
    Specified by:
    
    zInterStore in interface StringRedisConnection
  - zRange
```
public Set<String> zRange(String key,
                          long start,
                          long end)
```
    Specified by:
    
    zRange in interface StringRedisConnection
  - zRangeByScore
```
public Set<String> zRangeByScore(String key,
                                 double min,
                                 double max,
                                 long offset,
                                 long count)
```
    Specified by:
    
    zRangeByScore in interface StringRedisConnection
  - zRangeByScore
```
public Set<String> zRangeByScore(String key,
                                 double min,
                                 double max)
```
    Specified by:
    
    zRangeByScore in interface StringRedisConnection
  - zRangeByScoreWithScores
```
public Set<StringRedisConnection.StringTuple> zRangeByScoreWithScores(String key,
                                                                      double min,
                                                                      double max,
                                                                      long offset,
                                                                      long count)
```
    Specified by:
    
    zRangeByScoreWithScores in interface StringRedisConnection
  - zRangeByScoreWithScores
```
public Set<StringRedisConnection.StringTuple> zRangeByScoreWithScores(String key,
                                                                      double min,
                                                                      double max)
```
    Specified by:
    
    zRangeByScoreWithScores in interface StringRedisConnection
  - zRangeWithScores
```
public Set<StringRedisConnection.StringTuple> zRangeWithScores(String key,
                                                               long start,
                                                               long end)
```
    Specified by:
    
    zRangeWithScores in interface StringRedisConnection
  - zRank
```
public Long zRank(String key,
                  String value)
```
    Specified by:
    
    zRank in interface StringRedisConnection
  - zRem
```
public Long zRem(String key,
                 String... values)
```
    Specified by:
    
    zRem in interface StringRedisConnection
  - zRemRange
```
public Long zRemRange(String key,
                      long start,
                      long end)
```
    Specified by:
    
    zRemRange in interface StringRedisConnection
  - zRemRangeByScore
```
public Long zRemRangeByScore(String key,
                             double min,
                             double max)
```
    Specified by:
    
    zRemRangeByScore in interface StringRedisConnection
  - zRevRange
```
public Set<String> zRevRange(String key,
                             long start,
                             long end)
```
    Specified by:
    
    zRevRange in interface StringRedisConnection
  - zRevRangeWithScores
```
public Set<StringRedisConnection.StringTuple> zRevRangeWithScores(String key,
                                                                  long start,
                                                                  long end)
```
    Specified by:
    
    zRevRangeWithScores in interface StringRedisConnection
  - zRevRangeByScore
```
public Set<String> zRevRangeByScore(String key,
                                    double min,
                                    double max)
```
    Specified by:
    
    zRevRangeByScore in interface StringRedisConnection
  - zRevRangeByScoreWithScores
```
public Set<StringRedisConnection.StringTuple> zRevRangeByScoreWithScores(String key,
                                                                         double min,
                                                                         double max)
```
    Specified by:
    
    zRevRangeByScoreWithScores in interface StringRedisConnection
  - zRevRangeByScore
```
public Set<String> zRevRangeByScore(String key,
                                    double min,
                                    double max,
                                    long offset,
                                    long count)
```
    Specified by:
    
    zRevRangeByScore in interface StringRedisConnection
  - zRevRangeByScoreWithScores
```
public Set<StringRedisConnection.StringTuple> zRevRangeByScoreWithScores(String key,
                                                                         double min,
                                                                         double max,
                                                                         long offset,
                                                                         long count)
```
    Specified by:
    
    zRevRangeByScoreWithScores in interface StringRedisConnection
  - zRevRank
```
public Long zRevRank(String key,
                     String value)
```
    Specified by:
    
    zRevRank in interface StringRedisConnection
  - zScore
```
public Double zScore(String key,
                     String value)
```
    Specified by:
    
    zScore in interface StringRedisConnection
  - zUnionStore
```
public Long zUnionStore(String destKey,
                        RedisZSetCommands.Aggregate aggregate,
                        int[] weights,
                        String... sets)
```
    Specified by:
    
    zUnionStore in interface StringRedisConnection
  - zUnionStore
```
public Long zUnionStore(String destKey,
                        String... sets)
```
    Specified by:
    
    zUnionStore in interface StringRedisConnection
  - geoAdd
```
public Long geoAdd(byte[] key,
                   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:
    
    http://redis.io/commands/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:
    
    http://redis.io/commands/geoadd
  - geoAdd
```
public Long geoAdd(String key,
                   Point point,
                   String member)
```
    Description copied from interface: StringRedisConnection
    
    Add Point with given member name to key.
    
    Specified by:
    
    geoAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    point - must not be null.
    
    member - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    http://redis.io/commands/geoadd
  - geoAdd
```
public Long geoAdd(String key,
                   RedisGeoCommands.GeoLocation<String> location)
```
    Description copied from interface: StringRedisConnection
    
    Add GeoLocation to key.
    
    Specified by:
    
    geoAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    location - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    http://redis.io/commands/geoadd
  - geoAdd
```
public Long geoAdd(byte[] key,
                   Map<byte[],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:
    
    http://redis.io/commands/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:
    
    http://redis.io/commands/geoadd
  - geoAdd
```
public Long geoAdd(String key,
                   Map<String,Point> memberCoordinateMap)
```
    Description copied from interface: StringRedisConnection
    
    Add Map of member / Point pairs to key.
    
    Specified by:
    
    geoAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    memberCoordinateMap - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    http://redis.io/commands/geoadd
  - geoAdd
```
public Long geoAdd(String key,
                   Iterable<RedisGeoCommands.GeoLocation<String>> locations)
```
    Description copied from interface: StringRedisConnection
    
    Add GeoLocations to key
    
    Specified by:
    
    geoAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    locations - must not be null.
    
    Returns:
    
    Number of elements added.
    
    See Also:
    
    http://redis.io/commands/geoadd
  - geoDist
```
public 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:
    
    http://redis.io/commands/geodist
  - geoDist
```
public Distance geoDist(String key,
                        String member1,
                        String member2)
```
    Description copied from interface: StringRedisConnection
    
    Get the Distance between member1 and member2.
    
    Specified by:
    
    geoDist in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    member1 - must not be null.
    
    member2 - must not be null.
    
    Returns:
    
    can be null.
    
    See Also:
    
    http://redis.io/commands/geodist
  - geoDist
```
public Distance geoDist(byte[] key,
                        byte[] member1,
                        byte[] member2,
                        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:
    
    http://redis.io/commands/geodist
  - geoDist
```
public Distance geoDist(String key,
                        String member1,
                        String member2,
                        Metric metric)
```
    Description copied from interface: StringRedisConnection
    
    Get the Distance between member1 and member2 in the given Metric.
    
    Specified by:
    
    geoDist in interface StringRedisConnection
    
    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:
    
    http://redis.io/commands/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:
    
    http://redis.io/commands/geohash
  - geoHash
```
public List<String> geoHash(String key,
                            String... members)
```
    Description copied from interface: StringRedisConnection
    
    Get geohash representation of the position for one or more members.
    
    Specified by:
    
    geoHash in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    http://redis.io/commands/geohash
  - geoPos
```
public List<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:
    
    http://redis.io/commands/geopos
  - geoPos
```
public List<Point> geoPos(String key,
                          String... members)
```
    Description copied from interface: StringRedisConnection
    
    Get the Point representation of positions for one or more members.
    
    Specified by:
    
    geoPos in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    http://redis.io/commands/geopos
  - geoRadius
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadius(String key,
                                                                  Circle within)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the boundaries of a given Circle.
    
    Specified by:
    
    geoRadius in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    within - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    http://redis.io/commands/georadius
  - geoRadius
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadius(String key,
                                                                  Circle within,
                                                                  RedisGeoCommands.GeoRadiusCommandArgs args)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the boundaries of a given Circle applying GeoRadiusCommandArgs.
    
    Specified by:
    
    geoRadius in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    within - must not be null.
    
    args - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    http://redis.io/commands/georadius
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key,
                                                                          String member,
                                                                          double radius)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the circle defined by the members coordinates and given radius.
    
    Specified by:
    
    geoRadiusByMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    http://redis.io/commands/georadiusbymember
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key,
                                                                          String member,
                                                                          Distance radius)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the circle defined by the members coordinates and given Distance.
    
    Specified by:
    
    geoRadiusByMember in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    member - must not be null.
    
    radius - must not be null.
    
    Returns:
    
    never null.
    
    See Also:
    
    http://redis.io/commands/georadiusbymember
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<String>> geoRadiusByMember(String key,
                                                                          String member,
                                                                          Distance radius,
                                                                          RedisGeoCommands.GeoRadiusCommandArgs args)
```
    Description copied from interface: StringRedisConnection
    
    Get the members within the circle defined by the members coordinates and given Distance and GeoRadiusCommandArgs.
    
    Specified by:
    
    geoRadiusByMember in interface StringRedisConnection
    
    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:
    
    http://redis.io/commands/georadiusbymember
  - geoRadius
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key,
                                                                  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:
    
    http://redis.io/commands/georadius
  - geoRadius
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key,
                                                                  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:
    
    http://redis.io/commands/georadius
  - geoRadiusByMember
```
public 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:
    
    http://redis.io/commands/georadiusbymember
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                          byte[] member,
                                                                          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:
    
    http://redis.io/commands/georadiusbymember
  - geoRadiusByMember
```
public GeoResults<RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                          byte[] member,
                                                                          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:
    
    http://redis.io/commands/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.
  - geoRemove
```
public Long geoRemove(String key,
                      String... members)
```
    Description copied from interface: StringRedisConnection
    
    Remove the members.
    
    Specified by:
    
    geoRemove in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    members - must not be null.
    
    Returns:
    
    Number of members elements removed.
  - closePipeline
```
public List<Object> closePipeline()
```
    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.
  - 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()
  - execute
```
public Object execute(String command)
```
    Specified by:
    
    execute in interface StringRedisConnection
  - 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.
  - execute
```
public Object execute(String command,
                      String... args)
```
    Specified by:
    
    execute in interface StringRedisConnection
  - pExpire
```
public Boolean pExpire(String key,
                       long millis)
```
    Description copied from interface: StringRedisConnection
    
    Set time to live for given key in milliseconds.
    See http://redis.io/commands/pexpire
    
    Specified by:
    
    pExpire in interface StringRedisConnection
    
    Returns:
  - pExpireAt
```
public Boolean pExpireAt(String key,
                         long unixTimeInMillis)
```
    Description copied from interface: StringRedisConnection
    
    Set the expiration for given key as a UNIX timestamp in milliseconds.
    See http://redis.io/commands/pexpireat
    
    Specified by:
    
    pExpireAt in interface StringRedisConnection
    
    Returns:
  - pTtl
```
public Long pTtl(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get the precise time to live for key in milliseconds.
    See http://redis.io/commands/pttl
    
    Specified by:
    
    pTtl in interface StringRedisConnection
    
    Returns:
  - pTtl
```
public Long pTtl(String key,
                 TimeUnit timeUnit)
```
    Description copied from interface: StringRedisConnection
    
    Get the precise time to live for key in and convert it to the given TimeUnit.
    See http://redis.io/commands/pttl
    
    Specified by:
    
    pTtl in interface StringRedisConnection
    
    Returns:
  - scriptLoad
```
public String scriptLoad(String script)
```
    Specified by:
    
    scriptLoad in interface StringRedisConnection
  - eval
```
public <T> T eval(String script,
                  ReturnType returnType,
                  int numKeys,
                  String... keysAndArgs)
```
    NOTE: This method will not deserialize Strings returned by Lua scripts, as they may not be encoded with the same serializer used here. They will be returned as byte[]s
    
    Specified by:
    
    eval in interface StringRedisConnection
  - evalSha
```
public <T> T evalSha(String scriptSha1,
                     ReturnType returnType,
                     int numKeys,
                     String... keysAndArgs)
```
    NOTE: This method will not deserialize Strings returned by Lua scripts, as they may not be encoded with the same serializer used here. They will be returned as byte[]s
    
    Specified by:
    
    evalSha in interface StringRedisConnection
  - 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.
  - getClientList
```
public List<RedisClientInfo> getClientList()
```
    Description copied from interface: RedisServerCommands
    
    Request information and statistics about connected clients.
    See http://redis.io/commands/client-list
    
    Specified by:
    
    getClientList in interface RedisServerCommands
    
    Specified by:
    
    getClientList in interface StringRedisConnection
    
    Returns:
    
    List of RedisClientInfo objects.
    
    See Also:
    
    RedisServerCommands.getClientList()
  - slaveOf
```
public void slaveOf(String host,
                    int port)
```
    Description copied from interface: RedisServerCommands
    
    Change redis replication setting to new master.
    See http://redis.io/commands/slaveof
    
    Specified by:
    
    slaveOf in interface RedisServerCommands
  - slaveOfNoOne
```
public void slaveOfNoOne()
```
    Description copied from interface: RedisServerCommands
    
    Change server into master.
    See http://redis.io/commands/slaveof
    
    Specified by:
    
    slaveOfNoOne in interface RedisServerCommands
  - scan
```
public Cursor<byte[]> scan(ScanOptions options)
```
    Description copied from interface: RedisKeyCommands
    
    Use a Cursor to iterate over keys.
    See http://redis.io/commands/scan
    
    Specified by:
    
    scan in interface RedisKeyCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/scan
    
    Specified by:
    
    zScan in interface RedisZSetCommands
    
    Returns:
  - 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.
    See http://redis.io/commands/scan
    
    Specified by:
    
    sScan in interface RedisSetCommands
    
    Returns:
  - 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
    
    Returns:
    
    See Also:
    
    http://redis.io/commands/scan
  - setDeserializePipelineAndTxResults
```
public void setDeserializePipelineAndTxResults(boolean deserializePipelineAndTxResults)
```
    Specifies if pipelined and tx results should be deserialized to Strings. If false, results of closePipeline() and exec() will be of the type returned by the underlying connection
    
    Parameters:
    
    deserializePipelineAndTxResults - Whether or not to deserialize pipeline and tx results
  - setClientName
```
public void setClientName(byte[] name)
```
    Description copied from interface: RedisServerCommands
    
    Assign given name to current connection.
    
    Specified by:
    
    setClientName in interface RedisServerCommands
  - setClientName
```
public void setClientName(String name)
```
    Description copied from interface: StringRedisConnection
    
    Assign given name to connection using registered RedisSerializer for name conversion.
    
    Specified by:
    
    setClientName in interface StringRedisConnection
    
    See Also:
    
    RedisServerCommands.setClientName(byte[])
  - 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
  - getClientName
```
public String getClientName()
```
    Description copied from interface: RedisServerCommands
    
    Returns the name of the current connection.
    See http://redis.io/commands/client-getname
    
    Specified by:
    
    getClientName in interface RedisServerCommands
    
    Returns:
  - hScan
```
public Cursor<Map.Entry<String,String>> hScan(String key,
                                              ScanOptions options)
```
    Specified by:
    
    hScan in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    RedisHashCommands.hScan(byte[], ScanOptions)
  - sScan
```
public Cursor<String> sScan(String key,
                            ScanOptions options)
```
    Specified by:
    
    sScan in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    RedisSetCommands.sScan(byte[], ScanOptions)
  - zScan
```
public Cursor<StringRedisConnection.StringTuple> zScan(String key,
                                                       ScanOptions options)
```
    Specified by:
    
    zScan in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
    
    See Also:
    
    RedisZSetCommands.zScan(byte[], ScanOptions)
  - getSentinelConnection
```
public RedisSentinelConnection getSentinelConnection()
```
    Specified by:
    
    getSentinelConnection in interface RedisConnection
    
    Returns:
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(String key,
                                 String min,
                                 String max)
```
    Specified by:
    
    zRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - zRangeByScore
```
public Set<byte[]> zRangeByScore(String key,
                                 String min,
                                 String max,
                                 long offset,
                                 long count)
```
    Specified by:
    
    zRangeByScore in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - 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.
    See http://redis.io/commands/zrangebyscore
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Returns:
  - 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 begin to end where score is between min and max from sorted set.
    See http://redis.io/commands/zrangebyscore
    
    Specified by:
    
    zRangeByScore in interface RedisZSetCommands
    
    Returns:
  - 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
    
    Returns:
  - pfAdd
```
public Long pfAdd(String key,
                  String... values)
```
    Description copied from interface: StringRedisConnection
    
    Adds given values to the HyperLogLog stored at given key.
    
    Specified by:
    
    pfAdd in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - 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
    
    Returns:
  - pfCount
```
public Long pfCount(String... keys)
```
    Specified by:
    
    pfCount in interface StringRedisConnection
    
    Returns:
  - 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
  - pfMerge
```
public void pfMerge(String destinationKey,
                    String... sourceKeys)
```
    Specified by:
    
    pfMerge in interface StringRedisConnection
  - 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:
  - 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:
  - 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:
  - zRangeByLex
```
public Set<String> zRangeByLex(String key)
```
    Description copied from interface: StringRedisConnection
    
    Get all elements in the sorted set at key in lexicographical ordering.
    
    Specified by:
    
    zRangeByLex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    Returns:
  - zRangeByLex
```
public Set<String> zRangeByLex(String key,
                               RedisZSetCommands.Range range)
```
    Description copied from interface: StringRedisConnection
    
    Get the elements in Range from the sorted set at key in lexicographical ordering
    
    Specified by:
    
    zRangeByLex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
  - zRangeByLex
```
public Set<String> zRangeByLex(String key,
                               RedisZSetCommands.Range range,
                               RedisZSetCommands.Limit limit)
```
    Description copied from interface: StringRedisConnection
    
    Get the elements in Range from the sorted set at key in lexicographical ordering. Result is limited via Limit.
    
    Specified by:
    
    zRangeByLex in interface StringRedisConnection
    
    Parameters:
    
    key - must not be null.
    
    range - must not be null.
    
    Returns:
  - migrate
```
public void migrate(byte[] key,
                    RedisNode target,
                    int dbIndex,
                    RedisServerCommands.MigrateOption option)
```
    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.
  - migrate
```
public void migrate(byte[] key,
                    RedisNode target,
                    int dbIndex,
                    RedisServerCommands.MigrateOption option,
                    long timeout)
```
    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.
  - getDelegate
```
public RedisConnection getDelegate()
```
    Description copied from interface: DecoratedRedisConnection
    
    Gets the underlying RedisConnection.
    
    Specified by:
    
    getDelegate in interface DecoratedRedisConnection
    
    Returns:
    
    never null.

Class DefaultStringRedisConnection

Nested Class Summary

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

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DefaultStringRedisConnection

DefaultStringRedisConnection

Method Detail

append

bgSave

bgReWriteAof

bgWriteAof

bLPop

bRPop

bRPopLPush

close

dbSize

decr

decrBy

del

discard

echo

exec

exists

expire

expireAt

flushAll

flushDb

get

getBit

getConfig

getNativeConnection

getRange

getSet

getSubscription

hDel

hExists

hGet

hGetAll

hIncrBy

hIncrBy

hKeys

hLen

hMGet

hMSet

hSet

hSetNX

hVals

incr

incrBy

incrBy

info

info

isClosed

isQueueing

isSubscribed

keys

lastSave

lIndex

lInsert

lLen

lPop

lPush

lPushX

lRange

lRem

lSet

lTrim

mGet

mSet

mSetNX

multi

persist