org.redisson.spring.data.connection

Class RedissonConnection

java.lang.Object

org.springframework.data.redis.connection.AbstractRedisConnection

org.redisson.spring.data.connection.RedissonConnection

All Implemented Interfaces:

org.springframework.data.redis.connection.HyperLogLogCommands, 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.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:

RedissonClusterConnection

public class RedissonConnection
extends org.springframework.data.redis.connection.AbstractRedisConnection

Redisson connection

Author:

Nikita Koksharov

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

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

Field Summary

Fields

Modifier and Type	Field and Description
protected org.redisson.Redisson	redisson

Constructor Summary

Constructors

Constructor and Description
RedissonConnection(org.redisson.api.RedissonClient redisson)

Method Summary

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)
Long	bitOp(org.springframework.data.redis.connection.RedisStringCommands.BitOperation op, byte[] destination, byte[]... keys)
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()
protected List<byte[]>	convert(Map<byte[],byte[]> tuple)
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)
<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)
Boolean	exists(byte[] key)
Boolean	expire(byte[] key, long seconds)
Boolean	expireAt(byte[] key, long unixTime)
protected void	filterResults(org.redisson.api.BatchResult<?> result)
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.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()
List<String>	getConfig(String pattern)
Object	getNativeConnection()
byte[]	getRange(byte[] key, long begin, long end)
byte[]	getSet(byte[] key, byte[] value)
org.springframework.data.redis.connection.Subscription	getSubscription()
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)
List<byte[]>	hVals(byte[] key)
Long	incr(byte[] key)
Double	incrBy(byte[] key, double value)
Long	incrBy(byte[] key, long value)
protected void	indexCommand(org.redisson.client.protocol.RedisCommand<?> command)
Properties	info()
Properties	info(String section)
boolean	isClosed()
boolean	isPipelined()
boolean	isPipelinedAtomic()
boolean	isQueueing()
boolean	isSubscribed()
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)
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)
void	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()
void	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()
void	rename(byte[] oldName, byte[] newName)
Boolean	renameNX(byte[] oldName, byte[] newName)
void	resetConfigStats()
protected void	resetConnection()
void	restore(byte[] key, long ttlInMillis, byte[] serializedValue)
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()
void	scriptKill()
String	scriptLoad(byte[] script)
Set<byte[]>	sDiff(byte[]... keys)
Long	sDiffStore(byte[] destKey, byte[]... keys)
void	select(int dbIndex)
void	set(byte[] key, byte[] value)
void	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)
void	setConfig(String param, String value)
void	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 sortParams)
Long	sort(byte[] key, org.springframework.data.redis.connection.SortParameters sortParams, byte[] storeKey)
byte[]	sPop(byte[] key)
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)
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)
protected <T> T	sync(org.redisson.api.RFuture<T> f)
Long	time()
protected org.redisson.client.protocol.RedisCommand<?>	toCommand(org.springframework.data.redis.connection.ReturnType returnType, String name)
protected RuntimeException	transform(Exception ex)
Long	ttl(byte[] key)
Long	ttl(byte[] key, TimeUnit timeUnit)
org.springframework.data.redis.connection.DataType	type(byte[] key)
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)
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)
Long	zUnionStore(byte[] destKey, byte[]... sets)
Long	zUnionStore(byte[] destKey, org.springframework.data.redis.connection.RedisZSetCommands.Aggregate aggregate, int[] weights, byte[]... sets)

Methods inherited from class org.springframework.data.redis.connection.AbstractRedisConnection

getSentinelConnection, getSentinelConnection, hasRedisSentinelConfigured, isActive, setSentinelConfiguration

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

redisson

protected final org.redisson.Redisson redisson

Constructor Detail

RedissonConnection

public RedissonConnection(org.redisson.api.RedissonClient redisson)

Method Detail

close

public void close()
           throws org.springframework.dao.DataAccessException

Specified by:

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

Overrides:

close in class org.springframework.data.redis.connection.AbstractRedisConnection

Throws:

org.springframework.dao.DataAccessException

isClosed

public boolean isClosed()

getNativeConnection

public Object getNativeConnection()

isQueueing

public boolean isQueueing()

isPipelined

public boolean isPipelined()

isPipelinedAtomic

public boolean isPipelinedAtomic()

openPipeline

public void openPipeline()

closePipeline

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

Throws:

org.springframework.data.redis.connection.RedisPipelineException

execute

public Object execute(String command,
                      byte[]... args)

transform

protected RuntimeException transform(Exception ex)

exists

public Boolean exists(byte[] key)

del

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

type

public org.springframework.data.redis.connection.DataType type(byte[] key)

keys

public Set<byte[]> keys(byte[] pattern)

scan

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

randomKey

public byte[] randomKey()

rename

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

renameNX

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

expire

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

pExpire

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

expireAt

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

pExpireAt

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

persist

public Boolean persist(byte[] key)

move

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

ttl

public Long ttl(byte[] key)

sync

protected <T> T sync(org.redisson.api.RFuture<T> f)

ttl

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

pTtl

public Long pTtl(byte[] key)

pTtl

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

sort

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

sort

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

dump

public byte[] dump(byte[] key)

restore

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

get

public byte[] get(byte[] key)

getSet

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

mGet

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

set

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

set

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

setNX

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

setEx

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

pSetEx

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

mSet

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

convert

protected List<byte[]> convert(Map<byte[],byte[]> tuple)

mSetNX

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

incr

public Long incr(byte[] key)

incrBy

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

incrBy

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

decr

public Long decr(byte[] key)

decrBy

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

append

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

getRange

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

setRange

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

getBit

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

setBit

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

bitCount

public Long bitCount(byte[] key)

bitCount

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

bitOp

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

strLen

public Long strLen(byte[] key)

rPush

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

lPush

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

rPushX

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

lPushX

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

lLen

public Long lLen(byte[] key)

lRange

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

lTrim

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

lIndex

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

lInsert

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

indexCommand

protected void indexCommand(org.redisson.client.protocol.RedisCommand<?> command)

lSet

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

lRem

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

lPop

public byte[] lPop(byte[] key)

rPop

public byte[] rPop(byte[] key)

bLPop

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

bRPop

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

rPopLPush

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

bRPopLPush

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

sAdd

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

sRem

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

sPop

public byte[] sPop(byte[] key)

sMove

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

sCard

public Long sCard(byte[] key)

sIsMember

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

sInter

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

sInterStore

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

sUnion

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

sUnionStore

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

sDiff

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

sDiffStore

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

sMembers

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

sRandMember

public byte[] sRandMember(byte[] key)

sRandMember

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

sScan

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

zAdd

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

zAdd

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

zRem

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

zIncrBy

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

zRank

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

zRevRank

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

zRange

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

zRangeWithScores

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

zRangeByScore

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

zRangeByScoreWithScores

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

zRangeByScoreWithScores

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

zRangeByScore

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

zRangeByScoreWithScores

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

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)

zRevRange

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

zRevRangeWithScores

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

zRevRangeByScore

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

zRevRangeByScore

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

zRevRangeByScoreWithScores

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

zRevRangeByScore

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

zRevRangeByScore

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

zRevRangeByScoreWithScores

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

zRevRangeByScoreWithScores

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

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)

zCount

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

zCount

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

zCard

public Long zCard(byte[] key)

zScore

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

zRemRange

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

zRemRangeByScore

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

zRemRangeByScore

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

zUnionStore

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

zUnionStore

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

zInterStore

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

zInterStore

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

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)

zRangeByScore

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

zRangeByScore

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

zRangeByScore

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

zRangeByScore

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

zRangeByLex

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

zRangeByLex

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

zRangeByLex

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

hSet

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

hSetNX

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

hGet

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

hMGet

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

hMSet

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

hIncrBy

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

hIncrBy

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

hExists

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

hDel

public Long hDel(byte[] key,
                 byte[]... fields)

hLen

public Long hLen(byte[] key)

hKeys

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

hVals

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

hGetAll

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

hScan

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

multi

public void multi()

exec

public List<Object> exec()

filterResults

protected void filterResults(org.redisson.api.BatchResult<?> result)

resetConnection

protected void resetConnection()

discard

public void discard()

watch

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

unwatch

public void unwatch()

isSubscribed

public boolean isSubscribed()

getSubscription

public org.springframework.data.redis.connection.Subscription getSubscription()

publish

public Long publish(byte[] channel,
                    byte[] message)

subscribe

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

pSubscribe

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

select

public void select(int dbIndex)

echo

public byte[] echo(byte[] message)

ping

public String ping()

bgWriteAof

public void bgWriteAof()

bgReWriteAof

public void bgReWriteAof()

bgSave

public void bgSave()

lastSave

public Long lastSave()

save

public void save()

dbSize

public Long dbSize()

flushDb

public void flushDb()

flushAll

public void flushAll()

info

public Properties info()

info

public Properties info(String section)

shutdown

public void shutdown()

shutdown

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

getConfig

public List<String> getConfig(String pattern)

setConfig

public void setConfig(String param,
                      String value)

resetConfigStats

public void resetConfigStats()

time

public Long time()

killClient

public void killClient(String host,
                       int port)

setClientName

public void setClientName(byte[] name)

getClientName

public String getClientName()

getClientList

public List<org.springframework.data.redis.core.types.RedisClientInfo> getClientList()

slaveOf

public void slaveOf(String host,
                    int port)

slaveOfNoOne

public void slaveOfNoOne()

migrate

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

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)

scriptFlush

public void scriptFlush()

scriptKill

public void scriptKill()

scriptLoad

public String scriptLoad(byte[] script)

scriptExists

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

eval

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

toCommand

protected org.redisson.client.protocol.RedisCommand<?> toCommand(org.springframework.data.redis.connection.ReturnType returnType,
                                                                 String name)

evalSha

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

evalSha

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

geoAdd

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

geoAdd

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

geoAdd

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

geoAdd

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

geoDist

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

geoDist

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

geoHash

public List<String> geoHash(byte[] key,
                            byte[]... members)

geoPos

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

geoRadius

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

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)

geoRadiusByMember

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

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)

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)

geoRemove

public Long geoRemove(byte[] key,
                      byte[]... members)

pfAdd

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

pfCount

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

pfMerge

public void pfMerge(byte[] destinationKey,
                    byte[]... sourceKeys)