Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.data.redis.connection
Class DefaultStringRedisConnection

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

All Implemented Interfaces:
  RedisCommands, RedisConnection, RedisConnectionCommands, RedisHashCommands, RedisKeyCommands, RedisListCommands, RedisPubSubCommands, RedisScriptingCommands, RedisServerCommands, RedisSetCommands, RedisStringCommands, RedisTxCommands, RedisZSetCommands, StringRedisConnection

    public class DefaultStringRedisConnection

extends Object
implements StringRedisConnection

Default implementation of `StringRedisConnection`.

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`

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.Tuple`

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

Method Summary
`Long` | `append(byte[] key, byte[] value)`
`Long` | `append(String key, String value)`
`void` | `bgSave()`
`void` | `bgWriteAof()`
`Long` | `bitCount(byte[] key)`
`Long` | `bitCount(byte[] key, long begin, long end)`
`Long` | `bitCount(String key)`
`Long` | `bitCount(String key, long begin, long end)`
`Long` | `bitOp(RedisStringCommands.BitOperation op, byte[] destination, byte[]... keys)`
`Long` | `bitOp(RedisStringCommands.BitOperation op, String destination, String... keys)`
`List<byte[]>` | `bLPop(int timeout, byte[]... keys)`
`List<String>` | `bLPop(int timeout, String... keys)`
`List<byte[]>` | `bRPop(int timeout, byte[]... keys)`
`List<String>` | `bRPop(int timeout, String... keys)`
`byte[]` | `bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey)`
`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()`
`Long` | `decr(byte[] key)`
`Long` | `decr(String key)`
`Long` | `decrBy(byte[] key, long value)`
`Long` | `decrBy(String key, long value)`
`Long` | `del(byte[]... keys)`
`Long` | `del(String... keys)`
`void` | `discard()`
`byte[]` | `dump(byte[] key)`
`byte[]` | `echo(byte[] message)`
`String` | `echo(String message)`
`
`<T> T`
` | `eval(byte[] script, ReturnType returnType, int numKeys, byte[]... keysAndArgs)`
`
`<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(String scriptSha1, ReturnType returnType, int numKeys, byte[]... keysAndArgs)`
`
`<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()`
`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)`
`Boolean` | `exists(String key)`
`Boolean` | `expire(byte[] key, long seconds)`
`Boolean` | `expire(String key, long seconds)`
`Boolean` | `expireAt(byte[] key, long unixTime)`
`Boolean` | `expireAt(String key, long unixTime)`
`void` | `flushAll()`
`void` | `flushDb()`
`byte[]` | `get(byte[] key)`
`String` | `get(String key)`
`Boolean` | `getBit(byte[] key, long offset)`
`Boolean` | `getBit(String key, long offset)`
`List<String>` | `getConfig(String pattern)`
`Object` | `getNativeConnection()` Returns the native connection (the underlying library/driver object).
`byte[]` | `getRange(byte[] key, long start, long end)`
`String` | `getRange(String key, long start, long end)`
`byte[]` | `getSet(byte[] key, byte[] value)`
`String` | `getSet(String key, String value)`
`Subscription` | `getSubscription()` Returns the current subscription for this connection or null if the connection is not subscribed.
`Long` | `hDel(byte[] key, byte[]... fields)`
`Long` | `hDel(String key, String... fields)`
`Boolean` | `hExists(byte[] key, byte[] field)`
`Boolean` | `hExists(String key, String field)`
`byte[]` | `hGet(byte[] key, byte[] field)`
`String` | `hGet(String key, String field)`
`Map<byte[],byte[]>` | `hGetAll(byte[] key)`
`Map<String,String>` | `hGetAll(String key)`
`Double` | `hIncrBy(byte[] key, byte[] field, double delta)`
`Long` | `hIncrBy(byte[] key, byte[] field, long delta)`
`Double` | `hIncrBy(String key, String field, double delta)`
`Long` | `hIncrBy(String key, String field, long delta)`
`Set<byte[]>` | `hKeys(byte[] key)`
`Set<String>` | `hKeys(String key)`
`Long` | `hLen(byte[] key)`
`Long` | `hLen(String key)`
`List<byte[]>` | `hMGet(byte[] key, byte[]... fields)`
`List<String>` | `hMGet(String key, String... fields)`
`void` | `hMSet(byte[] key, Map<byte[],byte[]> hashes)`
`void` | `hMSet(String key, Map<String,String> hashes)`
`Boolean` | `hSet(byte[] key, byte[] field, byte[] value)`
`Boolean` | `hSet(String key, String field, String value)`
`Boolean` | `hSetNX(byte[] key, byte[] field, byte[] value)`
`Boolean` | `hSetNX(String key, String field, String value)`
`List<byte[]>` | `hVals(byte[] key)`
`List<String>` | `hVals(String key)`
`Long` | `incr(byte[] key)`
`Long` | `incr(String key)`
`Double` | `incrBy(byte[] key, double value)`
`Long` | `incrBy(byte[] key, long value)`
`Double` | `incrBy(String key, double value)`
`Long` | `incrBy(String key, long value)`
`Properties` | `info()`
`Properties` | `info(String section)`
`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)`
`Collection<String>` | `keys(String pattern)`
`Long` | `lastSave()`
`byte[]` | `lIndex(byte[] key, long index)`
`String` | `lIndex(String key, long index)`
`Long` | `lInsert(byte[] key, RedisListCommands.Position where, byte[] pivot, byte[] value)`
`Long` | `lInsert(String key, RedisListCommands.Position where, String pivot, String value)`
`Long` | `lLen(byte[] key)`
`Long` | `lLen(String key)`
`byte[]` | `lPop(byte[] key)`
`String` | `lPop(String key)`
`Long` | `lPush(byte[] key, byte[]... values)`
`Long` | `lPush(String key, String... values)`
`Long` | `lPushX(byte[] key, byte[] value)`
`Long` | `lPushX(String key, String value)`
`List<byte[]>` | `lRange(byte[] key, long start, long end)`
`List<String>` | `lRange(String key, long start, long end)`
`Long` | `lRem(byte[] key, long count, byte[] value)`
`Long` | `lRem(String key, long count, String value)`
`void` | `lSet(byte[] key, long index, byte[] value)`
`void` | `lSet(String key, long index, String value)`
`void` | `lTrim(byte[] key, long start, long end)`
`void` | `lTrim(String key, long start, long end)`
`List<byte[]>` | `mGet(byte[]... keys)`
`List<String>` | `mGet(String... keys)`
`Boolean` | `move(byte[] key, int dbIndex)`
`Boolean` | `move(String key, int dbIndex)`
`void` | `mSet(Map<byte[],byte[]> tuple)`
`Boolean` | `mSetNX(Map<byte[],byte[]> tuple)`
`Boolean` | `mSetNXString(Map<String,String> tuple)`
`void` | `mSetString(Map<String,String> tuple)`
`void` | `multi()`
`void` | `openPipeline()` Activates the pipeline mode for this connection.
`Boolean` | `persist(byte[] key)`
`Boolean` | `persist(String key)`
`Boolean` | `pExpire(byte[] key, long millis)`
`Boolean` | `pExpire(String key, long millis)`
`Boolean` | `pExpireAt(byte[] key, long unixTimeInMillis)`
`Boolean` | `pExpireAt(String key, long unixTimeInMillis)`
`String` | `ping()`
`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)`
`Long` | `pTtl(String key)`
`Long` | `publish(byte[] channel, byte[] message)` Publishes the given message to the given channel.
`Long` | `publish(String channel, String message)`
`byte[]` | `randomKey()`
`void` | `rename(byte[] oldName, byte[] newName)`
`void` | `rename(String oldName, String newName)`
`Boolean` | `renameNX(byte[] oldName, byte[] newName)`
`Boolean` | `renameNX(String oldName, String newName)`
`void` | `resetConfigStats()`
`void` | `restore(byte[] key, long ttlInMillis, byte[] serializedValue)`
`byte[]` | `rPop(byte[] key)`
`String` | `rPop(String key)`
`byte[]` | `rPopLPush(byte[] srcKey, byte[] dstKey)`
`String` | `rPopLPush(String srcKey, String dstKey)`
`Long` | `rPush(byte[] key, byte[]... values)`
`Long` | `rPush(String key, String... values)`
`Long` | `rPushX(byte[] key, byte[] value)`
`Long` | `rPushX(String key, String value)`
`Long` | `sAdd(byte[] key, byte[]... values)`
`Long` | `sAdd(String key, String... values)`
`void` | `save()`
`Long` | `sCard(byte[] key)`
`Long` | `sCard(String key)`
`List<Boolean>` | `scriptExists(String... scriptSha1)`
`void` | `scriptFlush()`
`void` | `scriptKill()`
`String` | `scriptLoad(byte[] script)`
`String` | `scriptLoad(String script)`
`Set<byte[]>` | `sDiff(byte[]... keys)`
`Set<String>` | `sDiff(String... keys)`
`Long` | `sDiffStore(byte[] destKey, byte[]... keys)`
`Long` | `sDiffStore(String destKey, String... keys)`
`void` | `select(int dbIndex)`
`void` | `set(byte[] key, byte[] value)`
`void` | `set(String key, String value)`
`void` | `setBit(byte[] key, long offset, boolean value)`
`void` | `setBit(String key, long offset, boolean value)`
`void` | `setConfig(String param, String value)`
`void` | `setDeserializePipelineAndTxResults(boolean deserializePipelineAndTxResults)` Specifies if pipelined and tx results should be deserialized to Strings.
`void` | `setEx(byte[] key, long seconds, byte[] value)`
`void` | `setEx(String key, long seconds, String value)`
`Boolean` | `setNX(byte[] key, byte[] value)`
`Boolean` | `setNX(String key, String value)`
`void` | `setRange(byte[] key, byte[] value, long start)`
`void` | `setRange(String key, String value, long start)`
`void` | `shutdown()`
`Set<byte[]>` | `sInter(byte[]... keys)`
`Set<String>` | `sInter(String... keys)`
`Long` | `sInterStore(byte[] destKey, byte[]... keys)`
`Long` | `sInterStore(String destKey, String... keys)`
`Boolean` | `sIsMember(byte[] key, byte[] value)`
`Boolean` | `sIsMember(String key, String value)`
`Set<byte[]>` | `sMembers(byte[] key)`
`Set<String>` | `sMembers(String key)`
`Boolean` | `sMove(byte[] srcKey, byte[] destKey, byte[] value)`
`Boolean` | `sMove(String srcKey, String destKey, String value)`
`List<byte[]>` | `sort(byte[] key, SortParameters params)`
`Long` | `sort(byte[] key, SortParameters params, byte[] storeKey)`
`List<String>` | `sort(String key, SortParameters params)`
`Long` | `sort(String key, SortParameters params, String storeKey)`
`byte[]` | `sPop(byte[] key)`
`String` | `sPop(String key)`
`byte[]` | `sRandMember(byte[] key)`
`List<byte[]>` | `sRandMember(byte[] key, long count)`
`String` | `sRandMember(String key)`
`List<String>` | `sRandMember(String key, long count)`
`Long` | `sRem(byte[] key, byte[]... values)`
`Long` | `sRem(String key, String... values)`
`Long` | `strLen(byte[] key)`
`Long` | `strLen(String 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)`
`Set<String>` | `sUnion(String... keys)`
`Long` | `sUnionStore(byte[] destKey, byte[]... keys)`
`Long` | `sUnionStore(String destKey, String... keys)`
`Long` | `ttl(byte[] key)`
`Long` | `ttl(String key)`
`DataType` | `type(byte[] key)`
`DataType` | `type(String key)`
`void` | `unwatch()`
`void` | `watch(byte[]... keys)`
`Boolean` | `zAdd(byte[] key, double score, byte[] value)`
`Long` | `zAdd(byte[] key, Set<RedisZSetCommands.Tuple> tuples)`
`Boolean` | `zAdd(String key, double score, String value)`
`Long` | `zAdd(String key, Set<StringRedisConnection.StringTuple> tuples)`
`Long` | `zCard(byte[] key)`
`Long` | `zCard(String key)`
`Long` | `zCount(byte[] key, double min, double max)`
`Long` | `zCount(String key, double min, double max)`
`Double` | `zIncrBy(byte[] key, double increment, byte[] value)`
`Double` | `zIncrBy(String key, double increment, String value)`
`Long` | `zInterStore(byte[] destKey, byte[]... sets)`
`Long` | `zInterStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets)`
`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)`
`Set<String>` | `zRange(String key, long start, long end)`
`Set<byte[]>` | `zRangeByScore(byte[] key, double min, double max)`
`Set<byte[]>` | `zRangeByScore(byte[] key, double min, double max, long offset, long count)`
`Set<String>` | `zRangeByScore(String key, double min, double max)`
`Set<String>` | `zRangeByScore(String key, double min, double max, long offset, long count)`
`Set<RedisZSetCommands.Tuple>` | `zRangeByScoreWithScores(byte[] key, double min, double max)`
`Set<RedisZSetCommands.Tuple>` | `zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count)`
`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)`
`Set<StringRedisConnection.StringTuple>` | `zRangeWithScores(String key, long start, long end)`
`Long` | `zRank(byte[] key, byte[] value)`
`Long` | `zRank(String key, String value)`
`Long` | `zRem(byte[] key, byte[]... values)`
`Long` | `zRem(String key, String... values)`
`Long` | `zRemRange(byte[] key, long start, long end)`
`Long` | `zRemRange(String key, long start, long end)`
`Long` | `zRemRangeByScore(byte[] key, double min, double max)`
`Long` | `zRemRangeByScore(String key, double min, double max)`
`Set<byte[]>` | `zRevRange(byte[] key, long start, long end)`
`Set<String>` | `zRevRange(String key, long start, long end)`
`Set<byte[]>` | `zRevRangeByScore(byte[] key, double min, double max)`
`Set<byte[]>` | `zRevRangeByScore(byte[] key, double min, double max, long offset, long count)`
`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)`
`Set<RedisZSetCommands.Tuple>` | `zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count)`
`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)`
`Set<StringRedisConnection.StringTuple>` | `zRevRangeWithScores(String key, long start, long end)`
`Long` | `zRevRank(byte[] key, byte[] value)`
`Long` | `zRevRank(String key, String value)`
`Double` | `zScore(byte[] key, byte[] value)`
`Double` | `zScore(String key, String value)`
`Long` | `zUnionStore(byte[] destKey, byte[]... sets)`
`Long` | `zUnionStore(byte[] destKey, RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets)`
`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)

  Specified by:
    `append` in interface `RedisStringCommands`

### bgSave

    public void bgSave()

  Specified by:
    `bgSave` in interface `RedisServerCommands`

### bgWriteAof

    public void bgWriteAof()

  Specified by:
    `bgWriteAof` in interface `RedisServerCommands`

### bLPop

    public List<byte[]> bLPop(int timeout,
                              byte[]... keys)

  Specified by:
    `bLPop` in interface `RedisListCommands`

### bRPop

    public List<byte[]> bRPop(int timeout,
                              byte[]... keys)

  Specified by:
    `bRPop` in interface `RedisListCommands`

### bRPopLPush

    public byte[] bRPopLPush(int timeout,
                             byte[] srcKey,
                             byte[] dstKey)

  Specified by:
    `bRPopLPush` in interface `RedisListCommands`

### 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()

  Specified by:
    `dbSize` in interface `RedisServerCommands`

### decr

    public Long decr(byte[] key)

  Specified by:
    `decr` in interface `RedisStringCommands`

### decrBy

    public Long decrBy(byte[] key,
                       long value)

  Specified by:
    `decrBy` in interface `RedisStringCommands`

### del

    public Long del(byte[]... keys)

  Specified by:
    `del` in interface `RedisKeyCommands`

### discard

    public void discard()

  Specified by:
    `discard` in interface `RedisTxCommands`

### echo

    public byte[] echo(byte[] message)

  Specified by:
    `echo` in interface `RedisConnectionCommands`

### exec

    public List<Object> exec()

  Specified by:
    `exec` in interface `RedisTxCommands`

### exists

    public Boolean exists(byte[] key)

  Specified by:
    `exists` in interface `RedisKeyCommands`

### expire

    public Boolean expire(byte[] key,
                          long seconds)

  Specified by:
    `expire` in interface `RedisKeyCommands`

### expireAt

    public Boolean expireAt(byte[] key,
                            long unixTime)

  Specified by:
    `expireAt` in interface `RedisKeyCommands`

### flushAll

    public void flushAll()

  Specified by:
    `flushAll` in interface `RedisServerCommands`

### flushDb

    public void flushDb()

  Specified by:
    `flushDb` in interface `RedisServerCommands`

### get

    public byte[] get(byte[] key)

  Specified by:
    `get` in interface `RedisStringCommands`

### getBit

    public Boolean getBit(byte[] key,
                          long offset)

  Specified by:
    `getBit` in interface `RedisStringCommands`

### getConfig

    public List<String> getConfig(String pattern)

  Specified by:
    `getConfig` in interface `RedisServerCommands`

### 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)

  Specified by:
    `getRange` in interface `RedisStringCommands`

### getSet

    public byte[] getSet(byte[] key,
                         byte[] value)

  Specified by:
    `getSet` in interface `RedisStringCommands`

### 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)

  Specified by:
    `hDel` in interface `RedisHashCommands`

### hExists

    public Boolean hExists(byte[] key,
                           byte[] field)

  Specified by:
    `hExists` in interface `RedisHashCommands`

### hGet

    public byte[] hGet(byte[] key,
                       byte[] field)

  Specified by:
    `hGet` in interface `RedisHashCommands`

### hGetAll

    public Map<byte[],byte[]> hGetAll(byte[] key)

  Specified by:
    `hGetAll` in interface `RedisHashCommands`

### hIncrBy

    public Long hIncrBy(byte[] key,
                        byte[] field,
                        long delta)

  Specified by:
    `hIncrBy` in interface `RedisHashCommands`

### hIncrBy

    public Double hIncrBy(byte[] key,
                          byte[] field,
                          double delta)

  Specified by:
    `hIncrBy` in interface `RedisHashCommands`

### hKeys

    public Set<byte[]> hKeys(byte[] key)

  Specified by:
    `hKeys` in interface `RedisHashCommands`

### hLen

    public Long hLen(byte[] key)

  Specified by:
    `hLen` in interface `RedisHashCommands`

### hMGet

    public List<byte[]> hMGet(byte[] key,
                              byte[]... fields)

  Specified by:
    `hMGet` in interface `RedisHashCommands`

### hMSet

    public void hMSet(byte[] key,
                      Map<byte[],byte[]> hashes)

  Specified by:
    `hMSet` in interface `RedisHashCommands`

### hSet

    public Boolean hSet(byte[] key,
                        byte[] field,
                        byte[] value)

  Specified by:
    `hSet` in interface `RedisHashCommands`

### hSetNX

    public Boolean hSetNX(byte[] key,
                          byte[] field,
                          byte[] value)

  Specified by:
    `hSetNX` in interface `RedisHashCommands`

### hVals

    public List<byte[]> hVals(byte[] key)

  Specified by:
    `hVals` in interface `RedisHashCommands`

### incr

    public Long incr(byte[] key)

  Specified by:
    `incr` in interface `RedisStringCommands`

### incrBy

    public Long incrBy(byte[] key,
                       long value)

  Specified by:
    `incrBy` in interface `RedisStringCommands`

### incrBy

    public Double incrBy(byte[] key,
                         double value)

  Specified by:
    `incrBy` in interface `RedisStringCommands`

### info

    public Properties info()

  Specified by:
    `info` in interface `RedisServerCommands`

### info

    public Properties info(String section)

  Specified by:
    `info` in interface `RedisServerCommands`

### 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)

  Specified by:
    `keys` in interface `RedisKeyCommands`

### lastSave

    public Long lastSave()

  Specified by:
    `lastSave` in interface `RedisServerCommands`

### lIndex

    public byte[] lIndex(byte[] key,
                         long index)

  Specified by:
    `lIndex` in interface `RedisListCommands`

### lInsert

    public Long lInsert(byte[] key,
                        RedisListCommands.Position where,
                        byte[] pivot,
                        byte[] value)

  Specified by:
    `lInsert` in interface `RedisListCommands`

### lLen

    public Long lLen(byte[] key)

  Specified by:
    `lLen` in interface `RedisListCommands`

### lPop

    public byte[] lPop(byte[] key)

  Specified by:
    `lPop` in interface `RedisListCommands`

### lPush

    public Long lPush(byte[] key,
                      byte[]... values)

  Specified by:
    `lPush` in interface `RedisListCommands`

### lPushX

    public Long lPushX(byte[] key,
                       byte[] value)

  Specified by:
    `lPushX` in interface `RedisListCommands`

### lRange

    public List<byte[]> lRange(byte[] key,
                               long start,
                               long end)

  Specified by:
    `lRange` in interface `RedisListCommands`

### lRem

    public Long lRem(byte[] key,
                     long count,
                     byte[] value)

  Specified by:
    `lRem` in interface `RedisListCommands`

### lSet

    public void lSet(byte[] key,
                     long index,
                     byte[] value)

  Specified by:
    `lSet` in interface `RedisListCommands`

### lTrim

    public void lTrim(byte[] key,
                      long start,
                      long end)

  Specified by:
    `lTrim` in interface `RedisListCommands`

### mGet

    public List<byte[]> mGet(byte[]... keys)

  Specified by:
    `mGet` in interface `RedisStringCommands`

### mSet

    public void mSet(Map<byte[],byte[]> tuple)

  Specified by:
    `mSet` in interface `RedisStringCommands`

### mSetNX

    public Boolean mSetNX(Map<byte[],byte[]> tuple)

  Specified by:
    `mSetNX` in interface `RedisStringCommands`

### multi

    public void multi()

  Specified by:
    `multi` in interface `RedisTxCommands`

### persist

    public Boolean persist(byte[] key)

  Specified by:
    `persist` in interface `RedisKeyCommands`

### move

    public Boolean move(byte[] key,
                        int dbIndex)

  Specified by:
    `move` in interface `RedisKeyCommands`

### ping

    public String ping()

  Specified by:
    `ping` in interface `RedisConnectionCommands`

### 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()

  Specified by:
    `randomKey` in interface `RedisKeyCommands`

### rename

    public void rename(byte[] oldName,
                       byte[] newName)

  Specified by:
    `rename` in interface `RedisKeyCommands`

### renameNX

    public Boolean renameNX(byte[] oldName,
                            byte[] newName)

  Specified by:
    `renameNX` in interface `RedisKeyCommands`

### resetConfigStats

    public void resetConfigStats()

  Specified by:
    `resetConfigStats` in interface `RedisServerCommands`

### rPop

    public byte[] rPop(byte[] key)

  Specified by:
    `rPop` in interface `RedisListCommands`

### rPopLPush

    public byte[] rPopLPush(byte[] srcKey,
                            byte[] dstKey)

  Specified by:
    `rPopLPush` in interface `RedisListCommands`

### rPush

    public Long rPush(byte[] key,
                      byte[]... values)

  Specified by:
    `rPush` in interface `RedisListCommands`

### rPushX

    public Long rPushX(byte[] key,
                       byte[] value)

  Specified by:
    `rPushX` in interface `RedisListCommands`

### sAdd

    public Long sAdd(byte[] key,
                     byte[]... values)

  Specified by:
    `sAdd` in interface `RedisSetCommands`

### save

    public void save()

  Specified by:
    `save` in interface `RedisServerCommands`

### sCard

    public Long sCard(byte[] key)

  Specified by:
    `sCard` in interface `RedisSetCommands`

### sDiff

    public Set<byte[]> sDiff(byte[]... keys)

  Specified by:
    `sDiff` in interface `RedisSetCommands`

### sDiffStore

    public Long sDiffStore(byte[] destKey,
                           byte[]... keys)

  Specified by:
    `sDiffStore` in interface `RedisSetCommands`

### select

    public void select(int dbIndex)

  Specified by:
    `select` in interface `RedisConnectionCommands`

### set

    public void set(byte[] key,
                    byte[] value)

  Specified by:
    `set` in interface `RedisStringCommands`

### setBit

    public void setBit(byte[] key,
                       long offset,
                       boolean value)

  Specified by:
    `setBit` in interface `RedisStringCommands`

### setConfig

    public void setConfig(String param,
                          String value)

  Specified by:
    `setConfig` in interface `RedisServerCommands`

### setEx

    public void setEx(byte[] key,
                      long seconds,
                      byte[] value)

  Specified by:
    `setEx` in interface `RedisStringCommands`

### setNX

    public Boolean setNX(byte[] key,
                         byte[] value)

  Specified by:
    `setNX` in interface `RedisStringCommands`

### setRange

    public void setRange(byte[] key,
                         byte[] value,
                         long start)

  Specified by:
    `setRange` in interface `RedisStringCommands`

### shutdown

    public void shutdown()

  Specified by:
    `shutdown` in interface `RedisServerCommands`

### sInter

    public Set<byte[]> sInter(byte[]... keys)

  Specified by:
    `sInter` in interface `RedisSetCommands`

### sInterStore

    public Long sInterStore(byte[] destKey,
                            byte[]... keys)

  Specified by:
    `sInterStore` in interface `RedisSetCommands`

### sIsMember

    public Boolean sIsMember(byte[] key,
                             byte[] value)

  Specified by:
    `sIsMember` in interface `RedisSetCommands`

### sMembers

    public Set<byte[]> sMembers(byte[] key)

  Specified by:
    `sMembers` in interface `RedisSetCommands`

### sMove

    public Boolean sMove(byte[] srcKey,
                         byte[] destKey,
                         byte[] value)

  Specified by:
    `sMove` in interface `RedisSetCommands`

### sort

    public Long sort(byte[] key,
                     SortParameters params,
                     byte[] storeKey)

  Specified by:
    `sort` in interface `RedisKeyCommands`

### sort

    public List<byte[]> sort(byte[] key,
                             SortParameters params)

  Specified by:
    `sort` in interface `RedisKeyCommands`

### sPop

    public byte[] sPop(byte[] key)

  Specified by:
    `sPop` in interface `RedisSetCommands`

### sRandMember

    public byte[] sRandMember(byte[] key)

  Specified by:
    `sRandMember` in interface `RedisSetCommands`

### sRandMember

    public List<byte[]> sRandMember(byte[] key,
                                    long count)

  Specified by:
    `sRandMember` in interface `RedisSetCommands`

### sRem

    public Long sRem(byte[] key,
                     byte[]... values)

  Specified by:
    `sRem` in interface `RedisSetCommands`

### strLen

    public Long strLen(byte[] key)

  Specified by:
    `strLen` in interface `RedisStringCommands`

### bitCount

    public Long bitCount(byte[] key)

  Specified by:
    `bitCount` in interface `RedisStringCommands`

### bitCount

    public Long bitCount(byte[] key,
                         long begin,
                         long end)

  Specified by:
    `bitCount` in interface `RedisStringCommands`

### bitOp

    public Long bitOp(RedisStringCommands.BitOperation op,
                      byte[] destination,
                      byte[]... keys)

  Specified by:
    `bitOp` in interface `RedisStringCommands`

### 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)

  Specified by:
    `sUnion` in interface `RedisSetCommands`

### sUnionStore

    public Long sUnionStore(byte[] destKey,
                            byte[]... keys)

  Specified by:
    `sUnionStore` in interface `RedisSetCommands`

### ttl

    public Long ttl(byte[] key)

  Specified by:
    `ttl` in interface `RedisKeyCommands`

### type

    public DataType type(byte[] key)

  Specified by:
    `type` in interface `RedisKeyCommands`

### unwatch

    public void unwatch()

  Specified by:
    `unwatch` in interface `RedisTxCommands`

### watch

    public void watch(byte[]... keys)

  Specified by:
    `watch` in interface `RedisTxCommands`

### zAdd

    public Boolean zAdd(byte[] key,
                        double score,
                        byte[] value)

  Specified by:
    `zAdd` in interface `RedisZSetCommands`

### zAdd

    public Long zAdd(byte[] key,
                     Set<RedisZSetCommands.Tuple> tuples)

  Specified by:
    `zAdd` in interface `RedisZSetCommands`

### zCard

    public Long zCard(byte[] key)

  Specified by:
    `zCard` in interface `RedisZSetCommands`

### zCount

    public Long zCount(byte[] key,
                       double min,
                       double max)

  Specified by:
    `zCount` in interface `RedisZSetCommands`

### zIncrBy

    public Double zIncrBy(byte[] key,
                          double increment,
                          byte[] value)

  Specified by:
    `zIncrBy` in interface `RedisZSetCommands`

### zInterStore

    public Long zInterStore(byte[] destKey,
                            RedisZSetCommands.Aggregate aggregate,
                            int[] weights,
                            byte[]... sets)

  Specified by:
    `zInterStore` in interface `RedisZSetCommands`

### zInterStore

    public Long zInterStore(byte[] destKey,
                            byte[]... sets)

  Specified by:
    `zInterStore` in interface `RedisZSetCommands`

### zRange

    public Set<byte[]> zRange(byte[] key,
                              long start,
                              long end)

  Specified by:
    `zRange` in interface `RedisZSetCommands`

### zRangeByScore

    public Set<byte[]> zRangeByScore(byte[] key,
                                     double min,
                                     double max,
                                     long offset,
                                     long count)

  Specified by:
    `zRangeByScore` in interface `RedisZSetCommands`

### zRangeByScore

    public Set<byte[]> zRangeByScore(byte[] key,
                                     double min,
                                     double max)

  Specified by:
    `zRangeByScore` in interface `RedisZSetCommands`

### zRangeByScoreWithScores

    public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                                double min,
                                                                double max,
                                                                long offset,
                                                                long count)

  Specified by:
    `zRangeByScoreWithScores` in interface `RedisZSetCommands`

### zRangeByScoreWithScores

    public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                                double min,
                                                                double max)

  Specified by:
    `zRangeByScoreWithScores` in interface `RedisZSetCommands`

### zRangeWithScores

    public Set<RedisZSetCommands.Tuple> zRangeWithScores(byte[] key,
                                                         long start,
                                                         long end)

  Specified by:
    `zRangeWithScores` in interface `RedisZSetCommands`

### zRevRangeByScore

    public Set<byte[]> zRevRangeByScore(byte[] key,
                                        double min,
                                        double max,
                                        long offset,
                                        long count)

  Specified by:
    `zRevRangeByScore` in interface `RedisZSetCommands`

### zRevRangeByScore

    public Set<byte[]> zRevRangeByScore(byte[] key,
                                        double min,
                                        double max)

  Specified by:
    `zRevRangeByScore` in interface `RedisZSetCommands`

### zRevRangeByScoreWithScores

    public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                   double min,
                                                                   double max,
                                                                   long offset,
                                                                   long count)

  Specified by:
    `zRevRangeByScoreWithScores` in interface `RedisZSetCommands`

### zRevRangeByScoreWithScores

    public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                   double min,
                                                                   double max)

  Specified by:
    `zRevRangeByScoreWithScores` in interface `RedisZSetCommands`

### zRank

    public Long zRank(byte[] key,
                      byte[] value)

  Specified by:
    `zRank` in interface `RedisZSetCommands`

### zRem

    public Long zRem(byte[] key,
                     byte[]... values)

  Specified by:
    `zRem` in interface `RedisZSetCommands`

### zRemRange

    public Long zRemRange(byte[] key,
                          long start,
                          long end)

  Specified by:
    `zRemRange` in interface `RedisZSetCommands`

### zRemRangeByScore

    public Long zRemRangeByScore(byte[] key,
                                 double min,
                                 double max)

  Specified by:
    `zRemRangeByScore` in interface `RedisZSetCommands`

### zRevRange

    public Set<byte[]> zRevRange(byte[] key,
                                 long start,
                                 long end)

  Specified by:
    `zRevRange` in interface `RedisZSetCommands`

### zRevRangeWithScores

    public Set<RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key,
                                                            long start,
                                                            long end)

  Specified by:
    `zRevRangeWithScores` in interface `RedisZSetCommands`

### zRevRank

    public Long zRevRank(byte[] key,
                         byte[] value)

  Specified by:
    `zRevRank` in interface `RedisZSetCommands`

### zScore

    public Double zScore(byte[] key,
                         byte[] value)

  Specified by:
    `zScore` in interface `RedisZSetCommands`

### zUnionStore

    public Long zUnionStore(byte[] destKey,
                            RedisZSetCommands.Aggregate aggregate,
                            int[] weights,
                            byte[]... sets)

  Specified by:
    `zUnionStore` in interface `RedisZSetCommands`

### zUnionStore

    public Long zUnionStore(byte[] destKey,
                            byte[]... sets)

  Specified by:
    `zUnionStore` in interface `RedisZSetCommands`

### pExpire

    public Boolean pExpire(byte[] key,
                           long millis)

  Specified by:
    `pExpire` in interface `RedisKeyCommands`

### pExpireAt

    public Boolean pExpireAt(byte[] key,
                             long unixTimeInMillis)

  Specified by:
    `pExpireAt` in interface `RedisKeyCommands`

### pTtl

    public Long pTtl(byte[] key)

  Specified by:
    `pTtl` in interface `RedisKeyCommands`

### dump

    public byte[] dump(byte[] key)

  Specified by:
    `dump` in interface `RedisKeyCommands`

### restore

    public void restore(byte[] key,
                        long ttlInMillis,
                        byte[] serializedValue)

  Specified by:
    `restore` in interface `RedisKeyCommands`

### scriptFlush

    public void scriptFlush()

  Specified by:
    `scriptFlush` in interface `RedisScriptingCommands`

### scriptKill

    public void scriptKill()

  Specified by:
    `scriptKill` in interface `RedisScriptingCommands`

### scriptLoad

    public String scriptLoad(byte[] script)

  Specified by:
    `scriptLoad` in interface `RedisScriptingCommands`

### scriptExists

    public List<Boolean> scriptExists(String... scriptSha1)

  Specified by:
    `scriptExists` in interface `RedisScriptingCommands`

### eval

    public <T> T eval(byte[] script,
                      ReturnType returnType,
                      int numKeys,
                      byte[]... keysAndArgs)

  Specified by:
    `eval` in interface `RedisScriptingCommands`

### evalSha

    public <T> T evalSha(String scriptSha1,
                         ReturnType returnType,
                         int numKeys,
                         byte[]... keysAndArgs)

  Specified by:
    `evalSha` in interface `RedisScriptingCommands`

### append

    public Long append(String key,
                       String value)

  Specified by:
    `append` in interface `StringRedisConnection`

### 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)

  Specified by:
    `decr` in interface `StringRedisConnection`

### decrBy

    public Long decrBy(String key,
                       long value)

  Specified by:
    `decrBy` in interface `StringRedisConnection`

### del

    public Long del(String... keys)

  Specified by:
    `del` in interface `StringRedisConnection`

### echo

    public String echo(String message)

  Specified by:
    `echo` in interface `StringRedisConnection`

### exists

    public Boolean exists(String key)

  Specified by:
    `exists` in interface `StringRedisConnection`

### expire

    public Boolean expire(String key,
                          long seconds)

  Specified by:
    `expire` in interface `StringRedisConnection`

### expireAt

    public Boolean expireAt(String key,
                            long unixTime)

  Specified by:
    `expireAt` in interface `StringRedisConnection`

### get

    public String get(String key)

  Specified by:
    `get` in interface `StringRedisConnection`

### getBit

    public Boolean getBit(String key,
                          long offset)

  Specified by:
    `getBit` in interface `StringRedisConnection`

### getRange

    public String getRange(String key,
                           long start,
                           long end)

  Specified by:
    `getRange` in interface `StringRedisConnection`

### getSet

    public String getSet(String key,
                         String value)

  Specified by:
    `getSet` in interface `StringRedisConnection`

### 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)

  Specified by:
    `incr` in interface `StringRedisConnection`

### incrBy

    public Long incrBy(String key,
                       long value)

  Specified by:
    `incrBy` in interface `StringRedisConnection`

### incrBy

    public Double incrBy(String key,
                         double value)

  Specified by:
    `incrBy` in interface `StringRedisConnection`

### keys

    public Collection<String> keys(String pattern)

  Specified by:
    `keys` in interface `StringRedisConnection`

### 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)

  Specified by:
    `mGet` in interface `StringRedisConnection`

### mSetNXString

    public Boolean mSetNXString(Map<String,String> tuple)

  Specified by:
    `mSetNXString` in interface `StringRedisConnection`

### mSetString

    public void mSetString(Map<String,String> tuple)

  Specified by:
    `mSetString` in interface `StringRedisConnection`

### persist

    public Boolean persist(String key)

  Specified by:
    `persist` in interface `StringRedisConnection`

### move

    public Boolean move(String key,
                        int dbIndex)

  Specified by:
    `move` in interface `StringRedisConnection`

### 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)

  Specified by:
    `rename` in interface `StringRedisConnection`

### renameNX

    public Boolean renameNX(String oldName,
                            String newName)

  Specified by:
    `renameNX` in interface `StringRedisConnection`

### 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)

  Specified by:
    `set` in interface `StringRedisConnection`

### setBit

    public void setBit(String key,
                       long offset,
                       boolean value)

  Specified by:
    `setBit` in interface `StringRedisConnection`

### setEx

    public void setEx(String key,
                      long seconds,
                      String value)

  Specified by:
    `setEx` in interface `StringRedisConnection`

### setNX

    public Boolean setNX(String key,
                         String value)

  Specified by:
    `setNX` in interface `StringRedisConnection`

### setRange

    public void setRange(String key,
                         String value,
                         long start)

  Specified by:
    `setRange` in interface `StringRedisConnection`

### 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)

  Specified by:
    `strLen` in interface `StringRedisConnection`

### bitCount

    public Long bitCount(String key)

  Specified by:
    `bitCount` in interface `StringRedisConnection`

### bitCount

    public Long bitCount(String key,
                         long begin,
                         long end)

  Specified by:
    `bitCount` in interface `StringRedisConnection`

### bitOp

    public Long bitOp(RedisStringCommands.BitOperation op,
                      String destination,
                      String... keys)

  Specified by:
    `bitOp` in interface `StringRedisConnection`

### 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)

  Specified by:
    `ttl` in interface `StringRedisConnection`

### type

    public DataType type(String key)

  Specified by:
    `type` in interface `StringRedisConnection`

### 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`

### 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)

  Specified by:
    `pExpire` in interface `StringRedisConnection`

### pExpireAt

    public Boolean pExpireAt(String key,
                             long unixTimeInMillis)

  Specified by:
    `pExpireAt` in interface `StringRedisConnection`

### pTtl

    public Long pTtl(String key)

  Specified by:
    `pTtl` in interface `StringRedisConnection`

### 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`

### 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

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD