|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||
java.lang.Objectorg.springframework.data.redis.connection.jedis.JedisConnection
public class JedisConnection
RedisConnection implementation on top of Jedis library.
| Nested Class Summary |
|---|
| Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisStringCommands |
|---|
RedisStringCommands.BitOperation |
| Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisListCommands |
|---|
RedisListCommands.Position |
| Nested classes/interfaces inherited from interface org.springframework.data.redis.connection.RedisZSetCommands |
|---|
RedisZSetCommands.Aggregate, RedisZSetCommands.Tuple |
| Constructor Summary | |
|---|---|
JedisConnection(redis.clients.jedis.Jedis jedis)
Constructs a new JedisConnection instance. |
|
JedisConnection(redis.clients.jedis.Jedis jedis,
redis.clients.util.Pool<redis.clients.jedis.Jedis> pool,
int dbIndex)
Constructs a new JedisConnection instance backed by a jedis pool. |
|
| Method Summary | ||
|---|---|---|
Long |
append(byte[] key,
byte[] value)
|
|
void |
bgSave()
|
|
void |
bgWriteAof()
|
|
Long |
bitCount(byte[] key)
|
|
Long |
bitCount(byte[] key,
long begin,
long end)
|
|
Long |
bitOp(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()
Closes (or quits) the connection. |
|
List<Object> |
closePipeline()
Executes the commands in the pipeline and returns their result. |
|
protected DataAccessException |
convertJedisAccessException(Exception ex)
|
|
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)
|
|
|
eval(byte[] script,
ReturnType returnType,
int numKeys,
byte[]... keysAndArgs)
|
|
|
evalSha(String scriptSha1,
ReturnType returnType,
int numKeys,
byte[]... keysAndArgs)
|
|
List<Object> |
exec()
|
|
Object |
execute(String command,
byte[]... args)
'Native' or 'raw' execution of the given command along-side the given arguments. |
|
Boolean |
exists(byte[] key)
|
|
Boolean |
expire(byte[] key,
long seconds)
|
|
Boolean |
expireAt(byte[] key,
long unixTime)
|
|
void |
flushAll()
|
|
void |
flushDb()
|
|
byte[] |
get(byte[] key)
|
|
Boolean |
getBit(byte[] key,
long offset)
|
|
List<String> |
getConfig(String param)
|
|
redis.clients.jedis.Jedis |
getNativeConnection()
Returns the native connection (the underlying library/driver object). |
|
byte[] |
getRange(byte[] key,
long start,
long end)
|
|
byte[] |
getSet(byte[] key,
byte[] value)
|
|
Subscription |
getSubscription()
Returns the current subscription for this connection or null if the connection is not subscribed. |
|
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[]> tuple)
|
|
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)
|
|
Properties |
info()
|
|
Properties |
info(String section)
|
|
boolean |
isClosed()
Indicates whether the underlying connection is closed or not. |
|
boolean |
isPipelined()
Indicates whether the connection is currently pipelined or not. |
|
boolean |
isQueueing()
Indicates whether the connection is in "queue"(or "MULTI") mode or not. |
|
boolean |
isSubscribed()
Indicates whether the current connection is subscribed (to at least one channel) or not. |
|
Set<byte[]> |
keys(byte[] pattern)
|
|
Long |
lastSave()
|
|
byte[] |
lIndex(byte[] key,
long index)
|
|
Long |
lInsert(byte[] key,
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)
|
|
Boolean |
move(byte[] key,
int dbIndex)
|
|
void |
mSet(Map<byte[],byte[]> tuples)
|
|
Boolean |
mSetNX(Map<byte[],byte[]> tuples)
|
|
void |
multi()
|
|
void |
openPipeline()
Activates the pipeline mode for this connection. |
|
Boolean |
persist(byte[] key)
|
|
Boolean |
pExpire(byte[] key,
long millis)
|
|
Boolean |
pExpireAt(byte[] key,
long unixTimeInMillis)
|
|
String |
ping()
|
|
void |
pSubscribe(MessageListener listener,
byte[]... patterns)
Subscribes the connection to all channels matching the given patterns. |
|
Long |
pTtl(byte[] key)
|
|
Long |
publish(byte[] channel,
byte[] message)
Publishes the given message to the given channel. |
|
byte[] |
randomKey()
|
|
void |
rename(byte[] oldName,
byte[] newName)
|
|
Boolean |
renameNX(byte[] oldName,
byte[] newName)
|
|
void |
resetConfigStats()
|
|
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()
|
|
Long |
sCard(byte[] key)
|
|
List<Boolean> |
scriptExists(String... scriptSha1)
|
|
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 |
setBit(byte[] key,
long offset,
boolean value)
|
|
void |
setConfig(String param,
String value)
|
|
void |
setConvertPipelineAndTxResults(boolean convertPipelineAndTxResults)
Specifies if pipelined results should be converted to the expected data type. |
|
void |
setEx(byte[] key,
long time,
byte[] value)
|
|
Boolean |
setNX(byte[] key,
byte[] value)
|
|
void |
setRange(byte[] key,
byte[] value,
long start)
|
|
void |
shutdown()
|
|
Set<byte[]> |
sInter(byte[]... keys)
|
|
Long |
sInterStore(byte[] destKey,
byte[]... keys)
|
|
Boolean |
sIsMember(byte[] key,
byte[] value)
|
|
Set<byte[]> |
sMembers(byte[] key)
|
|
Boolean |
sMove(byte[] srcKey,
byte[] destKey,
byte[] value)
|
|
List<byte[]> |
sort(byte[] key,
SortParameters params)
|
|
Long |
sort(byte[] key,
SortParameters params,
byte[] storeKey)
|
|
byte[] |
sPop(byte[] key)
|
|
byte[] |
sRandMember(byte[] key)
|
|
List<byte[]> |
sRandMember(byte[] key,
long count)
|
|
Long |
sRem(byte[] key,
byte[]... values)
|
|
Long |
strLen(byte[] key)
|
|
void |
subscribe(MessageListener listener,
byte[]... channels)
Subscribes the connection to the given channels. |
|
Set<byte[]> |
sUnion(byte[]... keys)
|
|
Long |
sUnionStore(byte[] destKey,
byte[]... keys)
|
|
Long |
ttl(byte[] key)
|
|
DataType |
type(byte[] key)
|
|
void |
unwatch()
|
|
void |
watch(byte[]... keys)
|
|
Boolean |
zAdd(byte[] key,
double score,
byte[] value)
|
|
Long |
zAdd(byte[] key,
Set<RedisZSetCommands.Tuple> tuples)
|
|
Long |
zCard(byte[] key)
|
|
Long |
zCount(byte[] key,
double min,
double max)
|
|
Double |
zIncrBy(byte[] key,
double increment,
byte[] value)
|
|
Long |
zInterStore(byte[] destKey,
byte[]... sets)
|
|
Long |
zInterStore(byte[] destKey,
RedisZSetCommands.Aggregate aggregate,
int[] weights,
byte[]... sets)
|
|
Set<byte[]> |
zRange(byte[] key,
long start,
long end)
|
|
Set<byte[]> |
zRangeByScore(byte[] key,
double min,
double max)
|
|
Set<byte[]> |
zRangeByScore(byte[] key,
double min,
double max,
long offset,
long count)
|
|
Set<RedisZSetCommands.Tuple> |
zRangeByScoreWithScores(byte[] key,
double min,
double max)
|
|
Set<RedisZSetCommands.Tuple> |
zRangeByScoreWithScores(byte[] key,
double min,
double max,
long offset,
long count)
|
|
Set<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)
|
|
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<RedisZSetCommands.Tuple> |
zRevRangeByScoreWithScores(byte[] key,
double min,
double max)
|
|
Set<RedisZSetCommands.Tuple> |
zRevRangeByScoreWithScores(byte[] key,
double min,
double max,
long offset,
long count)
|
|
Set<RedisZSetCommands.Tuple> |
zRevRangeWithScores(byte[] key,
long start,
long end)
|
|
Long |
zRevRank(byte[] key,
byte[] value)
|
|
Double |
zScore(byte[] key,
byte[] value)
|
|
Long |
zUnionStore(byte[] destKey,
byte[]... sets)
|
|
Long |
zUnionStore(byte[] destKey,
RedisZSetCommands.Aggregate aggregate,
int[] weights,
byte[]... sets)
|
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public JedisConnection(redis.clients.jedis.Jedis jedis)
JedisConnection instance.
jedis - Jedis entity
public JedisConnection(redis.clients.jedis.Jedis jedis,
redis.clients.util.Pool<redis.clients.jedis.Jedis> pool,
int dbIndex)
JedisConnection instance backed by a jedis pool.
jedis - pool - can be null, if no pool is used| Method Detail |
|---|
protected DataAccessException convertJedisAccessException(Exception ex)
public Object execute(String command,
byte[]... args)
RedisCommands
execute in interface RedisCommandscommand - Command to executeargs - Possible command arguments (may be null)
public void close()
throws DataAccessException
RedisConnection
close in interface RedisConnectionDataAccessExceptionpublic redis.clients.jedis.Jedis getNativeConnection()
RedisConnection
getNativeConnection in interface RedisConnectionpublic boolean isClosed()
RedisConnection
isClosed in interface RedisConnectionpublic boolean isQueueing()
RedisConnection
isQueueing in interface RedisConnectionpublic boolean isPipelined()
RedisConnection
isPipelined in interface RedisConnectionRedisConnection.openPipeline(),
RedisConnection.isQueueing()public void openPipeline()
RedisConnectionRedisConnection.closePipeline(). Calling this method when the connection is already pipelined has no effect.
Pipelining is used for issuing commands without requesting the response right away but rather at the end of the
batch. While somewhat similar to MULTI, pipelining does not guarantee atomicity - it only tries to improve
performance when issuing a lot of commands (such as in batching scenarios).
Note:
Consider doing some performance testing before using this feature since in many cases the performance benefits are minimal yet the impact on usage are not.
openPipeline in interface RedisConnectionRedisTxCommands.multi()public List<Object> closePipeline()
RedisConnection
closePipeline in interface RedisConnection
public List<byte[]> sort(byte[] key,
SortParameters params)
sort in interface RedisKeyCommands
public Long sort(byte[] key,
SortParameters params,
byte[] storeKey)
sort in interface RedisKeyCommandspublic Long dbSize()
dbSize in interface RedisServerCommandspublic void flushDb()
flushDb in interface RedisServerCommandspublic void flushAll()
flushAll in interface RedisServerCommandspublic void bgSave()
bgSave in interface RedisServerCommandspublic void bgWriteAof()
bgWriteAof in interface RedisServerCommandspublic void save()
save in interface RedisServerCommandspublic List<String> getConfig(String param)
getConfig in interface RedisServerCommandspublic Properties info()
info in interface RedisServerCommandspublic Properties info(String section)
info in interface RedisServerCommandspublic Long lastSave()
lastSave in interface RedisServerCommands
public void setConfig(String param,
String value)
setConfig in interface RedisServerCommandspublic void resetConfigStats()
resetConfigStats in interface RedisServerCommandspublic void shutdown()
shutdown in interface RedisServerCommandspublic byte[] echo(byte[] message)
echo in interface RedisConnectionCommandspublic String ping()
ping in interface RedisConnectionCommandspublic Long del(byte[]... keys)
del in interface RedisKeyCommandspublic void discard()
discard in interface RedisTxCommandspublic List<Object> exec()
exec in interface RedisTxCommandspublic Boolean exists(byte[] key)
exists in interface RedisKeyCommands
public Boolean expire(byte[] key,
long seconds)
expire in interface RedisKeyCommands
public Boolean expireAt(byte[] key,
long unixTime)
expireAt in interface RedisKeyCommandspublic Set<byte[]> keys(byte[] pattern)
keys in interface RedisKeyCommandspublic void multi()
multi in interface RedisTxCommandspublic Boolean persist(byte[] key)
persist in interface RedisKeyCommands
public Boolean move(byte[] key,
int dbIndex)
move in interface RedisKeyCommandspublic byte[] randomKey()
randomKey in interface RedisKeyCommands
public void rename(byte[] oldName,
byte[] newName)
rename in interface RedisKeyCommands
public Boolean renameNX(byte[] oldName,
byte[] newName)
renameNX in interface RedisKeyCommandspublic void select(int dbIndex)
select in interface RedisConnectionCommandspublic Long ttl(byte[] key)
ttl in interface RedisKeyCommands
public Boolean pExpire(byte[] key,
long millis)
pExpire in interface RedisKeyCommands
public Boolean pExpireAt(byte[] key,
long unixTimeInMillis)
pExpireAt in interface RedisKeyCommandspublic Long pTtl(byte[] key)
pTtl in interface RedisKeyCommandspublic byte[] dump(byte[] key)
dump in interface RedisKeyCommands
public void restore(byte[] key,
long ttlInMillis,
byte[] serializedValue)
restore in interface RedisKeyCommandspublic DataType type(byte[] key)
type in interface RedisKeyCommandspublic void unwatch()
unwatch in interface RedisTxCommandspublic void watch(byte[]... keys)
watch in interface RedisTxCommandspublic byte[] get(byte[] key)
get in interface RedisStringCommands
public void set(byte[] key,
byte[] value)
set in interface RedisStringCommands
public byte[] getSet(byte[] key,
byte[] value)
getSet in interface RedisStringCommands
public Long append(byte[] key,
byte[] value)
append in interface RedisStringCommandspublic List<byte[]> mGet(byte[]... keys)
mGet in interface RedisStringCommandspublic void mSet(Map<byte[],byte[]> tuples)
mSet in interface RedisStringCommandspublic Boolean mSetNX(Map<byte[],byte[]> tuples)
mSetNX in interface RedisStringCommands
public void setEx(byte[] key,
long time,
byte[] value)
setEx in interface RedisStringCommands
public Boolean setNX(byte[] key,
byte[] value)
setNX in interface RedisStringCommands
public byte[] getRange(byte[] key,
long start,
long end)
getRange in interface RedisStringCommandspublic Long decr(byte[] key)
decr in interface RedisStringCommands
public Long decrBy(byte[] key,
long value)
decrBy in interface RedisStringCommandspublic Long incr(byte[] key)
incr in interface RedisStringCommands
public Long incrBy(byte[] key,
long value)
incrBy in interface RedisStringCommands
public Double incrBy(byte[] key,
double value)
incrBy in interface RedisStringCommands
public Boolean getBit(byte[] key,
long offset)
getBit in interface RedisStringCommands
public void setBit(byte[] key,
long offset,
boolean value)
setBit in interface RedisStringCommands
public void setRange(byte[] key,
byte[] value,
long start)
setRange in interface RedisStringCommandspublic Long strLen(byte[] key)
strLen in interface RedisStringCommandspublic Long bitCount(byte[] key)
bitCount in interface RedisStringCommands
public Long bitCount(byte[] key,
long begin,
long end)
bitCount in interface RedisStringCommands
public Long bitOp(RedisStringCommands.BitOperation op,
byte[] destination,
byte[]... keys)
bitOp in interface RedisStringCommands
public Long lPush(byte[] key,
byte[]... values)
lPush in interface RedisListCommands
public Long rPush(byte[] key,
byte[]... values)
rPush in interface RedisListCommands
public List<byte[]> bLPop(int timeout,
byte[]... keys)
bLPop in interface RedisListCommands
public List<byte[]> bRPop(int timeout,
byte[]... keys)
bRPop in interface RedisListCommands
public byte[] lIndex(byte[] key,
long index)
lIndex in interface RedisListCommands
public Long lInsert(byte[] key,
RedisListCommands.Position where,
byte[] pivot,
byte[] value)
lInsert in interface RedisListCommandspublic Long lLen(byte[] key)
lLen in interface RedisListCommandspublic byte[] lPop(byte[] key)
lPop in interface RedisListCommands
public List<byte[]> lRange(byte[] key,
long start,
long end)
lRange in interface RedisListCommands
public Long lRem(byte[] key,
long count,
byte[] value)
lRem in interface RedisListCommands
public void lSet(byte[] key,
long index,
byte[] value)
lSet in interface RedisListCommands
public void lTrim(byte[] key,
long start,
long end)
lTrim in interface RedisListCommandspublic byte[] rPop(byte[] key)
rPop in interface RedisListCommands
public byte[] rPopLPush(byte[] srcKey,
byte[] dstKey)
rPopLPush in interface RedisListCommands
public byte[] bRPopLPush(int timeout,
byte[] srcKey,
byte[] dstKey)
bRPopLPush in interface RedisListCommands
public Long lPushX(byte[] key,
byte[] value)
lPushX in interface RedisListCommands
public Long rPushX(byte[] key,
byte[] value)
rPushX in interface RedisListCommands
public Long sAdd(byte[] key,
byte[]... values)
sAdd in interface RedisSetCommandspublic Long sCard(byte[] key)
sCard in interface RedisSetCommandspublic Set<byte[]> sDiff(byte[]... keys)
sDiff in interface RedisSetCommands
public Long sDiffStore(byte[] destKey,
byte[]... keys)
sDiffStore in interface RedisSetCommandspublic Set<byte[]> sInter(byte[]... keys)
sInter in interface RedisSetCommands
public Long sInterStore(byte[] destKey,
byte[]... keys)
sInterStore in interface RedisSetCommands
public Boolean sIsMember(byte[] key,
byte[] value)
sIsMember in interface RedisSetCommandspublic Set<byte[]> sMembers(byte[] key)
sMembers in interface RedisSetCommands
public Boolean sMove(byte[] srcKey,
byte[] destKey,
byte[] value)
sMove in interface RedisSetCommandspublic byte[] sPop(byte[] key)
sPop in interface RedisSetCommandspublic byte[] sRandMember(byte[] key)
sRandMember in interface RedisSetCommands
public List<byte[]> sRandMember(byte[] key,
long count)
sRandMember in interface RedisSetCommands
public Long sRem(byte[] key,
byte[]... values)
sRem in interface RedisSetCommandspublic Set<byte[]> sUnion(byte[]... keys)
sUnion in interface RedisSetCommands
public Long sUnionStore(byte[] destKey,
byte[]... keys)
sUnionStore in interface RedisSetCommands
public Boolean zAdd(byte[] key,
double score,
byte[] value)
zAdd in interface RedisZSetCommands
public Long zAdd(byte[] key,
Set<RedisZSetCommands.Tuple> tuples)
zAdd in interface RedisZSetCommandspublic Long zCard(byte[] key)
zCard in interface RedisZSetCommands
public Long zCount(byte[] key,
double min,
double max)
zCount in interface RedisZSetCommands
public Double zIncrBy(byte[] key,
double increment,
byte[] value)
zIncrBy in interface RedisZSetCommands
public Long zInterStore(byte[] destKey,
RedisZSetCommands.Aggregate aggregate,
int[] weights,
byte[]... sets)
zInterStore in interface RedisZSetCommands
public Long zInterStore(byte[] destKey,
byte[]... sets)
zInterStore in interface RedisZSetCommands
public Set<byte[]> zRange(byte[] key,
long start,
long end)
zRange in interface RedisZSetCommands
public Set<RedisZSetCommands.Tuple> zRangeWithScores(byte[] key,
long start,
long end)
zRangeWithScores in interface RedisZSetCommands
public Set<byte[]> zRangeByScore(byte[] key,
double min,
double max)
zRangeByScore in interface RedisZSetCommands
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
double min,
double max)
zRangeByScoreWithScores in interface RedisZSetCommands
public Set<RedisZSetCommands.Tuple> zRevRangeWithScores(byte[] key,
long start,
long end)
zRevRangeWithScores in interface RedisZSetCommands
public Set<byte[]> zRangeByScore(byte[] key,
double min,
double max,
long offset,
long count)
zRangeByScore in interface RedisZSetCommands
public Set<RedisZSetCommands.Tuple> zRangeByScoreWithScores(byte[] key,
double min,
double max,
long offset,
long count)
zRangeByScoreWithScores in interface RedisZSetCommands
public Set<byte[]> zRevRangeByScore(byte[] key,
double min,
double max,
long offset,
long count)
zRevRangeByScore in interface RedisZSetCommands
public Set<byte[]> zRevRangeByScore(byte[] key,
double min,
double max)
zRevRangeByScore in interface RedisZSetCommands
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
double min,
double max,
long offset,
long count)
zRevRangeByScoreWithScores in interface RedisZSetCommands
public Set<RedisZSetCommands.Tuple> zRevRangeByScoreWithScores(byte[] key,
double min,
double max)
zRevRangeByScoreWithScores in interface RedisZSetCommands
public Long zRank(byte[] key,
byte[] value)
zRank in interface RedisZSetCommands
public Long zRem(byte[] key,
byte[]... values)
zRem in interface RedisZSetCommands
public Long zRemRange(byte[] key,
long start,
long end)
zRemRange in interface RedisZSetCommands
public Long zRemRangeByScore(byte[] key,
double min,
double max)
zRemRangeByScore in interface RedisZSetCommands
public Set<byte[]> zRevRange(byte[] key,
long start,
long end)
zRevRange in interface RedisZSetCommands
public Long zRevRank(byte[] key,
byte[] value)
zRevRank in interface RedisZSetCommands
public Double zScore(byte[] key,
byte[] value)
zScore in interface RedisZSetCommands
public Long zUnionStore(byte[] destKey,
RedisZSetCommands.Aggregate aggregate,
int[] weights,
byte[]... sets)
zUnionStore in interface RedisZSetCommands
public Long zUnionStore(byte[] destKey,
byte[]... sets)
zUnionStore in interface RedisZSetCommands
public Boolean hSet(byte[] key,
byte[] field,
byte[] value)
hSet in interface RedisHashCommands
public Boolean hSetNX(byte[] key,
byte[] field,
byte[] value)
hSetNX in interface RedisHashCommands
public Long hDel(byte[] key,
byte[]... fields)
hDel in interface RedisHashCommands
public Boolean hExists(byte[] key,
byte[] field)
hExists in interface RedisHashCommands
public byte[] hGet(byte[] key,
byte[] field)
hGet in interface RedisHashCommandspublic Map<byte[],byte[]> hGetAll(byte[] key)
hGetAll in interface RedisHashCommands
public Long hIncrBy(byte[] key,
byte[] field,
long delta)
hIncrBy in interface RedisHashCommands
public Double hIncrBy(byte[] key,
byte[] field,
double delta)
hIncrBy in interface RedisHashCommandspublic Set<byte[]> hKeys(byte[] key)
hKeys in interface RedisHashCommandspublic Long hLen(byte[] key)
hLen in interface RedisHashCommands
public List<byte[]> hMGet(byte[] key,
byte[]... fields)
hMGet in interface RedisHashCommands
public void hMSet(byte[] key,
Map<byte[],byte[]> tuple)
hMSet in interface RedisHashCommandspublic List<byte[]> hVals(byte[] key)
hVals in interface RedisHashCommands
public Long publish(byte[] channel,
byte[] message)
RedisPubSubCommands
publish in interface RedisPubSubCommandschannel - the channel to publish tomessage - message to publish
public Subscription getSubscription()
RedisPubSubCommands
getSubscription in interface RedisPubSubCommandspublic boolean isSubscribed()
RedisPubSubCommands
isSubscribed in interface RedisPubSubCommands
public void pSubscribe(MessageListener listener,
byte[]... patterns)
RedisPubSubCommands
pSubscribe in interface RedisPubSubCommandslistener - message listenerpatterns - channel name patterns
public void subscribe(MessageListener listener,
byte[]... channels)
RedisPubSubCommands
subscribe in interface RedisPubSubCommandslistener - message listenerchannels - channel namespublic void scriptFlush()
scriptFlush in interface RedisScriptingCommandspublic void scriptKill()
scriptKill in interface RedisScriptingCommandspublic String scriptLoad(byte[] script)
scriptLoad in interface RedisScriptingCommandspublic List<Boolean> scriptExists(String... scriptSha1)
scriptExists in interface RedisScriptingCommands
public <T> T eval(byte[] script,
ReturnType returnType,
int numKeys,
byte[]... keysAndArgs)
eval in interface RedisScriptingCommands
public <T> T evalSha(String scriptSha1,
ReturnType returnType,
int numKeys,
byte[]... keysAndArgs)
evalSha in interface RedisScriptingCommandspublic void setConvertPipelineAndTxResults(boolean convertPipelineAndTxResults)
closePipeline() and exec() will be of the type returned by the Jedis driver
convertPipelineAndTxResults - Whether or not to convert pipeline and tx results
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | ||||||||