TracingRedisConnection (OpenTracing Instrumentation for Spring Data Redis 2.x 0.1.2 API)

java.lang.Object
- io.opentracing.contrib.redis.spring.data2.connection.TracingRedisConnection

All Implemented Interfaces:

org.springframework.data.redis.connection.RedisCommands, org.springframework.data.redis.connection.RedisConnection, org.springframework.data.redis.connection.RedisConnectionCommands, org.springframework.data.redis.connection.RedisGeoCommands, org.springframework.data.redis.connection.RedisHashCommands, org.springframework.data.redis.connection.RedisHyperLogLogCommands, org.springframework.data.redis.connection.RedisKeyCommands, org.springframework.data.redis.connection.RedisListCommands, org.springframework.data.redis.connection.RedisPubSubCommands, org.springframework.data.redis.connection.RedisScriptingCommands, org.springframework.data.redis.connection.RedisServerCommands, org.springframework.data.redis.connection.RedisSetCommands, org.springframework.data.redis.connection.RedisStringCommands, org.springframework.data.redis.connection.RedisTxCommands, org.springframework.data.redis.connection.RedisZSetCommands

Direct Known Subclasses:

TracingRedisClusterConnection
```
public class TracingRedisConnection
extends Object
implements org.springframework.data.redis.connection.RedisConnection
```
OpenTracing instrumentation of a RedisConnection.

Author:

Daniel del Castillo

Nested Class Summary
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStringCommands
  org.springframework.data.redis.connection.RedisStringCommands.BitOperation, org.springframework.data.redis.connection.RedisStringCommands.SetOption
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisListCommands
  org.springframework.data.redis.connection.RedisListCommands.Position
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisZSetCommands
  org.springframework.data.redis.connection.RedisZSetCommands.Aggregate, org.springframework.data.redis.connection.RedisZSetCommands.Limit, org.springframework.data.redis.connection.RedisZSetCommands.Range, org.springframework.data.redis.connection.RedisZSetCommands.Tuple, org.springframework.data.redis.connection.RedisZSetCommands.Weights
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisServerCommands
  org.springframework.data.redis.connection.RedisServerCommands.MigrateOption, org.springframework.data.redis.connection.RedisServerCommands.ShutdownOption
- Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisGeoCommands
  org.springframework.data.redis.connection.RedisGeoCommands.DistanceUnit, org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<T>, org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs

Constructor Summary

Constructors
Constructor and Description
`TracingRedisConnection(org.springframework.data.redis.connection.RedisConnection connection, boolean withActiveSpanOnly, io.opentracing.Tracer tracer)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Long`	`append(byte[] key, byte[] value)`
`void`	`bgReWriteAof()`
`void`	`bgSave()`
`void`	`bgWriteAof()`
`Long`	`bitCount(byte[] key)`
`Long`	`bitCount(byte[] key, long begin, long end)`
`List<Long>`	`bitField(byte[] key, org.springframework.data.redis.connection.BitFieldSubCommands subCommands)`
`Long`	`bitOp(org.springframework.data.redis.connection.RedisStringCommands.BitOperation op, byte[] destination, byte[]... keys)`
`Long`	`bitPos(byte[] key, boolean bit, org.springframework.data.domain.Range<Long> range)`
`List<byte[]>`	`bLPop(int timeout, byte[]... keys)`
`List<byte[]>`	`bRPop(int timeout, byte[]... keys)`
`byte[]`	`bRPopLPush(int timeout, byte[] srcKey, byte[] dstKey)`
`void`	`close()`
`List<Object>`	`closePipeline()`
`Long`	`dbSize()`
`Long`	`decr(byte[] key)`
`Long`	`decrBy(byte[] key, long value)`
`Long`	`del(byte[]... keys)`
`void`	`discard()`
`byte[]`	`dump(byte[] key)`
`byte[]`	`echo(byte[] message)`
`org.springframework.data.redis.connection.ValueEncoding`	`encodingOf(byte[] key)`
`<T> T`	`eval(byte[] script, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)`
`<T> T`	`evalSha(byte[] scriptSha, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)`
`<T> T`	`evalSha(String scriptSha, org.springframework.data.redis.connection.ReturnType returnType, int numKeys, byte[]... keysAndArgs)`
`List<Object>`	`exec()`
`Object`	`execute(String command, byte[]... args)`
`Long`	`exists(byte[]... keys)`
`Boolean`	`exists(byte[] key)`
`Boolean`	`expire(byte[] key, long seconds)`
`Boolean`	`expireAt(byte[] key, long unixTime)`
`void`	`flushAll()`
`void`	`flushDb()`
`Long`	`geoAdd(byte[] key, Iterable<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> locations)`
`Long`	`geoAdd(byte[] key, Map<byte[],org.springframework.data.geo.Point> memberCoordinateMap)`
`Long`	`geoAdd(byte[] key, org.springframework.data.geo.Point point, byte[] member)`
`Long`	`geoAdd(byte[] key, org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]> location)`
`org.springframework.data.redis.connection.RedisGeoCommands`	`geoCommands()`
`org.springframework.data.geo.Distance`	`geoDist(byte[] key, byte[] member1, byte[] member2)`
`org.springframework.data.geo.Distance`	`geoDist(byte[] key, byte[] member1, byte[] member2, org.springframework.data.geo.Metric metric)`
`List<String>`	`geoHash(byte[] key, byte[]... members)`
`List<org.springframework.data.geo.Point>`	`geoPos(byte[] key, byte[]... members)`
`org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadius(byte[] key, org.springframework.data.geo.Circle within)`
`org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadius(byte[] key, org.springframework.data.geo.Circle within, org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs args)`
`org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, org.springframework.data.geo.Distance radius)`
`org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, org.springframework.data.geo.Distance radius, org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs args)`
`org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>>`	`geoRadiusByMember(byte[] key, byte[] member, double radius)`
`Long`	`geoRemove(byte[] key, byte[]... members)`
`byte[]`	`get(byte[] key)`
`Boolean`	`getBit(byte[] key, long offset)`
`List<org.springframework.data.redis.core.types.RedisClientInfo>`	`getClientList()`
`String`	`getClientName()`
`Properties`	`getConfig(String pattern)`
`Object`	`getNativeConnection()`
`byte[]`	`getRange(byte[] key, long begin, long end)`
`org.springframework.data.redis.connection.RedisSentinelConnection`	`getSentinelConnection()`
`byte[]`	`getSet(byte[] key, byte[] value)`
`org.springframework.data.redis.connection.Subscription`	`getSubscription()`
`org.springframework.data.redis.connection.RedisHashCommands`	`hashCommands()`
`Long`	`hDel(byte[] key, byte[]... fields)`
`Boolean`	`hExists(byte[] key, byte[] field)`
`byte[]`	`hGet(byte[] key, byte[] field)`
`Map<byte[],byte[]>`	`hGetAll(byte[] key)`
`Double`	`hIncrBy(byte[] key, byte[] field, double delta)`
`Long`	`hIncrBy(byte[] key, byte[] field, long delta)`
`Set<byte[]>`	`hKeys(byte[] key)`
`Long`	`hLen(byte[] key)`
`List<byte[]>`	`hMGet(byte[] key, byte[]... fields)`
`void`	`hMSet(byte[] key, Map<byte[],byte[]> hashes)`
`org.springframework.data.redis.core.Cursor<Map.Entry<byte[],byte[]>>`	`hScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)`
`Boolean`	`hSet(byte[] key, byte[] field, byte[] value)`
`Boolean`	`hSetNX(byte[] key, byte[] field, byte[] value)`
`Long`	`hStrLen(byte[] key, byte[] field)`
`List<byte[]>`	`hVals(byte[] key)`
`org.springframework.data.redis.connection.RedisHyperLogLogCommands`	`hyperLogLogCommands()`
`Duration`	`idletime(byte[] key)`
`Long`	`incr(byte[] key)`
`Double`	`incrBy(byte[] key, double value)`
`Long`	`incrBy(byte[] key, long value)`
`Properties`	`info()`
`Properties`	`info(String section)`
`boolean`	`isClosed()`
`boolean`	`isPipelined()`
`boolean`	`isQueueing()`
`boolean`	`isSubscribed()`
`org.springframework.data.redis.connection.RedisKeyCommands`	`keyCommands()`
`Set<byte[]>`	`keys(byte[] pattern)`
`void`	`killClient(String host, int port)`
`Long`	`lastSave()`
`byte[]`	`lIndex(byte[] key, long index)`
`Long`	`lInsert(byte[] key, org.springframework.data.redis.connection.RedisListCommands.Position where, byte[] pivot, byte[] value)`
`org.springframework.data.redis.connection.RedisListCommands`	`listCommands()`
`Long`	`lLen(byte[] key)`
`byte[]`	`lPop(byte[] key)`
`Long`	`lPush(byte[] key, byte[]... values)`
`Long`	`lPushX(byte[] key, byte[] value)`
`List<byte[]>`	`lRange(byte[] key, long start, long end)`
`Long`	`lRem(byte[] key, long count, byte[] value)`
`void`	`lSet(byte[] key, long index, byte[] value)`
`void`	`lTrim(byte[] key, long start, long end)`
`List<byte[]>`	`mGet(byte[]... keys)`
`void`	`migrate(byte[] key, org.springframework.data.redis.connection.RedisNode target, int dbIndex, org.springframework.data.redis.connection.RedisServerCommands.MigrateOption option)`
`void`	`migrate(byte[] key, org.springframework.data.redis.connection.RedisNode target, int dbIndex, org.springframework.data.redis.connection.RedisServerCommands.MigrateOption option, long timeout)`
`Boolean`	`move(byte[] key, int dbIndex)`
`Boolean`	`mSet(Map<byte[],byte[]> tuple)`
`Boolean`	`mSetNX(Map<byte[],byte[]> tuple)`
`void`	`multi()`
`void`	`openPipeline()`
`Boolean`	`persist(byte[] key)`
`Boolean`	`pExpire(byte[] key, long millis)`
`Boolean`	`pExpireAt(byte[] key, long unixTimeInMillis)`
`Long`	`pfAdd(byte[] key, byte[]... values)`
`Long`	`pfCount(byte[]... keys)`
`void`	`pfMerge(byte[] destinationKey, byte[]... sourceKeys)`
`String`	`ping()`
`Boolean`	`pSetEx(byte[] key, long milliseconds, byte[] value)`
`void`	`pSubscribe(org.springframework.data.redis.connection.MessageListener listener, byte[]... patterns)`
`Long`	`pTtl(byte[] key)`
`Long`	`pTtl(byte[] key, TimeUnit timeUnit)`
`Long`	`publish(byte[] channel, byte[] message)`
`byte[]`	`randomKey()`
`Long`	`refcount(byte[] key)`
`void`	`rename(byte[] oldName, byte[] newName)`
`Boolean`	`renameNX(byte[] oldName, byte[] newName)`
`void`	`resetConfigStats()`
`void`	`restore(byte[] key, long ttlInMillis, byte[] serializedValue)`
`void`	`restore(byte[] key, long ttlInMillis, byte[] serializedValue, boolean replace)`
`byte[]`	`rPop(byte[] key)`
`byte[]`	`rPopLPush(byte[] srcKey, byte[] dstKey)`
`Long`	`rPush(byte[] key, byte[]... values)`
`Long`	`rPushX(byte[] key, byte[] value)`
`Long`	`sAdd(byte[] key, byte[]... values)`
`void`	`save()`
`org.springframework.data.redis.core.Cursor<byte[]>`	`scan(org.springframework.data.redis.core.ScanOptions options)`
`Long`	`sCard(byte[] key)`
`List<Boolean>`	`scriptExists(String... scriptShas)`
`void`	`scriptFlush()`
`org.springframework.data.redis.connection.RedisScriptingCommands`	`scriptingCommands()`
`void`	`scriptKill()`
`String`	`scriptLoad(byte[] script)`
`Set<byte[]>`	`sDiff(byte[]... keys)`
`Long`	`sDiffStore(byte[] destKey, byte[]... keys)`
`void`	`select(int dbIndex)`
`org.springframework.data.redis.connection.RedisServerCommands`	`serverCommands()`
`Boolean`	`set(byte[] key, byte[] value)`
`Boolean`	`set(byte[] key, byte[] value, org.springframework.data.redis.core.types.Expiration expiration, org.springframework.data.redis.connection.RedisStringCommands.SetOption option)`
`Boolean`	`setBit(byte[] key, long offset, boolean value)`
`void`	`setClientName(byte[] name)`
`org.springframework.data.redis.connection.RedisSetCommands`	`setCommands()`
`void`	`setConfig(String param, String value)`
`Boolean`	`setEx(byte[] key, long seconds, byte[] value)`
`Boolean`	`setNX(byte[] key, byte[] value)`
`void`	`setRange(byte[] key, byte[] value, long offset)`
`void`	`shutdown()`
`void`	`shutdown(org.springframework.data.redis.connection.RedisServerCommands.ShutdownOption option)`
`Set<byte[]>`	`sInter(byte[]... keys)`
`Long`	`sInterStore(byte[] destKey, byte[]... keys)`
`Boolean`	`sIsMember(byte[] key, byte[] value)`
`void`	`slaveOf(String host, int port)`
`void`	`slaveOfNoOne()`
`Set<byte[]>`	`sMembers(byte[] key)`
`Boolean`	`sMove(byte[] srcKey, byte[] destKey, byte[] value)`
`List<byte[]>`	`sort(byte[] key, org.springframework.data.redis.connection.SortParameters params)`
`Long`	`sort(byte[] key, org.springframework.data.redis.connection.SortParameters params, byte[] storeKey)`
`byte[]`	`sPop(byte[] key)`
`List<byte[]>`	`sPop(byte[] key, long count)`
`byte[]`	`sRandMember(byte[] key)`
`List<byte[]>`	`sRandMember(byte[] key, long count)`
`Long`	`sRem(byte[] key, byte[]... values)`
`org.springframework.data.redis.core.Cursor<byte[]>`	`sScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)`
`org.springframework.data.redis.connection.RedisStringCommands`	`stringCommands()`
`Long`	`strLen(byte[] key)`
`void`	`subscribe(org.springframework.data.redis.connection.MessageListener listener, byte[]... channels)`
`Set<byte[]>`	`sUnion(byte[]... keys)`
`Long`	`sUnionStore(byte[] destKey, byte[]... keys)`
`Long`	`time()`
`Long`	`touch(byte[]... keys)`
`Long`	`ttl(byte[] key)`
`Long`	`ttl(byte[] key, TimeUnit timeUnit)`
`org.springframework.data.redis.connection.DataType`	`type(byte[] key)`
`Long`	`unlink(byte[]... keys)`
`void`	`unwatch()`
`void`	`watch(byte[]... keys)`
`Boolean`	`zAdd(byte[] key, double score, byte[] value)`
`Long`	`zAdd(byte[] key, Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> tuples)`
`Long`	`zCard(byte[] key)`
`Long`	`zCount(byte[] key, double min, double max)`
`Long`	`zCount(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range)`
`Double`	`zIncrBy(byte[] key, double increment, byte[] value)`
`Long`	`zInterStore(byte[] destKey, byte[]... sets)`
`Long`	`zInterStore(byte[] destKey, org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets)`
`Long`	`zInterStore(byte[] destKey, org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate, org.springframework.data.redis.connection.RedisZSetCommands.Weights weights, byte[]... sets)`
`Set<byte[]>`	`zRange(byte[] key, long start, long end)`
`Set<byte[]>`	`zRangeByLex(byte[] key)`
`Set<byte[]>`	`zRangeByLex(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range)`
`Set<byte[]>`	`zRangeByLex(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range, org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)`
`Set<byte[]>`	`zRangeByScore(byte[] key, double min, double max)`
`Set<byte[]>`	`zRangeByScore(byte[] key, double min, double max, long offset, long count)`
`Set<byte[]>`	`zRangeByScore(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range)`
`Set<byte[]>`	`zRangeByScore(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range, org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)`
`Set<byte[]>`	`zRangeByScore(byte[] key, String min, String max)`
`Set<byte[]>`	`zRangeByScore(byte[] key, String min, String max, long offset, long count)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, double min, double max)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRangeByScoreWithScores(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range, org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRangeWithScores(byte[] key, long start, long end)`
`Long`	`zRank(byte[] key, byte[] value)`
`Long`	`zRem(byte[] key, byte[]... values)`
`Long`	`zRemRange(byte[] key, long start, long end)`
`Long`	`zRemRangeByScore(byte[] key, double min, double max)`
`Long`	`zRemRangeByScore(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range)`
`Set<byte[]>`	`zRevRange(byte[] 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<byte[]>`	`zRevRangeByScore(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range)`
`Set<byte[]>`	`zRevRangeByScore(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range, org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRevRangeByScoreWithScores(byte[] key, double min, double max)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRevRangeByScoreWithScores(byte[] key, double min, double max, long offset, long count)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRevRangeByScoreWithScores(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRevRangeByScoreWithScores(byte[] key, org.springframework.data.redis.connection.RedisZSetCommands.Range range, org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)`
`Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zRevRangeWithScores(byte[] key, long start, long end)`
`Long`	`zRevRank(byte[] key, byte[] value)`
`org.springframework.data.redis.core.Cursor<org.springframework.data.redis.connection.RedisZSetCommands.Tuple>`	`zScan(byte[] key, org.springframework.data.redis.core.ScanOptions options)`
`Double`	`zScore(byte[] key, byte[] value)`
`org.springframework.data.redis.connection.RedisZSetCommands`	`zSetCommands()`
`Long`	`zUnionStore(byte[] destKey, byte[]... sets)`
`Long`	`zUnionStore(byte[] destKey, org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets)`
`Long`	`zUnionStore(byte[] destKey, org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate, org.springframework.data.redis.connection.RedisZSetCommands.Weights weights, byte[]... sets)`

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

Methods inherited from interface org.springframework.data.redis.connection.RedisStringCommands
bitPos

Constructor Detail

TracingRedisConnection

public TracingRedisConnection(org.springframework.data.redis.connection.RedisConnection connection,
                              boolean withActiveSpanOnly,
                              io.opentracing.Tracer tracer)

Method Detail

geoCommands
```
public org.springframework.data.redis.connection.RedisGeoCommands geoCommands()
```
Specified by:

geoCommands in interface org.springframework.data.redis.connection.RedisConnection

hashCommands
```
public org.springframework.data.redis.connection.RedisHashCommands hashCommands()
```
Specified by:

hashCommands in interface org.springframework.data.redis.connection.RedisConnection

hyperLogLogCommands
```
public org.springframework.data.redis.connection.RedisHyperLogLogCommands hyperLogLogCommands()
```
Specified by:

hyperLogLogCommands in interface org.springframework.data.redis.connection.RedisConnection

keyCommands
```
public org.springframework.data.redis.connection.RedisKeyCommands keyCommands()
```
Specified by:

keyCommands in interface org.springframework.data.redis.connection.RedisConnection

listCommands
```
public org.springframework.data.redis.connection.RedisListCommands listCommands()
```
Specified by:

listCommands in interface org.springframework.data.redis.connection.RedisConnection

setCommands
```
public org.springframework.data.redis.connection.RedisSetCommands setCommands()
```
Specified by:

setCommands in interface org.springframework.data.redis.connection.RedisConnection

scriptingCommands
```
public org.springframework.data.redis.connection.RedisScriptingCommands scriptingCommands()
```
Specified by:

scriptingCommands in interface org.springframework.data.redis.connection.RedisConnection

serverCommands
```
public org.springframework.data.redis.connection.RedisServerCommands serverCommands()
```
Specified by:

serverCommands in interface org.springframework.data.redis.connection.RedisConnection

stringCommands
```
public org.springframework.data.redis.connection.RedisStringCommands stringCommands()
```
Specified by:

stringCommands in interface org.springframework.data.redis.connection.RedisConnection

zSetCommands
```
public org.springframework.data.redis.connection.RedisZSetCommands zSetCommands()
```
Specified by:

zSetCommands in interface org.springframework.data.redis.connection.RedisConnection

close
```
public void close()
           throws org.springframework.dao.DataAccessException
```
Specified by:

close in interface org.springframework.data.redis.connection.RedisConnection

Throws:

org.springframework.dao.DataAccessException

isClosed
```
public boolean isClosed()
```
Specified by:

isClosed in interface org.springframework.data.redis.connection.RedisConnection

getNativeConnection
```
public Object getNativeConnection()
```
Specified by:

getNativeConnection in interface org.springframework.data.redis.connection.RedisConnection

isQueueing
```
public boolean isQueueing()
```
Specified by:

isQueueing in interface org.springframework.data.redis.connection.RedisConnection

isPipelined
```
public boolean isPipelined()
```
Specified by:

isPipelined in interface org.springframework.data.redis.connection.RedisConnection

openPipeline
```
public void openPipeline()
```
Specified by:

openPipeline in interface org.springframework.data.redis.connection.RedisConnection

closePipeline
```
public List<Object> closePipeline()
                           throws org.springframework.data.redis.connection.RedisPipelineException
```
Specified by:

closePipeline in interface org.springframework.data.redis.connection.RedisConnection

Throws:

org.springframework.data.redis.connection.RedisPipelineException

isSubscribed
```
public boolean isSubscribed()
```
Specified by:

isSubscribed in interface org.springframework.data.redis.connection.RedisPubSubCommands

getSubscription
```
public org.springframework.data.redis.connection.Subscription getSubscription()
```
Specified by:

getSubscription in interface org.springframework.data.redis.connection.RedisPubSubCommands

getSentinelConnection
```
public org.springframework.data.redis.connection.RedisSentinelConnection getSentinelConnection()
```
Specified by:

getSentinelConnection in interface org.springframework.data.redis.connection.RedisConnection

execute
```
public Object execute(String command,
                      byte[]... args)
```
Specified by:

execute in interface org.springframework.data.redis.connection.RedisCommands

exists
```
public Boolean exists(byte[] key)
```
Specified by:

exists in interface org.springframework.data.redis.connection.RedisKeyCommands

exists
```
public Long exists(byte[]... keys)
```
Specified by:

exists in interface org.springframework.data.redis.connection.RedisKeyCommands

del
```
public Long del(byte[]... keys)
```
Specified by:

del in interface org.springframework.data.redis.connection.RedisKeyCommands

unlink
```
public Long unlink(byte[]... keys)
```
Specified by:

unlink in interface org.springframework.data.redis.connection.RedisKeyCommands

type
```
public org.springframework.data.redis.connection.DataType type(byte[] key)
```
Specified by:

type in interface org.springframework.data.redis.connection.RedisKeyCommands

touch
```
public Long touch(byte[]... keys)
```
Specified by:

touch in interface org.springframework.data.redis.connection.RedisKeyCommands

keys
```
public Set<byte[]> keys(byte[] pattern)
```
Specified by:

keys in interface org.springframework.data.redis.connection.RedisKeyCommands

scan

public org.springframework.data.redis.core.Cursor<byte[]> scan(org.springframework.data.redis.core.ScanOptions options)

Specified by:: scan in interface org.springframework.data.redis.connection.RedisKeyCommands

randomKey
```
public byte[] randomKey()
```
Specified by:

randomKey in interface org.springframework.data.redis.connection.RedisKeyCommands

rename
```
public void rename(byte[] oldName,
                   byte[] newName)
```
Specified by:

rename in interface org.springframework.data.redis.connection.RedisKeyCommands

renameNX
```
public Boolean renameNX(byte[] oldName,
                        byte[] newName)
```
Specified by:

renameNX in interface org.springframework.data.redis.connection.RedisKeyCommands

expire
```
public Boolean expire(byte[] key,
                      long seconds)
```
Specified by:

expire in interface org.springframework.data.redis.connection.RedisKeyCommands

pExpire
```
public Boolean pExpire(byte[] key,
                       long millis)
```
Specified by:

pExpire in interface org.springframework.data.redis.connection.RedisKeyCommands

expireAt
```
public Boolean expireAt(byte[] key,
                        long unixTime)
```
Specified by:

expireAt in interface org.springframework.data.redis.connection.RedisKeyCommands

pExpireAt
```
public Boolean pExpireAt(byte[] key,
                         long unixTimeInMillis)
```
Specified by:

pExpireAt in interface org.springframework.data.redis.connection.RedisKeyCommands

persist
```
public Boolean persist(byte[] key)
```
Specified by:

persist in interface org.springframework.data.redis.connection.RedisKeyCommands

move
```
public Boolean move(byte[] key,
                    int dbIndex)
```
Specified by:

move in interface org.springframework.data.redis.connection.RedisKeyCommands

ttl
```
public Long ttl(byte[] key)
```
Specified by:

ttl in interface org.springframework.data.redis.connection.RedisKeyCommands

ttl

public Long ttl(byte[] key,
                TimeUnit timeUnit)

Specified by:: ttl in interface org.springframework.data.redis.connection.RedisKeyCommands

pTtl
```
public Long pTtl(byte[] key)
```
Specified by:

pTtl in interface org.springframework.data.redis.connection.RedisKeyCommands

pTtl

public Long pTtl(byte[] key,
                 TimeUnit timeUnit)

Specified by:: pTtl in interface org.springframework.data.redis.connection.RedisKeyCommands

sort

public List<byte[]> sort(byte[] key,
                         org.springframework.data.redis.connection.SortParameters params)

Specified by:: sort in interface org.springframework.data.redis.connection.RedisKeyCommands

sort

public Long sort(byte[] key,
                 org.springframework.data.redis.connection.SortParameters params,
                 byte[] storeKey)

Specified by:: sort in interface org.springframework.data.redis.connection.RedisKeyCommands

dump
```
public byte[] dump(byte[] key)
```
Specified by:

dump in interface org.springframework.data.redis.connection.RedisKeyCommands

restore

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

Specified by:: restore in interface org.springframework.data.redis.connection.RedisKeyCommands

restore

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

Specified by:: restore in interface org.springframework.data.redis.connection.RedisKeyCommands

encodingOf
```
public org.springframework.data.redis.connection.ValueEncoding encodingOf(byte[] key)
```
Specified by:

encodingOf in interface org.springframework.data.redis.connection.RedisKeyCommands

idletime
```
public Duration idletime(byte[] key)
```
Specified by:

idletime in interface org.springframework.data.redis.connection.RedisKeyCommands

refcount
```
public Long refcount(byte[] key)
```
Specified by:

refcount in interface org.springframework.data.redis.connection.RedisKeyCommands

get
```
public byte[] get(byte[] key)
```
Specified by:

get in interface org.springframework.data.redis.connection.RedisStringCommands

getSet
```
public byte[] getSet(byte[] key,
                     byte[] value)
```
Specified by:

getSet in interface org.springframework.data.redis.connection.RedisStringCommands

mGet
```
public List<byte[]> mGet(byte[]... keys)
```
Specified by:

mGet in interface org.springframework.data.redis.connection.RedisStringCommands

set
```
public Boolean set(byte[] key,
                   byte[] value)
```
Specified by:

set in interface org.springframework.data.redis.connection.RedisStringCommands

set

public Boolean set(byte[] key,
                   byte[] value,
                   org.springframework.data.redis.core.types.Expiration expiration,
                   org.springframework.data.redis.connection.RedisStringCommands.SetOption option)

Specified by:: set in interface org.springframework.data.redis.connection.RedisStringCommands

setNX
```
public Boolean setNX(byte[] key,
                     byte[] value)
```
Specified by:

setNX in interface org.springframework.data.redis.connection.RedisStringCommands

setEx

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

Specified by:: setEx in interface org.springframework.data.redis.connection.RedisStringCommands

pSetEx

public Boolean pSetEx(byte[] key,
                      long milliseconds,
                      byte[] value)

Specified by:: pSetEx in interface org.springframework.data.redis.connection.RedisStringCommands

mSet
```
public Boolean mSet(Map<byte[],byte[]> tuple)
```
Specified by:

mSet in interface org.springframework.data.redis.connection.RedisStringCommands

mSetNX
```
public Boolean mSetNX(Map<byte[],byte[]> tuple)
```
Specified by:

mSetNX in interface org.springframework.data.redis.connection.RedisStringCommands

incr
```
public Long incr(byte[] key)
```
Specified by:

incr in interface org.springframework.data.redis.connection.RedisStringCommands

incrBy
```
public Long incrBy(byte[] key,
                   long value)
```
Specified by:

incrBy in interface org.springframework.data.redis.connection.RedisStringCommands

incrBy
```
public Double incrBy(byte[] key,
                     double value)
```
Specified by:

incrBy in interface org.springframework.data.redis.connection.RedisStringCommands

decr
```
public Long decr(byte[] key)
```
Specified by:

decr in interface org.springframework.data.redis.connection.RedisStringCommands

decrBy
```
public Long decrBy(byte[] key,
                   long value)
```
Specified by:

decrBy in interface org.springframework.data.redis.connection.RedisStringCommands

append
```
public Long append(byte[] key,
                   byte[] value)
```
Specified by:

append in interface org.springframework.data.redis.connection.RedisStringCommands

getRange

public byte[] getRange(byte[] key,
                       long begin,
                       long end)

Specified by:: getRange in interface org.springframework.data.redis.connection.RedisStringCommands

setRange

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

Specified by:: setRange in interface org.springframework.data.redis.connection.RedisStringCommands

getBit
```
public Boolean getBit(byte[] key,
                      long offset)
```
Specified by:

getBit in interface org.springframework.data.redis.connection.RedisStringCommands

setBit

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

Specified by:: setBit in interface org.springframework.data.redis.connection.RedisStringCommands

bitCount
```
public Long bitCount(byte[] key)
```
Specified by:

bitCount in interface org.springframework.data.redis.connection.RedisStringCommands

bitCount

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

Specified by:: bitCount in interface org.springframework.data.redis.connection.RedisStringCommands

bitField

public List<Long> bitField(byte[] key,
                           org.springframework.data.redis.connection.BitFieldSubCommands subCommands)

Specified by:: bitField in interface org.springframework.data.redis.connection.RedisStringCommands

bitOp

public Long bitOp(org.springframework.data.redis.connection.RedisStringCommands.BitOperation op,
                  byte[] destination,
                  byte[]... keys)

Specified by:: bitOp in interface org.springframework.data.redis.connection.RedisStringCommands

bitPos

public Long bitPos(byte[] key,
                   boolean bit,
                   org.springframework.data.domain.Range<Long> range)

Specified by:: bitPos in interface org.springframework.data.redis.connection.RedisStringCommands

strLen
```
public Long strLen(byte[] key)
```
Specified by:

strLen in interface org.springframework.data.redis.connection.RedisStringCommands

rPush
```
public Long rPush(byte[] key,
                  byte[]... values)
```
Specified by:

rPush in interface org.springframework.data.redis.connection.RedisListCommands

lPush
```
public Long lPush(byte[] key,
                  byte[]... values)
```
Specified by:

lPush in interface org.springframework.data.redis.connection.RedisListCommands

rPushX
```
public Long rPushX(byte[] key,
                   byte[] value)
```
Specified by:

rPushX in interface org.springframework.data.redis.connection.RedisListCommands

lPushX
```
public Long lPushX(byte[] key,
                   byte[] value)
```
Specified by:

lPushX in interface org.springframework.data.redis.connection.RedisListCommands

lLen
```
public Long lLen(byte[] key)
```
Specified by:

lLen in interface org.springframework.data.redis.connection.RedisListCommands

lRange

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

Specified by:: lRange in interface org.springframework.data.redis.connection.RedisListCommands

lTrim
```
public void lTrim(byte[] key,
                  long start,
                  long end)
```
Specified by:

lTrim in interface org.springframework.data.redis.connection.RedisListCommands

lIndex
```
public byte[] lIndex(byte[] key,
                     long index)
```
Specified by:

lIndex in interface org.springframework.data.redis.connection.RedisListCommands

lInsert

public Long lInsert(byte[] key,
                    org.springframework.data.redis.connection.RedisListCommands.Position where,
                    byte[] pivot,
                    byte[] value)

Specified by:: lInsert in interface org.springframework.data.redis.connection.RedisListCommands

lSet

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

Specified by:: lSet in interface org.springframework.data.redis.connection.RedisListCommands

lRem

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

Specified by:: lRem in interface org.springframework.data.redis.connection.RedisListCommands

lPop
```
public byte[] lPop(byte[] key)
```
Specified by:

lPop in interface org.springframework.data.redis.connection.RedisListCommands

rPop
```
public byte[] rPop(byte[] key)
```
Specified by:

rPop in interface org.springframework.data.redis.connection.RedisListCommands

bLPop
```
public List<byte[]> bLPop(int timeout,
                          byte[]... keys)
```
Specified by:

bLPop in interface org.springframework.data.redis.connection.RedisListCommands

bRPop
```
public List<byte[]> bRPop(int timeout,
                          byte[]... keys)
```
Specified by:

bRPop in interface org.springframework.data.redis.connection.RedisListCommands

rPopLPush
```
public byte[] rPopLPush(byte[] srcKey,
                        byte[] dstKey)
```
Specified by:

rPopLPush in interface org.springframework.data.redis.connection.RedisListCommands

bRPopLPush

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

Specified by:: bRPopLPush in interface org.springframework.data.redis.connection.RedisListCommands

sAdd
```
public Long sAdd(byte[] key,
                 byte[]... values)
```
Specified by:

sAdd in interface org.springframework.data.redis.connection.RedisSetCommands

sRem
```
public Long sRem(byte[] key,
                 byte[]... values)
```
Specified by:

sRem in interface org.springframework.data.redis.connection.RedisSetCommands

sPop
```
public byte[] sPop(byte[] key)
```
Specified by:

sPop in interface org.springframework.data.redis.connection.RedisSetCommands

sPop
```
public List<byte[]> sPop(byte[] key,
                         long count)
```
Specified by:

sPop in interface org.springframework.data.redis.connection.RedisSetCommands

sMove

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

Specified by:: sMove in interface org.springframework.data.redis.connection.RedisSetCommands

sCard
```
public Long sCard(byte[] key)
```
Specified by:

sCard in interface org.springframework.data.redis.connection.RedisSetCommands

sIsMember
```
public Boolean sIsMember(byte[] key,
                         byte[] value)
```
Specified by:

sIsMember in interface org.springframework.data.redis.connection.RedisSetCommands

sInter
```
public Set<byte[]> sInter(byte[]... keys)
```
Specified by:

sInter in interface org.springframework.data.redis.connection.RedisSetCommands

sInterStore
```
public Long sInterStore(byte[] destKey,
                        byte[]... keys)
```
Specified by:

sInterStore in interface org.springframework.data.redis.connection.RedisSetCommands

sUnion
```
public Set<byte[]> sUnion(byte[]... keys)
```
Specified by:

sUnion in interface org.springframework.data.redis.connection.RedisSetCommands

sUnionStore
```
public Long sUnionStore(byte[] destKey,
                        byte[]... keys)
```
Specified by:

sUnionStore in interface org.springframework.data.redis.connection.RedisSetCommands

sDiff
```
public Set<byte[]> sDiff(byte[]... keys)
```
Specified by:

sDiff in interface org.springframework.data.redis.connection.RedisSetCommands

sDiffStore
```
public Long sDiffStore(byte[] destKey,
                       byte[]... keys)
```
Specified by:

sDiffStore in interface org.springframework.data.redis.connection.RedisSetCommands

sMembers
```
public Set<byte[]> sMembers(byte[] key)
```
Specified by:

sMembers in interface org.springframework.data.redis.connection.RedisSetCommands

sRandMember
```
public byte[] sRandMember(byte[] key)
```
Specified by:

sRandMember in interface org.springframework.data.redis.connection.RedisSetCommands

sRandMember
```
public List<byte[]> sRandMember(byte[] key,
                                long count)
```
Specified by:

sRandMember in interface org.springframework.data.redis.connection.RedisSetCommands

sScan

public org.springframework.data.redis.core.Cursor<byte[]> sScan(byte[] key,
                                                                org.springframework.data.redis.core.ScanOptions options)

Specified by:: sScan in interface org.springframework.data.redis.connection.RedisSetCommands

zAdd

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

Specified by:: zAdd in interface org.springframework.data.redis.connection.RedisZSetCommands

zAdd

public Long zAdd(byte[] key,
                 Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> tuples)

Specified by:: zAdd in interface org.springframework.data.redis.connection.RedisZSetCommands

zRem
```
public Long zRem(byte[] key,
                 byte[]... values)
```
Specified by:

zRem in interface org.springframework.data.redis.connection.RedisZSetCommands

zIncrBy

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

Specified by:: zIncrBy in interface org.springframework.data.redis.connection.RedisZSetCommands

zRank
```
public Long zRank(byte[] key,
                  byte[] value)
```
Specified by:

zRank in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRank
```
public Long zRevRank(byte[] key,
                     byte[] value)
```
Specified by:

zRevRank in interface org.springframework.data.redis.connection.RedisZSetCommands

zRange

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

Specified by:: zRange in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRange

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

Specified by:: zRevRange in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeWithScores

public Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key,
                                                                                                  long start,
                                                                                                  long end)

Specified by:: zRevRangeWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeWithScores

public Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zRangeWithScores(byte[] key,
                                                                                               long start,
                                                                                               long end)

Specified by:: zRangeWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScore

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

Specified by:: zRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScore

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

Specified by:: zRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScore

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

Specified by:: zRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScore

public Set<byte[]> zRangeByScore(byte[] key,
                                 org.springframework.data.redis.connection.RedisZSetCommands.Range range)

Specified by:: zRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScore

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

Specified by:: zRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScore

public Set<byte[]> zRangeByScore(byte[] key,
                                 org.springframework.data.redis.connection.RedisZSetCommands.Range range,
                                 org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)

Specified by:: zRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScoreWithScores

public Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                                                                      org.springframework.data.redis.connection.RedisZSetCommands.Range range)

Specified by:: zRangeByScoreWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScoreWithScores

public Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                                                                      double min,
                                                                                                      double max)

Specified by:: zRangeByScoreWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScoreWithScores

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

Specified by:: zRangeByScoreWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByScoreWithScores

public Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
                                                                                                      org.springframework.data.redis.connection.RedisZSetCommands.Range range,
                                                                                                      org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)

Specified by:: zRangeByScoreWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeByScore

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

Specified by:: zRevRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeByScore

public Set<byte[]> zRevRangeByScore(byte[] key,
                                    org.springframework.data.redis.connection.RedisZSetCommands.Range range)

Specified by:: zRevRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeByScore

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

Specified by:: zRevRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeByScore

public Set<byte[]> zRevRangeByScore(byte[] key,
                                    org.springframework.data.redis.connection.RedisZSetCommands.Range range,
                                    org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)

Specified by:: zRevRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeByScoreWithScores

public Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                                                         double min,
                                                                                                         double max)

Specified by:: zRevRangeByScoreWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeByScoreWithScores

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

Specified by:: zRevRangeByScoreWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeByScoreWithScores

public Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                                                         org.springframework.data.redis.connection.RedisZSetCommands.Range range)

Specified by:: zRevRangeByScoreWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zRevRangeByScoreWithScores

public Set<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
                                                                                                         org.springframework.data.redis.connection.RedisZSetCommands.Range range,
                                                                                                         org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)

Specified by:: zRevRangeByScoreWithScores in interface org.springframework.data.redis.connection.RedisZSetCommands

zCount

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

Specified by:: zCount in interface org.springframework.data.redis.connection.RedisZSetCommands

zCount

public Long zCount(byte[] key,
                   org.springframework.data.redis.connection.RedisZSetCommands.Range range)

Specified by:: zCount in interface org.springframework.data.redis.connection.RedisZSetCommands

zCard
```
public Long zCard(byte[] key)
```
Specified by:

zCard in interface org.springframework.data.redis.connection.RedisZSetCommands

zScore
```
public Double zScore(byte[] key,
                     byte[] value)
```
Specified by:

zScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRemRange

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

Specified by:: zRemRange in interface org.springframework.data.redis.connection.RedisZSetCommands

zRemRangeByScore

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

Specified by:: zRemRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zRemRangeByScore

public Long zRemRangeByScore(byte[] key,
                             org.springframework.data.redis.connection.RedisZSetCommands.Range range)

Specified by:: zRemRangeByScore in interface org.springframework.data.redis.connection.RedisZSetCommands

zUnionStore
```
public Long zUnionStore(byte[] destKey,
                        byte[]... sets)
```
Specified by:

zUnionStore in interface org.springframework.data.redis.connection.RedisZSetCommands

zUnionStore

public Long zUnionStore(byte[] destKey,
                        org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate,
                        int[] weights,
                        byte[]... sets)

Specified by:: zUnionStore in interface org.springframework.data.redis.connection.RedisZSetCommands

zUnionStore

public Long zUnionStore(byte[] destKey,
                        org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate,
                        org.springframework.data.redis.connection.RedisZSetCommands.Weights weights,
                        byte[]... sets)

Specified by:: zUnionStore in interface org.springframework.data.redis.connection.RedisZSetCommands

zInterStore
```
public Long zInterStore(byte[] destKey,
                        byte[]... sets)
```
Specified by:

zInterStore in interface org.springframework.data.redis.connection.RedisZSetCommands

zInterStore

public Long zInterStore(byte[] destKey,
                        org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate,
                        int[] weights,
                        byte[]... sets)

Specified by:: zInterStore in interface org.springframework.data.redis.connection.RedisZSetCommands

zInterStore

public Long zInterStore(byte[] destKey,
                        org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate,
                        org.springframework.data.redis.connection.RedisZSetCommands.Weights weights,
                        byte[]... sets)

Specified by:: zInterStore in interface org.springframework.data.redis.connection.RedisZSetCommands

zScan

public org.springframework.data.redis.core.Cursor<org.springframework.data.redis.connection.RedisZSetCommands.Tuple> zScan(byte[] key,
                                                                                                                           org.springframework.data.redis.core.ScanOptions options)

Specified by:: zScan in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByLex
```
public Set<byte[]> zRangeByLex(byte[] key)
```
Specified by:

zRangeByLex in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByLex

public Set<byte[]> zRangeByLex(byte[] key,
                               org.springframework.data.redis.connection.RedisZSetCommands.Range range)

Specified by:: zRangeByLex in interface org.springframework.data.redis.connection.RedisZSetCommands

zRangeByLex

public Set<byte[]> zRangeByLex(byte[] key,
                               org.springframework.data.redis.connection.RedisZSetCommands.Range range,
                               org.springframework.data.redis.connection.RedisZSetCommands.Limit limit)

Specified by:: zRangeByLex in interface org.springframework.data.redis.connection.RedisZSetCommands

hSet

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

Specified by:: hSet in interface org.springframework.data.redis.connection.RedisHashCommands

hSetNX

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

Specified by:: hSetNX in interface org.springframework.data.redis.connection.RedisHashCommands

hGet
```
public byte[] hGet(byte[] key,
                   byte[] field)
```
Specified by:

hGet in interface org.springframework.data.redis.connection.RedisHashCommands

hMGet
```
public List<byte[]> hMGet(byte[] key,
                          byte[]... fields)
```
Specified by:

hMGet in interface org.springframework.data.redis.connection.RedisHashCommands

hMSet

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

Specified by:: hMSet in interface org.springframework.data.redis.connection.RedisHashCommands

hIncrBy

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

Specified by:: hIncrBy in interface org.springframework.data.redis.connection.RedisHashCommands

hIncrBy

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

Specified by:: hIncrBy in interface org.springframework.data.redis.connection.RedisHashCommands

hExists
```
public Boolean hExists(byte[] key,
                       byte[] field)
```
Specified by:

hExists in interface org.springframework.data.redis.connection.RedisHashCommands

hDel
```
public Long hDel(byte[] key,
                 byte[]... fields)
```
Specified by:

hDel in interface org.springframework.data.redis.connection.RedisHashCommands

hLen
```
public Long hLen(byte[] key)
```
Specified by:

hLen in interface org.springframework.data.redis.connection.RedisHashCommands

hKeys
```
public Set<byte[]> hKeys(byte[] key)
```
Specified by:

hKeys in interface org.springframework.data.redis.connection.RedisHashCommands

hVals
```
public List<byte[]> hVals(byte[] key)
```
Specified by:

hVals in interface org.springframework.data.redis.connection.RedisHashCommands

hGetAll
```
public Map<byte[],byte[]> hGetAll(byte[] key)
```
Specified by:

hGetAll in interface org.springframework.data.redis.connection.RedisHashCommands

hScan

public org.springframework.data.redis.core.Cursor<Map.Entry<byte[],byte[]>> hScan(byte[] key,
                                                                                  org.springframework.data.redis.core.ScanOptions options)

Specified by:: hScan in interface org.springframework.data.redis.connection.RedisHashCommands

hStrLen
```
public Long hStrLen(byte[] key,
                    byte[] field)
```
Specified by:

hStrLen in interface org.springframework.data.redis.connection.RedisHashCommands

multi
```
public void multi()
```
Specified by:

multi in interface org.springframework.data.redis.connection.RedisTxCommands

exec
```
public List<Object> exec()
```
Specified by:

exec in interface org.springframework.data.redis.connection.RedisTxCommands

discard
```
public void discard()
```
Specified by:

discard in interface org.springframework.data.redis.connection.RedisTxCommands

watch
```
public void watch(byte[]... keys)
```
Specified by:

watch in interface org.springframework.data.redis.connection.RedisTxCommands

unwatch
```
public void unwatch()
```
Specified by:

unwatch in interface org.springframework.data.redis.connection.RedisTxCommands

publish
```
public Long publish(byte[] channel,
                    byte[] message)
```
Specified by:

publish in interface org.springframework.data.redis.connection.RedisPubSubCommands

public void subscribe(org.springframework.data.redis.connection.MessageListener listener,
                      byte[]... channels)

Specified by:: subscribe in interface org.springframework.data.redis.connection.RedisPubSubCommands

pSubscribe

public void pSubscribe(org.springframework.data.redis.connection.MessageListener listener,
                       byte[]... patterns)

Specified by:: pSubscribe in interface org.springframework.data.redis.connection.RedisPubSubCommands

select
```
public void select(int dbIndex)
```
Specified by:

select in interface org.springframework.data.redis.connection.RedisConnectionCommands

echo
```
public byte[] echo(byte[] message)
```
Specified by:

echo in interface org.springframework.data.redis.connection.RedisConnectionCommands

ping
```
public String ping()
```
Specified by:

ping in interface org.springframework.data.redis.connection.RedisConnectionCommands

bgWriteAof
```
public void bgWriteAof()
```
Specified by:

bgWriteAof in interface org.springframework.data.redis.connection.RedisServerCommands

bgReWriteAof
```
public void bgReWriteAof()
```
Specified by:

bgReWriteAof in interface org.springframework.data.redis.connection.RedisServerCommands

bgSave
```
public void bgSave()
```
Specified by:

bgSave in interface org.springframework.data.redis.connection.RedisServerCommands

lastSave
```
public Long lastSave()
```
Specified by:

lastSave in interface org.springframework.data.redis.connection.RedisServerCommands

save
```
public void save()
```
Specified by:

save in interface org.springframework.data.redis.connection.RedisServerCommands

dbSize
```
public Long dbSize()
```
Specified by:

dbSize in interface org.springframework.data.redis.connection.RedisServerCommands

flushDb
```
public void flushDb()
```
Specified by:

flushDb in interface org.springframework.data.redis.connection.RedisServerCommands

flushAll
```
public void flushAll()
```
Specified by:

flushAll in interface org.springframework.data.redis.connection.RedisServerCommands

info
```
public Properties info()
```
Specified by:

info in interface org.springframework.data.redis.connection.RedisServerCommands

info
```
public Properties info(String section)
```
Specified by:

info in interface org.springframework.data.redis.connection.RedisServerCommands

shutdown
```
public void shutdown()
```
Specified by:

shutdown in interface org.springframework.data.redis.connection.RedisServerCommands

shutdown

public void shutdown(org.springframework.data.redis.connection.RedisServerCommands.ShutdownOption option)

Specified by:: shutdown in interface org.springframework.data.redis.connection.RedisServerCommands

getConfig
```
public Properties getConfig(String pattern)
```
Specified by:

getConfig in interface org.springframework.data.redis.connection.RedisServerCommands

setConfig
```
public void setConfig(String param,
                      String value)
```
Specified by:

setConfig in interface org.springframework.data.redis.connection.RedisServerCommands

resetConfigStats
```
public void resetConfigStats()
```
Specified by:

resetConfigStats in interface org.springframework.data.redis.connection.RedisServerCommands

time
```
public Long time()
```
Specified by:

time in interface org.springframework.data.redis.connection.RedisServerCommands

killClient
```
public void killClient(String host,
                       int port)
```
Specified by:

killClient in interface org.springframework.data.redis.connection.RedisServerCommands

setClientName
```
public void setClientName(byte[] name)
```
Specified by:

setClientName in interface org.springframework.data.redis.connection.RedisServerCommands

getClientName
```
public String getClientName()
```
Specified by:

getClientName in interface org.springframework.data.redis.connection.RedisServerCommands

getClientList
```
public List<org.springframework.data.redis.core.types.RedisClientInfo> getClientList()
```
Specified by:

getClientList in interface org.springframework.data.redis.connection.RedisServerCommands

slaveOf
```
public void slaveOf(String host,
                    int port)
```
Specified by:

slaveOf in interface org.springframework.data.redis.connection.RedisServerCommands

slaveOfNoOne
```
public void slaveOfNoOne()
```
Specified by:

slaveOfNoOne in interface org.springframework.data.redis.connection.RedisServerCommands

migrate

public void migrate(byte[] key,
                    org.springframework.data.redis.connection.RedisNode target,
                    int dbIndex,
                    org.springframework.data.redis.connection.RedisServerCommands.MigrateOption option)

Specified by:: migrate in interface org.springframework.data.redis.connection.RedisServerCommands

migrate

public void migrate(byte[] key,
                    org.springframework.data.redis.connection.RedisNode target,
                    int dbIndex,
                    org.springframework.data.redis.connection.RedisServerCommands.MigrateOption option,
                    long timeout)

Specified by:: migrate in interface org.springframework.data.redis.connection.RedisServerCommands

scriptFlush
```
public void scriptFlush()
```
Specified by:

scriptFlush in interface org.springframework.data.redis.connection.RedisScriptingCommands

scriptKill
```
public void scriptKill()
```
Specified by:

scriptKill in interface org.springframework.data.redis.connection.RedisScriptingCommands

scriptLoad
```
public String scriptLoad(byte[] script)
```
Specified by:

scriptLoad in interface org.springframework.data.redis.connection.RedisScriptingCommands

scriptExists
```
public List<Boolean> scriptExists(String... scriptShas)
```
Specified by:

scriptExists in interface org.springframework.data.redis.connection.RedisScriptingCommands

eval

public <T> T eval(byte[] script,
                  org.springframework.data.redis.connection.ReturnType returnType,
                  int numKeys,
                  byte[]... keysAndArgs)

Specified by:: eval in interface org.springframework.data.redis.connection.RedisScriptingCommands

evalSha

public <T> T evalSha(String scriptSha,
                     org.springframework.data.redis.connection.ReturnType returnType,
                     int numKeys,
                     byte[]... keysAndArgs)

Specified by:: evalSha in interface org.springframework.data.redis.connection.RedisScriptingCommands

evalSha

public <T> T evalSha(byte[] scriptSha,
                     org.springframework.data.redis.connection.ReturnType returnType,
                     int numKeys,
                     byte[]... keysAndArgs)

Specified by:: evalSha in interface org.springframework.data.redis.connection.RedisScriptingCommands

geoAdd

public Long geoAdd(byte[] key,
                   org.springframework.data.geo.Point point,
                   byte[] member)

Specified by:: geoAdd in interface org.springframework.data.redis.connection.RedisGeoCommands

geoAdd

public Long geoAdd(byte[] key,
                   org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]> location)

Specified by:: geoAdd in interface org.springframework.data.redis.connection.RedisGeoCommands

geoAdd

public Long geoAdd(byte[] key,
                   Map<byte[],org.springframework.data.geo.Point> memberCoordinateMap)

Specified by:: geoAdd in interface org.springframework.data.redis.connection.RedisGeoCommands

geoAdd

public Long geoAdd(byte[] key,
                   Iterable<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> locations)

Specified by:: geoAdd in interface org.springframework.data.redis.connection.RedisGeoCommands

geoDist

public org.springframework.data.geo.Distance geoDist(byte[] key,
                                                     byte[] member1,
                                                     byte[] member2)

Specified by:: geoDist in interface org.springframework.data.redis.connection.RedisGeoCommands

geoDist

public org.springframework.data.geo.Distance geoDist(byte[] key,
                                                     byte[] member1,
                                                     byte[] member2,
                                                     org.springframework.data.geo.Metric metric)

Specified by:: geoDist in interface org.springframework.data.redis.connection.RedisGeoCommands

geoHash
```
public List<String> geoHash(byte[] key,
                            byte[]... members)
```
Specified by:

geoHash in interface org.springframework.data.redis.connection.RedisGeoCommands

geoPos

public List<org.springframework.data.geo.Point> geoPos(byte[] key,
                                                       byte[]... members)

Specified by:: geoPos in interface org.springframework.data.redis.connection.RedisGeoCommands

geoRadius

public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key,
                                                                                                                                         org.springframework.data.geo.Circle within)

Specified by:: geoRadius in interface org.springframework.data.redis.connection.RedisGeoCommands

geoRadius

public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadius(byte[] key,
                                                                                                                                         org.springframework.data.geo.Circle within,
                                                                                                                                         org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs args)

Specified by:: geoRadius in interface org.springframework.data.redis.connection.RedisGeoCommands

geoRadiusByMember

public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                                                                                                 byte[] member,
                                                                                                                                                 double radius)

Specified by:: geoRadiusByMember in interface org.springframework.data.redis.connection.RedisGeoCommands

geoRadiusByMember

public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                                                                                                 byte[] member,
                                                                                                                                                 org.springframework.data.geo.Distance radius)

Specified by:: geoRadiusByMember in interface org.springframework.data.redis.connection.RedisGeoCommands

geoRadiusByMember

public org.springframework.data.geo.GeoResults<org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation<byte[]>> geoRadiusByMember(byte[] key,
                                                                                                                                                 byte[] member,
                                                                                                                                                 org.springframework.data.geo.Distance radius,
                                                                                                                                                 org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs args)

Specified by:: geoRadiusByMember in interface org.springframework.data.redis.connection.RedisGeoCommands

geoRemove
```
public Long geoRemove(byte[] key,
                      byte[]... members)
```
Specified by:

geoRemove in interface org.springframework.data.redis.connection.RedisGeoCommands

pfAdd
```
public Long pfAdd(byte[] key,
                  byte[]... values)
```
Specified by:

pfAdd in interface org.springframework.data.redis.connection.RedisHyperLogLogCommands

pfCount
```
public Long pfCount(byte[]... keys)
```
Specified by:

pfCount in interface org.springframework.data.redis.connection.RedisHyperLogLogCommands

pfMerge
```
public void pfMerge(byte[] destinationKey,
                    byte[]... sourceKeys)
```
Specified by:

pfMerge in interface org.springframework.data.redis.connection.RedisHyperLogLogCommands

Class TracingRedisConnection

Nested Class Summary

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

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

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

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

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.springframework.data.redis.connection.RedisStringCommands

Constructor Detail

TracingRedisConnection

Method Detail

geoCommands

hashCommands

hyperLogLogCommands

keyCommands

listCommands

setCommands

scriptingCommands

serverCommands

stringCommands

zSetCommands

close

isClosed

getNativeConnection

isQueueing

isPipelined

openPipeline

closePipeline

isSubscribed

getSubscription

getSentinelConnection

execute

exists

exists

del

unlink

type

touch

keys

scan

randomKey

rename

renameNX

expire

pExpire

expireAt

pExpireAt

persist

move

ttl

ttl

pTtl

pTtl

sort

sort

dump

restore

restore

encodingOf

idletime

refcount

get

getSet

mGet

set

set

setNX

setEx

pSetEx

mSet

mSetNX

incr

incrBy

incrBy

decr

decrBy

append