cn.ipokerface.redis

接口 JedisClient

所有已知实现类:

JedisClusterClient, JedisSimpleClient

public interface JedisClient

Created by PokerFace Create Date 2019-11-27. Email: 214888341@163.com Version 1.0.0

Description: Common interface of operation Redis-server

字段概要

字段

限定符和类型	字段和说明
static long	DEFAULT_TIMEOUT
static String	RESULT_OK
static Long	RESULT_WHEN_EXCEPTION
static String	SET_EXPIRE_TIME_MILLISECOND
static String	SET_EXPIRE_TIME_SECOND
static String	SET_IF_EXIST
static String	SET_IF_NOT_EXIST

方法概要

限定符和类型	方法和说明
Long	append(String key, String value) If the key already exists and is a string, this command appends the provided value at the end of the string.
Long	bigCount(String key)
Long	bitCount(String key, long start, long end)
List<Long>	bitField(String key, String... arguments)
Long	bitOp(redis.clients.jedis.BitOP op, String destKey, String... srcKeys)
Long	decrease(String key) Decrement the number stored at key by one.
Long	decreaseBy(String key, long decrement) Decrement the number stored at key by decrement count.
Long	delete(String... keys) Delete from redis with keys... .
String	echo(String string) print string in redis
Object	eval(String script)
Object	eval(String script, int keyCount, String... params)
Object	eval(String script, List<String> keys, List<String> args) Eval a script in lua .
Object	evalSha(String sha1)
Object	evalSha(String sha1, int keyCount, String... params)
Object	evalSha(String sha1, List<String> keys, List<String> args)
Long	exists(String... keys) Test if the specified keys exist.
Boolean	exists(String key) if key exist or not .
Long	expire(String key, int seconds) expire key in time of seconds CMD: TTL seconds this key will be removed at time after now in seconds.
Long	expire(String key, long timeMillis) expire key in time of milliseconds CMD: expire key time this key will be removed at time after now in seconds.
Long	expireAt(String key, long unixTimestamp) expire key at time of unix timestamp. it takes an absolute one in the form of a UNIX timestamp (Number of seconds elapsed since 1 Gen 1970).
Long	geoAdd(String key, double longitude, double latitude, String value) Add a geo location of value
Long	geoAdd(String key, Map<String,redis.clients.jedis.GeoCoordinate> memberCoordinateMap)
Double	geoDistant(String key, String source, String target)
Double	geoDistant(String key, String source, String target, redis.clients.jedis.GeoUnit unit)
List<String>	geoHash(String key, String... values)
List<redis.clients.jedis.GeoCoordinate>	geoPos(String key, String... values)
List<redis.clients.jedis.GeoRadiusResponse>	geoRadius(String key, double longitude, double latitude, double radius, redis.clients.jedis.GeoUnit unit) Find values that distant is in radius with longitude and latitude.
List<redis.clients.jedis.GeoRadiusResponse>	geoRadius(String key, double longitude, double latitude, double radius, redis.clients.jedis.GeoUnit unit, redis.clients.jedis.params.GeoRadiusParam param)
List<redis.clients.jedis.GeoRadiusResponse>	geoRadiusByMember(String key, String member, double radius, redis.clients.jedis.GeoUnit unit)
List<redis.clients.jedis.GeoRadiusResponse>	geoRadiusByMember(String key, String member, double radius, redis.clients.jedis.GeoUnit unit, redis.clients.jedis.params.GeoRadiusParam param)
List<redis.clients.jedis.GeoRadiusResponse>	geoRadiusByMemberReadonly(String key, String member, double radius, redis.clients.jedis.GeoUnit unit)
List<redis.clients.jedis.GeoRadiusResponse>	geoRadiusByMemberReadonly(String key, String member, double radius, redis.clients.jedis.GeoUnit unit, redis.clients.jedis.params.GeoRadiusParam param)
List<redis.clients.jedis.GeoRadiusResponse>	geoRadiusReadonly(String key, double longitude, double latitude, double radius, redis.clients.jedis.GeoUnit unit)
List<redis.clients.jedis.GeoRadiusResponse>	geoRadiusReadonly(String key, double longitude, double latitude, double radius, redis.clients.jedis.GeoUnit unit, redis.clients.jedis.params.GeoRadiusParam param)
List<String>	get(String... keys) Get the values of all the specified keys.
String	get(String key) Get value from redis with key.
Boolean	getBit(String key, long offset) check if the offset of key is positive.
String	getRange(String key, long offset, long endOffset) get the substring of key that between offset and endOffset.
String	getSet(String key, String value) atomic set this value and return the old value command.
Long	increase(String key) Increment the number stored at key by one.
Long	increaseBy(String key, long increment) Increment the number stored at key by increment count.
Double	increaseByFloat(String key, float increment) this is actually a string operation, that is, in Redis there are not "double" types.
Set<String>	keys(String pattern) Get a set of keys that exist in redis match with pattern.
List<String>	listBlockingLeftPop(int timeout, String... keys) BLPOP (and BRPOP) is a blocking list pop primitive.
List<String>	listBlockingRightPop(int timeout, String... keys) listBlockingLeftPop(int, String...)
String	listBlockingRightPopLeftPush(String srcKey, String targetKey, int timeout) Pop a value from a list, push it to another list and return it; or block until one is available
String	listIndex(String key, long index) Return the specified element of the list stored at the specified key. 0 is the first element, 1 the second and so on.
Long	listInsert(String key, redis.clients.jedis.ListPosition where, String anchor, String value) Insert a value into list of where with anchor.
String	listLeftPop(String key) Pop out the HEAD value just push to the list.
Long	listLeftPush(String key, String... values) Add the string value to the HEAD of the list.
Long	listLeftPushExist(String key, String... values) Add the string value to the HEAD of the list.
Long	listLength(String key) Return the length of the list stored at the specified key.
String	listPop(String key) Pop out the value just push to the list.
Long	listPush(String key, String... values) Add the string value to the TAIL of the list.
List<String>	listRange(String key, long start, long end) Return the specified elements of the list stored at the specified key.
Long	listRemove(String key, long count, String value) Remove the first count occurrences of the value element from the list.
String	listRightPop(String key) Pop out the TAIL value just push to the list.
String	listRightPopLeftPush(String srcKey, String targetKey) Atomically return and remove the last (tail) element of the srckey list, and push the element as the first (head) element of the dstkey list.
Long	listRightPush(String key, String... values) Add the string value to the TAIL of the list.
Long	listRightPushExist(String key, String... values) Add the string value to the TAIL of the list.
String	listSet(String key, long index, String value) Set a new value as the element at index position of the List at key.
String	listTrim(String key, long start, long end) Trim an existing list so that it will contain only the specified range of elements specified.
Map<String,String>	mapAll(String key) Return all the fields and associated values in a hash.
Long	mapDelete(String key, String... fields) Remove the specified field from an hash stored at key.
Boolean	mapExist(String key, String field) Test for existence of a specified field in a hash.
String	mapGet(String key, String field) If key holds a hash, retrieve the value associated to the specified field.
Long	mapIncreaseBy(String key, String field, long value) Increment the number stored at field in the hash at key by value.
Double	mapIncreaseByFloat(String key, String field, float value) Increment the number stored at field in the hash at key by a double precision floating point value.
Set<String>	mapKeys(String key) Return all the fields in a hash.
Long	mapLength(String key) Get the length of a hash key.
List<String>	mapMultiGet(String key, String... fields) Retrieve the values associated to the specified fields.
Long	mapSet(String key, Map<String,String> map) Set the specified hash map field to the specified value.
Long	mapSet(String key, String field, String value) Set the specified hash map field to the specified value.
Long	mapSetNx(String key, String field, String value) Set the specified hash field to the specified value if the field not exists.
List<String>	mapValues(String key) Return all the values in a hash.
String	multiSet(String... keyValues) set key values into a map structure.
Long	multiSetNx(String... keyValues) set key values info a map structure only if all keys not exist in map.
void	patternSubscribe(redis.clients.jedis.JedisPubSub jedisPubSub, String... patterns) subscribe channels in patterns...
Long	persist(String key) Undo a expire at turning the expire key into a normal key.
Long	publish(String channel, String message) publish message to channel.
List<Boolean>	scriptExists(String... sha1)
Boolean	scriptExists(String sha1)
String	scriptLoad(String script)
String	set(String key, String value) Set a value with key with no expire times.
String	set(String key, String value, long expireInMillis) Set value with expire time .
String	set(String key, String value, redis.clients.jedis.params.SetParams setParams) Set value with some options like: NX: set key only if key not exist XX: set key only if key exist PX: set key expire time in milliseconds.
Boolean	setBit(String key, long offset, boolean value) Sets or clears the bit at offset in the string value stored at key set value:1 00000000000 setbit value:1 2 1 after set value:1 00100000000
Boolean	setBit(String key, long offset, String value) setBit(String, long, String)
Long	setRange(String key, long offset, String value) cover the string value of key of new value that offset to key.
Long	setsAdd(String key, String... values) Add the specified member to the set value stored at key.
Long	setsDelete(String key, String... values) Remove the specified member from the set value stored at key.
Set<String>	setsDifferent(String... keys) Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN Example: key1 = [x, a, b, c] key2 = [c] key3 = [a, d] SDIFF key1,key2,key3 => [x, b] Non existing keys are considered like empty sets.
Long	setsDifferentStore(String destKey, String... keys) This command works exactly like setsDifferent(String...) but instead of being returned the resulting set is stored in destkey.
Boolean	setsExist(String key, String value) Return true if member is a member of the set stored at key, otherwise false is returned.
Set<String>	setsInter(String... keys) Return the members of a set resulting from the intersection of all the sets hold at the specified keys.
Long	setsInterStore(String destKey, String... keys) This command works exactly like setsInter(String...)
Long	setsLength(String key) Return the set cardinality (number of elements).
Long	setsMove(String srcKey, String targetKey, String value) Move the specified member from the set at srckey to the set at dstkey.
String	setsPop(String key) Remove a random element from a Set returning it as return value.
Set<String>	setsPop(String key, long count) Remove a random element from a Set returning it as return value.
String	setsRandomValue(String key) Return a random element from a Set, without removing the element.
List<String>	setsRandomValue(String key, int count) Return a count of random elements from a Set, without removing the element.
Set<String>	setsUnion(String... keys) Return the members of a set resulting from the union of all the sets hold at the specified keys.
Long	setsUnionStore(String destKey, String... keys) This command works exactly like setsUnion(String...)
Set<String>	setsValues(String key) Return all the members (elements) of the set value stored at key.
List<String>	sort(String key) Sort a Set or a List.
List<String>	sort(String key, redis.clients.jedis.SortingParams sortingParameters) Sort a Set or a List accordingly to the specified parameters.
Long	sortStore(String key, redis.clients.jedis.SortingParams sortingParameters, String destKey) Sort a Set or a List and Store the Result at dstkey.
Long	sortStore(String key, String destKey) Sort a Set or a List and Store the Result at dstkey.
void	subscribe(redis.clients.jedis.JedisPubSub jedisPubSub, String... channels) subscribe channels ..
String	subString(String key, int start, int end) Return a subset of the string from offset start to offset end (both offsets are inclusive).
Long	touch(String... keys) Alters the last access time of a key(s).
Long	ttl(String key) Get the remaining time to live in seconds of a key.
String	type(String key) get the type of this key.
Long	zsetAdd(String key, double score, String value) Add the specified member having the specified score to the sorted set stored at key.
Long	zsetAdd(String key, double score, String value, redis.clients.jedis.params.ZAddParams params) Add the specified member having the specified score to the sorted set stored at key.
Long	zsetAdd(String key, Map<String,Double> valueScores) Add the specified member having the specified score to the sorted set stored at key.
Long	zsetAdd(String key, Map<String,Double> valueScores, redis.clients.jedis.params.ZAddParams params) Add the specified member having the specified score to the sorted set stored at key.
Long	zsetDelete(String key, String... values) Remove the specified member from the sorted set value stored at key.
Long	zsetDeleteRangeByIndex(String key, long start, long stop) Remove all elements in the sorted set at key with rank between start and end.
Long	zsetDeleteRangeByLex(String key, String min, String max)
Long	zsetDeleteRangeByScore(String key, double min, double max) Remove all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Long	zsetDeleteRangeByScore(String key, String min, String max) zsetDeleteRangeByScore(String, String, String)
Double	zsetIncreaseBy(String key, double increment, String value) If member already exists in the sorted set adds the increment to its score and updates the position of the element in the sorted set accordingly.
Double	zsetIncreaseBy(String key, double increment, String value, redis.clients.jedis.params.ZIncrByParams params) If member already exists in the sorted set adds the increment to its score and updates the position of the element in the sorted set accordingly.
Long	zsetIndexOf(String key, String value) Return the rank (or index) of member in the sorted set at key, with scores being ordered from low to high.
Long	zsetInterStore(String destKey, String... keys) Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey.
Long	zsetInterStore(String destKey, redis.clients.jedis.ZParams params, String... keys) Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey.
Long	zsetLength(String key) Return the sorted set cardinality (number of elements).
Long	zsetLexLength(String key, String min, String max) Return count of set values that lex value between min and max such as: a -> z
Set<String>	zsetRange(String key, long start, long end) Return a range of zset . this function such as listRange(String, long, long)
Set<String>	zsetRangeByLex(String key, String min, String max) zsetRangeByScore(String, double, double) zsetLexLength(String, String, String)
Set<String>	zsetRangeByLex(String key, String min, String max, int offset, int count)
Set<String>	zsetRangeByScore(String key, double min, double max) Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Set<String>	zsetRangeByScore(String key, double min, double max, int offset, int count) Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Set<String>	zsetRangeByScore(String key, String min, String max) zsetRangeByScore(String, String, String)
Set<String>	zsetRangeByScore(String key, String min, String max, int offset, int count) zsetRangeByScore(String, String, String, int, int)
Set<redis.clients.jedis.Tuple>	zsetRangeByScoreWithScores(String key, double min, double max) Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).
Set<redis.clients.jedis.Tuple>	zsetRangeByScoreWithScores(String key, double min, double max, int offset, int count) zsetRangeByScoreWithScores(String, String, String) zsetRangeByScore(String, double, double, int ,int)
Set<redis.clients.jedis.Tuple>	zsetRangeByScoreWithScores(String key, String min, String max) zsetRangeByScoreWithScores(String, String, String)
Set<redis.clients.jedis.Tuple>	zsetRangeByScoreWithScores(String key, String min, String max, int offset, int count) zsetRangeByScoreWithScores(String, String, String) zsetRangeByScore(String, double, double, int ,int)
Set<redis.clients.jedis.Tuple>	zsetRangeWithScores(String key, long start, long end) return range of zset.
Long	zsetReverseIndexOf(String key, String value) Return the rank (or index) of member in the sorted set at key, with scores being ordered from high to low.
Set<String>	zsetReverseRange(String key, long start, long end) return reverse range of zset.
Set<String>	zsetReverseRangeByLex(String key, String min, String max)
Set<String>	zsetReverseRangeByLex(String key, String min, String max, int offset, int count)
Set<String>	zsetReverseRangeByScore(String key, double min, double max) zsetRangeByScore(String, double, double)
Set<String>	zsetReverseRangeByScore(String key, double min, double max, int offset, int count)
Set<String>	zsetReverseRangeByScore(String key, String min, String max)
Set<String>	zsetReverseRangeByScore(String key, String min, String max, int offset, int count)
Set<redis.clients.jedis.Tuple>	zsetReverseRangeByScoreWithScores(String key, double min, double max)
Set<redis.clients.jedis.Tuple>	zsetReverseRangeByScoreWithScores(String key, double min, double max, int offset, int count)
Set<redis.clients.jedis.Tuple>	zsetReverseRangeByScoreWithScores(String key, String min, String max)
Set<redis.clients.jedis.Tuple>	zsetReverseRangeByScoreWithScores(String key, String min, String max, int offset, int count)
Set<redis.clients.jedis.Tuple>	zsetReverseRangeWithScores(String key, long start, long end) return reverse range of zset.
Double	zsetScore(String key, String value) Return the score of the specified element of the sorted set at key.
Long	zsetUnionStore(String destKey, String... keys) Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey.
Long	zsetUnionStore(String destKey, redis.clients.jedis.ZParams params, String... keys) Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey.

字段详细资料

RESULT_OK

static final String RESULT_OK

另请参阅:

常量字段值

RESULT_WHEN_EXCEPTION

static final Long RESULT_WHEN_EXCEPTION

DEFAULT_TIMEOUT

static final long DEFAULT_TIMEOUT

另请参阅:

常量字段值

SET_IF_EXIST

static final String SET_IF_EXIST

另请参阅:

常量字段值

SET_IF_NOT_EXIST

static final String SET_IF_NOT_EXIST

另请参阅:

常量字段值

SET_EXPIRE_TIME_SECOND

static final String SET_EXPIRE_TIME_SECOND

另请参阅:

常量字段值

SET_EXPIRE_TIME_MILLISECOND

static final String SET_EXPIRE_TIME_MILLISECOND

另请参阅:

常量字段值

方法详细资料

set

String set(String key,
           String value)

Set a value with key with no expire times. set("key","value") The string can't be longer than 1073741824 bytes (1GB). And this will return RESULT_OK if succeed.

参数:

key - key

value - value

返回:

redis-server reply

set

String set(String key,
           String value,
           long expireInMillis)

Set value with expire time . set(String, String, SetParams) set(key, value, SetParams.setParams().px(expireInMillis)) And this will return RESULT_OK if succeed.

参数:

key - key

value - value

expireInMillis - expire time in milliseconds

返回:

redis-server reply

set

String set(String key,
           String value,
           redis.clients.jedis.params.SetParams setParams)

Set value with some options like:

• NX: set key only if key not exist
• XX: set key only if key exist
• PX: set key expire time in milliseconds.
• EX: set key expire time in seconds

usage: SetParams param = SetParams.setParams().nx().px(123L); And this will return RESULT_OK if succeed.

参数:

key - key

value - value

setParams - params

返回:

server reply

multiSet

String multiSet(String... keyValues)

set key values into a map structure.

参数:

keyValues - key value pairs

返回:

status code like OK.

multiSetNx

Long multiSetNx(String... keyValues)

set key values info a map structure only if all keys not exist in map. returns:

• 1 if the all the keys were set
• 0 if no key was set (at least one key already existed)

参数:

keyValues -

返回:

Integer reply

get

String get(String key)

Get value from redis with key. return null if key not exist.

参数:

key - key

返回:

value of key

get

List<String> get(String... keys)

Get the values of all the specified keys. If one or more keys don't exist or is not of type String, a 'nil' value is returned instead of the value of the specified key, but the operation never fails.

参数:

keys - keys to get

返回:

value list of keys

exists

Long exists(String... keys)

Test if the specified keys exist. The command returns the number of keys exist.

参数:

keys - keys to be test

返回:

count exist

exists

Boolean exists(String key)

if key exist or not . Note that even keys set with an empty string as value will return true.

参数:

key - key to be test

返回:

if exist or nor.

expire

Long expire(String key,
            int seconds)

expire key in time of seconds CMD: TTL seconds this key will be removed at time after now in seconds. return : 1: the timeout was set. 0: the timeout was not set since the key already has an associated timeout (this may happen only in Redis versions < 2.1.3, Redis >= 2.1.3 will happily update the timeout), or the key does not exist.

参数:

key - key

seconds - time in seconds

返回:

Integer reply,

expire

Long expire(String key,
            long timeMillis)

expire key in time of milliseconds CMD: expire key time this key will be removed at time after now in seconds. return : 1: the timeout was set. 0: the timeout was not set since the key already has an associated timeout (this may happen only in Redis versions < 2.1.3, Redis >= 2.1.3 will happily update the timeout), or the key does not exist.

参数:

key - key

timeMillis - time in milliseconds

返回:

Integer reply

expireAt

Long expireAt(String key,
              long unixTimestamp)

expire key at time of unix timestamp. it takes an absolute one in the form of a UNIX timestamp (Number of seconds elapsed since 1 Gen 1970). return : 1: the timeout was set. 0: the timeout was not set since the key already has an associated timeout (this may happen only in Redis versions < 2.1.3, Redis >= 2.1.3 will happily update the timeout), or the key does not exist.

参数:

key - key

unixTimestamp - timestamp

返回:

Integer reply

persist

Long persist(String key)

Undo a expire at turning the expire key into a normal key.

参数:

key - key

返回:

Integer reply, specifically: 1: the key is now persist. 0: the key is not persist (only happens when key not set).

ttl

Long ttl(String key)

Get the remaining time to live in seconds of a key. returns the remaining time to live in seconds of a key that has an EXPIRE. In Redis 2.6 or older: if the Key does not exists or does not have an associated expire, -1 is returned. In Redis 2.8 or newer: if the Key does not have an associated expire, -1 is returned if the Key does not exists, -2 is returned.

参数:

key -

返回:

echo

String echo(String string)

print string in redis

参数:

string - string to echo

返回:

string to return

delete

Long delete(String... keys)

Delete from redis with keys... . This command is very similar to DEL: it removes the specified keys. Just like DEL a key is ignored if it does not exist. However the command performs the actual memory reclaiming in a different thread, so it is not blocking, while DEL is. This is where the command name comes from: the command just unlinks the keys from the keyspace. The actual removal will happen later asynchronously. using jedis.unlink(keys) CMD: unlink ... more. see Jedis or JedisCluster

参数:

keys - keys to be removed

返回:

number of keys been removed

type

String type(String key)

get the type of this key. The type can be one of "none", "string", "list", "set". "none" is returned if the key does not exist. returns:

• "none" : if the key does not exist
• "string": if the key contains a String value
• "list" : if the key contains a List value
• "set" : if the key contains a Set value
• "zset" : if the key contains a Sorted Set value
• "hash" : if the key contains a Hash value

参数:

key - key

返回:

type of key

keys

Set<String> keys(String pattern)

Get a set of keys that exist in redis match with pattern. This may course some problem if volume of data is huge. so do not use this api at any time.

参数:

pattern - pattern of keys

返回:

keys

touch

Long touch(String... keys)

Alters the last access time of a key(s). A key is ignored if it does not exist.

参数:

keys - keys to be touch

返回:

count of keys been touched.

getSet

String getSet(String key,
              String value)

atomic set this value and return the old value command. Set key to the string value and return the old value stored at key. The string can't be longer than 1073741824 bytes (1 GB).

参数:

key - key

value - new value of key

返回:

old value of key

increase

Long increase(String key)

Increment the number stored at key by one. If the key does not exist or contains a value of a wrong type, set the key to the value of "0" before to perform the increment operation.

INCR commands are limited to 64 bit signed integers.

Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.

参数:

key - key

返回:

new value of key.

increaseBy

Long increaseBy(String key,
                long increment)

Increment the number stored at key by increment count. If the key does not exist or contains a value of a wrong type, set the key to the value of "0" before to perform the increment operation.

INCR commands are limited to 64 bit signed integers.

Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, incremented, and then converted back as a string.

参数:

key - key

increment - increment count

返回:

new value of key

decrease

Long decrease(String key)

Decrement the number stored at key by one. If the key does not exist or contains a value of a wrong type, set the key to the value of "0" before to perform the Decrement operation.

INCR commands are limited to 64 bit signed integers.

Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, decremented, and then converted back as a string.

参数:

key - key

返回:

new value of key.

decreaseBy

Long decreaseBy(String key,
                long decrement)

Decrement the number stored at key by decrement count. If the key does not exist or contains a value of a wrong type, set the key to the value of "0" before to perform the decrement operation.

INCR commands are limited to 64 bit signed integers.

Note: this is actually a string operation, that is, in Redis there are not "integer" types. Simply the string stored at the key is parsed as a base 10 64 bit signed integer, decremented, and then converted back as a string.

参数:

key - key

decrement - increment count

返回:

new value of key

increaseByFloat

Double increaseByFloat(String key,
                       float increment)

this is actually a string operation, that is, in Redis there are not "double" types. Simply the string stored at the key is parsed as a base double precision floating point value, incremented, and then converted back as a string. There is no DECRYBYFLOAT but providing a negative value will work as expected.

参数:

key - key

increment - increment

返回:

new value

append

Long append(String key,
            String value)

If the key already exists and is a string, this command appends the provided value at the end of the string. If the key does not exist it is created and set as an empty string, so APPEND will be very similar to SET in this special case.

参数:

key - key

value - value

返回:

Integer reply, specifically the total length of the string after the append operation.

subString

String subString(String key,
                 int start,
                 int end)

Return a subset of the string from offset start to offset end (both offsets are inclusive). Negative offsets can be used in order to provide an offset starting from the end of the string. So -1 means the last char, -2 the penultimate and so forth.

The function handles out of range requests without raising an error, but just limiting the resulting range to the actual length of the string.

参数:

key - key

start - start index

end - end index

返回:

sub string of key

setBit

Boolean setBit(String key,
               long offset,
               boolean value)

Sets or clears the bit at offset in the string value stored at key set value:1 00000000000 setbit value:1 2 1 after set value:1 00100000000

参数:

key - key

offset - offset

value - bit value

返回:

if success

setBit

Boolean setBit(String key,
               long offset,
               String value)

setBit(String, long, String)

参数:

key - key

offset - offset

value - bit value

返回:

if success

getBit

Boolean getBit(String key,
               long offset)

check if the offset of key is positive. setBit(String, long, String)

参数:

key - key

offset - offset

返回:

if positive.

bigCount

Long bigCount(String key)

bitCount

Long bitCount(String key,
              long start,
              long end)

bitOp

Long bitOp(redis.clients.jedis.BitOP op,
           String destKey,
           String... srcKeys)

bitField

List<Long> bitField(String key,
                    String... arguments)

setRange

Long setRange(String key,
              long offset,
              String value)

cover the string value of key of new value that offset to key. "Hello News!" set 4 "FOO" become"Hello FOO" Do nothing if key not exist.

参数:

key - key

offset - offset to cover

value - new value

返回:

new length of string.

getRange

String getRange(String key,
                long offset,
                long endOffset)

get the substring of key that between offset and endOffset.

参数:

key - key

offset - start offset of string

endOffset - end offset of string

返回:

substring.

mapSet

Long mapSet(String key,
            String field,
            String value)

Set the specified hash map field to the specified value. returns:

• 0: If the field already exists, and the HSET just produced an update of the value
• 1: if a new field is created

参数:

key - key to hold this hash map

field - field name

value - value

返回:

type of result

mapSet

Long mapSet(String key,
            Map<String,String> map)

Set the specified hash map field to the specified value. CMD: HMSET key values... returns:

• 0: If the field already exists, and the HSET just produced an update of the value
• 1: if a new field is created

参数:

key - key

map - value map

返回:

type of result

mapSetNx

Long mapSetNx(String key,
              String field,
              String value)

Set the specified hash field to the specified value if the field not exists. returns:

• 0: If the field already exists, and the HSET just produced an update of the value
• 1: if a new field is created

参数:

key - key

field - field

value - value

返回:

reply

mapIncreaseBy

Long mapIncreaseBy(String key,
                   String field,
                   long value)

Increment the number stored at field in the hash at key by value. If key does not exist, a new key holding a hash is created. If field does not exist or holds a string, the value is set to 0 before applying the operation. Since the value argument is signed you can use this command to perform both increments and decrements. reply The new value at field after the increment operation.

参数:

key - key

field - field

value - increment.

返回:

new value of field

mapIncreaseByFloat

Double mapIncreaseByFloat(String key,
                          String field,
                          float value)

Increment the number stored at field in the hash at key by a double precision floating point value. If key does not exist, a new key holding a hash is created. If field does not exist or holds a string, the value is set to 0 before applying the operation. Since the value argument is signed you can use this command to perform both increments and decrements. Double precision floating point reply The new value at field after the increment operation.

参数:

key - hash key

field - field

value - float increment

返回:

new value of field.

mapGet

String mapGet(String key,
              String field)

If key holds a hash, retrieve the value associated to the specified field. If the field is not found or the key does not exist, a special 'nil' value is returned.

参数:

key - key

field - field

返回:

value

mapMultiGet

List<String> mapMultiGet(String key,
                         String... fields)

Retrieve the values associated to the specified fields. If some of the specified fields do not exist, nil values are returned. Non existing keys are considered like empty hashes. Reply specifically a list of all the values associated with the specified fields, in the same order of the request.

参数:

key - key

fields - fields to request

返回:

reply list

mapLength

Long mapLength(String key)

Get the length of a hash key. The number of entries (fields) contained in the hash stored at key. If the specified key does not exist, 0 is returned assuming an empty hash.

参数:

key - hash key

返回:

number of entries

mapExist

Boolean mapExist(String key,
                 String field)

Test for existence of a specified field in a hash. Return true if the hash stored at key contains the specified field. Return false if the key is not found or the field is not present.

参数:

key - key

field - field

返回:

if exist

mapKeys

Set<String> mapKeys(String key)

Return all the fields in a hash.

参数:

key - hash key

返回:

key set

mapValues

List<String> mapValues(String key)

Return all the values in a hash.

参数:

key - hash key

返回:

value list

mapAll

Map<String,String> mapAll(String key)

Return all the fields and associated values in a hash.

参数:

key - hash key

返回:

hash content.

mapDelete

Long mapDelete(String key,
               String... fields)

Remove the specified field from an hash stored at key. returns:

• 0: Negative if operation.
• 1: If the field was present in the hash it is deleted

参数:

key - key

fields - fields to be removed

返回:

reply

listPush

Long listPush(String key,
              String... values)

Add the string value to the TAIL of the list. listRightPush(String, String...) If the key does not exist an empty list is created just before the append operation. If the key exists but is not a List an error is returned.

参数:

key - key

values - values to be push

返回:

list length.

listInsert

Long listInsert(String key,
                redis.clients.jedis.ListPosition where,
                String anchor,
                String value)

Insert a value into list of where with anchor. ListPosition.BEFORE "FOO" will display as "VALUE" "FOO" ListPosition.AFTER "FOO" will display as "FOO" "VALUE" if key of list or anchor does not exist . do nothing. return total size of list after operation.

参数:

key - key of list

where - position ListPosition

anchor - anchor value

value - value

返回:

listRightPush

Long listRightPush(String key,
                   String... values)

Add the string value to the TAIL of the list. If the key does not exist an empty list is created just before the append operation. If the key exists but is not a List an error is returned.

参数:

key - key

values - values to be push

返回:

list length.

listRightPushExist

Long listRightPushExist(String key,
                        String... values)

Add the string value to the TAIL of the list. If the key does not exist it will not operate anything. If the key exists but is not a List an error is returned.

参数:

key - key

values - values to be push

返回:

list length.

listLeftPush

Long listLeftPush(String key,
                  String... values)

Add the string value to the HEAD of the list. If the key does not exist an empty list is created just before the append operation. If the key exists but is not a List an error is returned.

参数:

key - key

values - values to be push

返回:

list length.

listLeftPushExist

Long listLeftPushExist(String key,
                       String... values)

Add the string value to the HEAD of the list. If the key does not exist it will not operate anything. If the key exists but is not a List an error is returned.

参数:

key - key

values - values to be push

返回:

list length.

listLength

Long listLength(String key)

Return the length of the list stored at the specified key. returns:

• 0: dose not exist or empty list
• If the value stored at key is not a list an error is returned.

参数:

key - list key

返回:

count of list

listRange

List<String> listRange(String key,
                       long start,
                       long end)

Return the specified elements of the list stored at the specified key. Start and end are zero-based indexes. 0 is the first element of the list (the list head), 1 the next element and so on.

For example LRANGE foobar 0 2 will return the first three elements of the list.

start and end can also be negative numbers indicating offsets from the end of the list. For example -1 is the last element of the list, -2 the penultimate element and so on.

Consistency with range functions in various programming languages

Note that if you have a list of numbers from 0 to 100, LRANGE 0 10 will return 11 elements, that is, rightmost item is included. This may or may not be consistent with behavior of range-related functions in your programming language of choice (think Ruby's Range.new, Array#slice or Python's range() function).

LRANGE behavior is consistent with one of Tcl.

Out-of-range indexes

Indexes out of range will not produce an error: if start is over the end of the list, or start > end, an empty list is returned. If end is over the end of the list Redis will threat it just like the last element of the list.

参数:

key - list key

start - start index

end - end index.

返回:

sub list of list

listTrim

String listTrim(String key,
                long start,
                long end)

Trim an existing list so that it will contain only the specified range of elements specified. Start and end are zero-based indexes. 0 is the first element of the list (the list head), 1 the next element and so on.

For example LTRIM foobar 0 2 will modify the list stored at foobar key so that only the first three elements of the list will remain.

start and end can also be negative numbers indicating offsets from the end of the list. For example -1 is the last element of the list, -2 the penultimate element and so on.

Indexes out of range will not produce an error: if start is over the end of the list, or start > end, an empty list is left as value. If end over the end of the list Redis will threat it just like the last element of the list.

Hint: the obvious use of LTRIM is together with LPUSH/RPUSH. For example:

lpush("mylist", "someelement"); ltrim("mylist", 0, 99); *

The above two commands will push elements in the list taking care that the list will not grow without limits. This is very useful when using Redis to store logs for example. It is important to note that when used in this way LTRIM is an O(1) operation because in the average case just one element is removed from the tail of the list.

参数:

key - list key

start - start index

end - end index.

返回:

Status code reply

listIndex

String listIndex(String key,
                 long index)

Return the specified element of the list stored at the specified key. 0 is the first element, 1 the second and so on. Negative indexes are supported, for example -1 is the last element, -2 the penultimate and so on.

If the value stored at key is not of list type an error is returned. If the index is out of range a 'nil' reply is returned.

Note that even if the average time complexity is O(n) asking for the first or the last element of the list is O(1).

参数:

key - list key

index - index

返回:

element at index.

listSet

String listSet(String key,
               long index,
               String value)

Set a new value as the element at index position of the List at key.

Out of range indexes will generate an error.

Similarly to other list commands accepting indexes, the index can be negative to access elements starting from the end of the list. So -1 is the last element, -2 is the penultimate, and so forth.

参数:

key - list key

index - index

value - value

返回:

Status code reply

listRemove

Long listRemove(String key,
                long count,
                String value)

Remove the first count occurrences of the value element from the list. If count is zero all the elements are removed. If count is negative elements are removed from tail to head, instead to go from head to tail that is the normal behaviour. So for example LREM with count -2 and hello as value to remove against the list (a,b,c,hello,x,hello,hello) will leave the list (a,b,c,hello,x). The number of removed elements is returned as an integer, see below for more information about the returned value. Note that non existing keys are considered like empty lists by LREM, so LREM against non existing keys will always return 0.

参数:

key - list key

count - count to be removed

value - value to be removed

返回:

The number of removed elements if the operation succeeded

listPop

String listPop(String key)

Pop out the value just push to the list. Atomically return and remove the first (LPOP) or last (RPOP) element of the list. For example if the list contains the elements "a","b","c" RPOP will return "c" and the list will become "a","b". listPush(String, String...) If the key does not exist or the list is already empty the special value 'nil' is returned.

参数:

key - list key

返回:

pop value

listRightPop

String listRightPop(String key)

Pop out the TAIL value just push to the list. Atomically return and remove the first (LPOP) or last (RPOP) element of the list. For example if the list contains the elements "a","b","c" RPOP will return "c" and the list will become "a","b". listPush(String, String...) If the key does not exist or the list is already empty the special value 'nil' is returned.

参数:

key - list key

返回:

pop value

listLeftPop

String listLeftPop(String key)

Pop out the HEAD value just push to the list. Atomically return and remove the first (LPOP) or last (RPOP) element of the list. For example if the list contains the elements "a","b","c" RPOP will return "c" and the list will become "a","b". listPush(String, String...) If the key does not exist or the list is already empty the special value 'nil' is returned.

参数:

key - list key

返回:

pop value

listRightPopLeftPush

String listRightPopLeftPush(String srcKey,
                            String targetKey)

Atomically return and remove the last (tail) element of the srckey list, and push the element as the first (head) element of the dstkey list. For example if the source list contains the elements "a","b","c" and the destination list contains the elements "foo","bar" after an RPOPLPUSH command the content of the two lists will be "a","b" and "c","foo","bar".

If the key does not exist or the list is already empty the special value 'nil' is returned. If the srckey and dstkey are the same the operation is equivalent to removing the last element from the list and pushing it as first element of the list, so it's a "list rotation" command.

参数:

srcKey - source key

targetKey - target key

返回:

pop value

listBlockingRightPopLeftPush

String listBlockingRightPopLeftPush(String srcKey,
                                    String targetKey,
                                    int timeout)

Pop a value from a list, push it to another list and return it; or block until one is available

参数:

srcKey - source key

targetKey - target key

timeout - timeout count.

返回:

pop value

listBlockingLeftPop

List<String> listBlockingLeftPop(int timeout,
                                 String... keys)

BLPOP (and BRPOP) is a blocking list pop primitive. You can see this commands as blocking versions of LPOP and RPOP able to block if the specified keys don't exist or contain empty lists.

The following is a description of the exact semantic. We describe BLPOP but the two commands are identical, the only difference is that BLPOP pops the element from the left (head) of the list, and BRPOP pops from the right (tail).

Non blocking behavior

When BLPOP is called, if at least one of the specified keys contain a non empty list, an element is popped from the head of the list and returned to the caller together with the name of the key (BLPOP returns a two elements array, the first element is the key, the second the popped value).

Keys are scanned from left to right, so for instance if you issue BLPOP list1 list2 list3 0 against a dataset where list1 does not exist but list2 and list3 contain non empty lists, BLPOP guarantees to return an element from the list stored at list2 (since it is the first non empty list starting from the left).

Blocking behavior

If none of the specified keys exist or contain non empty lists, BLPOP blocks until some other client performs a LPUSH or an RPUSH operation against one of the lists.

Once new data is present on one of the lists, the client finally returns with the name of the key unblocking it and the popped value.

When blocking, if a non-zero timeout is specified, the client will unblock returning a nil special value if the specified amount of seconds passed without a push operation against at least one of the specified keys.

The timeout argument is interpreted as an integer value. A timeout of zero means instead to block forever.

Multiple clients blocking for the same keys

Multiple clients can block for the same key. They are put into a queue, so the first to be served will be the one that started to wait earlier, in a first-blpopping first-served fashion.

blocking POP inside a MULTI/EXEC transaction

BLPOP and BRPOP can be used with pipelining (sending multiple commands and reading the replies in batch), but it does not make sense to use BLPOP or BRPOP inside a MULTI/EXEC block (a Redis transaction).

The behavior of BLPOP inside MULTI/EXEC when the list is empty is to return a multi-bulk nil reply, exactly what happens when the timeout is reached. If you like science fiction, think at it like if inside MULTI/EXEC the time will flow at infinite speed :)

参数:

timeout - time out

keys - keys

返回:

pop values

listBlockingRightPop

List<String> listBlockingRightPop(int timeout,
                                  String... keys)

listBlockingLeftPop(int, String...)

参数:

timeout - timeout

keys - keys

返回:

pop values

setsAdd

Long setsAdd(String key,
             String... values)

Add the specified member to the set value stored at key. If member is already a member of the set no operation is performed. If key does not exist a new set with the specified member as sole member is created. If the key exists but does not hold a set value an error is returned.

• 1 if the new element was added
• 0 if the element was already a member of the set

参数:

key - set key

values -

返回:

setsValues

Set<String> setsValues(String key)

Return all the members (elements) of the set value stored at key.

参数:

key - set key

返回:

set values

setsDelete

Long setsDelete(String key,
                String... values)

Remove the specified member from the set value stored at key. If member was not a member of the set no operation is performed. If key does not hold a set value an error is returned. returns:

• 1 if the new element was removed
• 0 if the new element was not a member of the set

参数:

key - set key

values - values to be removed

返回:

reply

setsPop

String setsPop(String key)

Remove a random element from a Set returning it as return value. If the Set is empty or the key does not exist, a nil object is returned. setsPop(String, long)

参数:

key - key

返回:

random value.

setsPop

Set<String> setsPop(String key,
                    long count)

Remove a random element from a Set returning it as return value. If the Set is empty or the key does not exist, a nil object is returned.

参数:

key - set key

count - value count to be pop

返回:

removed values

setsLength

Long setsLength(String key)

Return the set cardinality (number of elements). If the key does not exist 0 is returned, like for empty sets.

参数:

key - key

返回:

count of set

setsMove

Long setsMove(String srcKey,
              String targetKey,
              String value)

Move the specified member from the set at srckey to the set at dstkey. This operation is atomic, in every given moment the element will appear to be in the source or destination set for accessing clients.

If the source set does not exist or does not contain the specified element no operation is performed and zero is returned, otherwise the element is removed from the source set and added to the destination set. On success one is returned, even if the element was already present in the destination set.

An error is raised if the source or destination keys contain a non Set value.

returns:

• 1 if the element was moved
• 0 if the element was not found on the first set and no operation was performed

参数:

srcKey - source key

targetKey - target key

value - value to be moved

返回:

reply

setsExist

Boolean setsExist(String key,
                  String value)

Return true if member is a member of the set stored at key, otherwise false is returned.

参数:

key - key

value - value

返回:

if value exist

setsInter

Set<String> setsInter(String... keys)

Return the members of a set resulting from the intersection of all the sets hold at the specified keys. Like in listRange(String, long, long) (String, long, long) LRANGE} the result is sent to the client as a multi-bulk reply (see the protocol specification for more information). If just a single key is specified, then this command produces the same result as setsValues(String) (String) SMEMBERS}. Actually SMEMBERS is just syntax sugar for SINTER.

Non existing keys are considered like empty sets, so if one of the keys is missing an empty set is returned (since the intersection with an empty set always is an empty set).

参数:

keys - set keys

返回:

total set.

setsInterStore

Long setsInterStore(String destKey,
                    String... keys)

This command works exactly like setsInter(String...) SINTER} but instead of being returned the resulting set is stored as dstkey.

参数:

destKey - target key

keys - source keys

返回:

Status code reply

setsUnion

Set<String> setsUnion(String... keys)

Return the members of a set resulting from the union of all the sets hold at the specified keys. Like in listRange(String, long, long) LRANGE} the result is sent to the client as a multi-bulk reply (see the protocol specification for more information). If just a single key is specified, then this command produces the same result as setsValues(String) SMEMBERS}.

Non existing keys are considered like empty sets.

参数:

keys - set keys

返回:

union values of keys

setsUnionStore

Long setsUnionStore(String destKey,
                    String... keys)

This command works exactly like setsUnion(String...) SUNION} but instead of being returned the resulting set is stored as dstkey. Any existing value in dstkey will be over-written.

参数:

destKey - dest key

keys - keys

返回:

Status code reply

setsDifferent

Set<String> setsDifferent(String... keys)

Return the difference between the Set stored at key1 and all the Sets key2, ..., keyN

Example:

 key1 = [x, a, b, c]
 key2 = [c]
 key3 = [a, d]
 SDIFF key1,key2,key3 => [x, b]
 

Non existing keys are considered like empty sets.

参数:

keys - key1 to keys all.

返回:

different between set keys.

setsDifferentStore

Long setsDifferentStore(String destKey,
                        String... keys)

This command works exactly like setsDifferent(String...) but instead of being returned the resulting set is stored in destkey.

参数:

destKey - dest key

keys - keys

返回:

Status code reply

setsRandomValue

String setsRandomValue(String key)

Return a random element from a Set, without removing the element. If the Set is empty or the key does not exist, a nil object is returned.

参数:

key - set key

返回:

random value.

setsRandomValue

List<String> setsRandomValue(String key,
                             int count)

Return a count of random elements from a Set, without removing the element. If the Set is empty or the key does not exist, a nil list is returned.

参数:

key - set key

count - value count

返回:

value set.

zsetAdd

Long zsetAdd(String key,
             double score,
             String value)

Add the specified member having the specified score to the sorted set stored at key. If member is already a member of the sorted set the score is updated, and the element reinserted in the right position to ensure sorting. If key does not exist a new sorted set with the specified member as sole member is created. If the key exists but does not hold a sorted set value an error is returned.

The score value can be the string representation of a double precision floating point number. returns:

• 1 if the new element was added
• 0 if the element was already a member of the sorted set and the score was updated

参数:

key - key

score - sort score of this value

value - value

返回:

status code

zsetAdd

Long zsetAdd(String key,
             double score,
             String value,
             redis.clients.jedis.params.ZAddParams params)

Add the specified member having the specified score to the sorted set stored at key.

参数:

key - key

score - the score of value

value - value of score

params - set params

返回:

status code

zsetAdd

Long zsetAdd(String key,
             Map<String,Double> valueScores)

Add the specified member having the specified score to the sorted set stored at key. with a map contains value and value score.

参数:

key - key

valueScores - value score pair

返回:

status code

zsetAdd

Long zsetAdd(String key,
             Map<String,Double> valueScores,
             redis.clients.jedis.params.ZAddParams params)

Add the specified member having the specified score to the sorted set stored at key. with a map contains value and value score and Zset add Params.

参数:

key - key

valueScores - value score pair

params - add param

返回:

status code

zsetRange

Set<String> zsetRange(String key,
                      long start,
                      long end)

Return a range of zset . this function such as listRange(String, long, long)

参数:

key - set key

start - start index

end - end index.

返回:

sub range of zset.

zsetDelete

Long zsetDelete(String key,
                String... values)

Remove the specified member from the sorted set value stored at key. If member was not a member of the set no operation is performed. If key does not not hold a set value an error is returned.

参数:

key - zset key

values - values

返回:

Integer reply, specifically: 1 if the new element was removed 0 if the new element was not a member of the set

zsetIncreaseBy

Double zsetIncreaseBy(String key,
                      double increment,
                      String value)

If member already exists in the sorted set adds the increment to its score and updates the position of the element in the sorted set accordingly. If member does not already exist in the sorted set it is added with increment as score (that is, like if the previous score was virtually zero). If key does not exist a new sorted set with the specified member as sole member is created. If the key exists but does not hold a sorted set value an error is returned.

The score value can be the string representation of a double precision floating point number. It's possible to provide a negative value to perform a decrement.

For an introduction to sorted sets check the Introduction to Redis data types page.

参数:

key - set key

increment - increment

value - value

返回:

The new score

zsetIncreaseBy

Double zsetIncreaseBy(String key,
                      double increment,
                      String value,
                      redis.clients.jedis.params.ZIncrByParams params)

If member already exists in the sorted set adds the increment to its score and updates the position of the element in the sorted set accordingly. If member does not already exist in the sorted set it is added with increment as score (that is, like if the previous score was virtually zero). If key does not exist a new sorted set with the specified member as sole member is created. If the key exists but does not hold a sorted set value an error is returned.

The score value can be the string representation of a double precision floating point number. It's possible to provide a negative value to perform a decrement.

For an introduction to sorted sets check the Introduction to Redis data types page.

参数:

key - set key

increment - increment

value - value

params - incrBy params

返回:

The new score

zsetIndexOf

Long zsetIndexOf(String key,
                 String value)

Return the rank (or index) of member in the sorted set at key, with scores being ordered from low to high.

When the given member does not exist in the sorted set, the special value 'nil' is returned. The returned rank (or index) of the member is 0-based for both commands.

参数:

key - zset key

value - zset value

返回:

Integer reply or a nil bulk reply, specifically: the rank of the element as an integer reply if the element exists. A nil bulk reply if there is no such element.

zsetReverseIndexOf

Long zsetReverseIndexOf(String key,
                        String value)

Return the rank (or index) of member in the sorted set at key, with scores being ordered from high to low.

When the given member does not exist in the sorted set, the special value 'nil' is returned. The returned rank (or index) of the member is 0-based for both commands.

参数:

key - zset key

value - zset value

返回:

Integer reply or a nil bulk reply, specifically: the rank of the element as an integer reply if the element exists. A nil bulk reply if there is no such element.

zsetReverseRange

Set<String> zsetReverseRange(String key,
                             long start,
                             long end)

return reverse range of zset. zsetRange(String, long, long)

参数:

key - zset key

start - start index

end - end index

返回:

set values

zsetLength

Long zsetLength(String key)

Return the sorted set cardinality (number of elements). If the key does not exist 0 is returned, like for empty sorted sets.

参数:

key - key

返回:

length of zset

zsetScore

Double zsetScore(String key,
                 String value)

Return the score of the specified element of the sorted set at key. If the specified element does not exist in the sorted set, or the key does not exist at all, a special 'nil' value is returned.

参数:

key - zset key

value - zset value

返回:

score of value in key.

zsetRangeWithScores

Set<redis.clients.jedis.Tuple> zsetRangeWithScores(String key,
                                                   long start,
                                                   long end)

return range of zset. zsetRange(String, long, long) witch is contain in Tuple with element and score.

参数:

key - zset key

start - start index

end - end index

返回:

set values

zsetRangeByScore

Set<String> zsetRangeByScore(String key,
                             double min,
                             double max)

Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).

The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).

Using the optional zsetRangeByScore(String, double, double) LIMIT} it's possible to get only a range of the matching elements in an SQL-alike way. Note that if offset is large the commands needs to traverse the list for offset elements and this adds up to the O(M) figure.

The command is similar to zsetRangeByScore(String, double, double)ZRANGEBYSCORE} but instead of returning the actual elements in the specified interval, it just returns the number of matching elements.

Exclusive intervals and infinity

min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".

Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:

ZRANGEBYSCORE zset (1.3 5

Will return all the values with score > 1.3 and <= 5, while for instance:

ZRANGEBYSCORE zset (5 (10

Will return all the values with score > 5 and < 10 (5 and 10 excluded).

参数:

key - set key

min - min score

max - max score

返回:

Multi bulk reply specifically a list of elements in the specified score range.

另请参阅:

zsetRangeByScore(String, double, double), zsetRangeByScore(String, double, double, int, int), zsetRangeByScoreWithScores(String, double, double), zsetRangeByScoreWithScores(String, double, double, int, int)

zsetRangeByScore

Set<String> zsetRangeByScore(String key,
                             String min,
                             String max)

zsetRangeByScore(String, String, String)

参数:

key - set key

min - min score

max - max score

返回:

Multi bulk reply specifically a list of elements in the specified score range.

zsetRangeByScore

Set<String> zsetRangeByScore(String key,
                             double min,
                             double max,
                             int offset,
                             int count)

Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).

The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).

Using the optional LIMIT it's possible to get only a range of the matching elements in an SQL-alike way. Note that if offset is large the commands needs to traverse the list for offset elements and this adds up to the O(M) figure.

The command is similar to ZRANGEBYSCORE but instead of returning the actual elements in the specified interval, it just returns the number of matching elements.

Exclusive intervals and infinity

min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".

Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:

ZRANGEBYSCORE zset (1.3 5

Will return all the values with score > 1.3 and <= 5, while for instance:

ZRANGEBYSCORE zset (5 (10

Will return all the values with score > 5 and < 10 (5 and 10 excluded).

参数:

key - set key

min - min score

max - max score

offset - offset index

count - count of set

返回:

Multi bulk reply specifically a list of elements in the specified score range.

zsetRangeByScore

Set<String> zsetRangeByScore(String key,
                             String min,
                             String max,
                             int offset,
                             int count)

zsetRangeByScore(String, String, String, int, int)

参数:

key - set key

min - min score

max - max score

offset - offset index

count - count of set

返回:

Multi bulk reply specifically a list of elements in the specified score range.

zsetRangeByScoreWithScores

Set<redis.clients.jedis.Tuple> zsetRangeByScoreWithScores(String key,
                                                          double min,
                                                          double max)

Return the all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).

The elements having the same score are returned sorted lexicographically as ASCII strings (this follows from a property of Redis sorted sets and does not involve further computation).

Using the optional zsetRangeByScore(String, String, String, int, int) it's possible to get only a range of the matching elements in an SQL-alike way. Note that if offset is large the commands needs to traverse the list for offset elements and this adds up to the O(M) figure.

The command is similar to ZRANGEBYSCORE but instead of returning the actual elements in the specified interval, it just returns the number of matching elements.

Exclusive intervals and infinity

min and max can be -inf and +inf, so that you are not required to know what's the greatest or smallest element in order to take, for instance, elements "up to a given value".

Also while the interval is for default closed (inclusive) it's possible to specify open intervals prefixing the score with a "(" character, so for instance:

ZRANGEBYSCORE zset (1.3 5

Will return all the values with score > 1.3 and <= 5, while for instance:

ZRANGEBYSCORE zset (5 (10

Will return all the values with score > 5 and < 10 (5 and 10 excluded).

参数:

key - key

min - min score

max - max score

返回:

value score pair

zsetRangeByScoreWithScores

Set<redis.clients.jedis.Tuple> zsetRangeByScoreWithScores(String key,
                                                          String min,
                                                          String max)

zsetRangeByScoreWithScores(String, String, String)

参数:

key - key

min - min score

max - max score

返回:

value score pair

zsetRangeByScoreWithScores

Set<redis.clients.jedis.Tuple> zsetRangeByScoreWithScores(String key,
                                                          double min,
                                                          double max,
                                                          int offset,
                                                          int count)

zsetRangeByScoreWithScores(String, String, String) zsetRangeByScore(String, double, double, int ,int)

参数:

key - key

min - min score

max - max score

返回:

value score pair

zsetRangeByScoreWithScores

Set<redis.clients.jedis.Tuple> zsetRangeByScoreWithScores(String key,
                                                          String min,
                                                          String max,
                                                          int offset,
                                                          int count)

zsetRangeByScoreWithScores(String, String, String) zsetRangeByScore(String, double, double, int ,int)

参数:

key - key

min - min score

max - max score

返回:

value score pair

zsetReverseRangeWithScores

Set<redis.clients.jedis.Tuple> zsetReverseRangeWithScores(String key,
                                                          long start,
                                                          long end)

return reverse range of zset. zsetRange(String, long, long) witch is contain in Tuple with element and score.

参数:

key - zset key

start - start index

end - end index

返回:

set values

zsetReverseRangeByScore

Set<String> zsetReverseRangeByScore(String key,
                                    double min,
                                    double max)

zsetRangeByScore(String, double, double)

参数:

key - key

min - min

max - max

返回:

values

zsetReverseRangeByScore

Set<String> zsetReverseRangeByScore(String key,
                                    String min,
                                    String max)

zsetReverseRangeByScore

Set<String> zsetReverseRangeByScore(String key,
                                    double min,
                                    double max,
                                    int offset,
                                    int count)

zsetReverseRangeByScore

Set<String> zsetReverseRangeByScore(String key,
                                    String min,
                                    String max,
                                    int offset,
                                    int count)

zsetReverseRangeByScoreWithScores

Set<redis.clients.jedis.Tuple> zsetReverseRangeByScoreWithScores(String key,
                                                                 double min,
                                                                 double max)

zsetReverseRangeByScoreWithScores

Set<redis.clients.jedis.Tuple> zsetReverseRangeByScoreWithScores(String key,
                                                                 String min,
                                                                 String max)

zsetReverseRangeByScoreWithScores

Set<redis.clients.jedis.Tuple> zsetReverseRangeByScoreWithScores(String key,
                                                                 double min,
                                                                 double max,
                                                                 int offset,
                                                                 int count)

zsetReverseRangeByScoreWithScores

Set<redis.clients.jedis.Tuple> zsetReverseRangeByScoreWithScores(String key,
                                                                 String min,
                                                                 String max,
                                                                 int offset,
                                                                 int count)

zsetDeleteRangeByIndex

Long zsetDeleteRangeByIndex(String key,
                            long start,
                            long stop)

Remove all elements in the sorted set at key with rank between start and end. Start and end are 0-based with rank 0 being the element with the lowest score. Both start and end can be negative numbers, where they indicate offsets starting at the element with the highest rank. For example: -1 is the element with the highest score, -2 the element with the second highest score and so forth.

参数:

key - set key

start - start index

stop - end index

返回:

status reply

zsetDeleteRangeByScore

Long zsetDeleteRangeByScore(String key,
                            double min,
                            double max)

Remove all the elements in the sorted set at key with a score between min and max (including elements with score equal to min or max).

参数:

key - key

min - min

max - max

返回:

status reply

zsetDeleteRangeByScore

Long zsetDeleteRangeByScore(String key,
                            String min,
                            String max)

zsetDeleteRangeByScore(String, String, String)

参数:

key - key

min - min

max - max

返回:

status reply

zsetUnionStore

Long zsetUnionStore(String destKey,
                    String... keys)

Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.

As the terms imply, the ZINTERSTORE command requires an element to be present in each of the given inputs to be inserted in the result. The ZUNIONSTORE command inserts all elements across all inputs.

Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.

With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.

参数:

destKey - target key

keys - source set's keys

返回:

Integer reply, specifically the number of elements in the sorted set at dstkey

zsetUnionStore

Long zsetUnionStore(String destKey,
                    redis.clients.jedis.ZParams params,
                    String... keys)

Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.

As the terms imply, the ZINTERSTORE command requires an element to be present in each of the given inputs to be inserted in the result. The ZUNIONSTORE command inserts all elements across all inputs.

Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.

With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.

参数:

destKey - target key

params - set params

keys - source set's keys

返回:

Integer reply, specifically the number of elements in the sorted set at dstkey

zsetInterStore

Long zsetInterStore(String destKey,
                    String... keys)

Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.

As the terms imply, the ZINTERSTORE command requires an element to be present in each of the given inputs to be inserted in the result. The ZUNIONSTORE command inserts all elements across all inputs.

Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.

With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.

参数:

destKey - target key

keys - source set's keys

返回:

Integer reply, specifically the number of elements in the sorted set at dstkey

zsetInterStore

Long zsetInterStore(String destKey,
                    redis.clients.jedis.ZParams params,
                    String... keys)

Creates a union or intersection of N sorted sets given by keys k1 through kN, and stores it at dstkey. It is mandatory to provide the number of input keys N, before passing the input keys and the other (optional) arguments.

As the terms imply, the ZINTERSTORE command requires an element to be present in each of the given inputs to be inserted in the result. The ZUNIONSTORE command inserts all elements across all inputs.

Using the WEIGHTS option, it is possible to add weight to each input sorted set. This means that the score of each element in the sorted set is first multiplied by this weight before being passed to the aggregation. When this option is not given, all weights default to 1.

With the AGGREGATE option, it's possible to specify how the results of the union or intersection are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to be either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists.

参数:

destKey - target key

params - set params

keys - source set's keys

返回:

Integer reply, specifically the number of elements in the sorted set at dstkey

zsetLexLength

Long zsetLexLength(String key,
                   String min,
                   String max)

Return count of set values that lex value between min and max such as: a -> z

参数:

key - key

min - min lex

max - max lex

返回:

count

zsetRangeByLex

Set<String> zsetRangeByLex(String key,
                           String min,
                           String max)

zsetRangeByScore(String, double, double) zsetLexLength(String, String, String)

参数:

key - key

min - min lex

max - max lex

返回:

values between min and max

zsetRangeByLex

Set<String> zsetRangeByLex(String key,
                           String min,
                           String max,
                           int offset,
                           int count)

zsetReverseRangeByLex

Set<String> zsetReverseRangeByLex(String key,
                                  String min,
                                  String max)

zsetReverseRangeByLex

Set<String> zsetReverseRangeByLex(String key,
                                  String min,
                                  String max,
                                  int offset,
                                  int count)

zsetDeleteRangeByLex

Long zsetDeleteRangeByLex(String key,
                          String min,
                          String max)

sort

List<String> sort(String key)

Sort a Set or a List.

Sort the elements contained in the List, Set, or Sorted Set value at key. By default sorting is numeric with elements being compared as double precision floating point numbers. This is the simplest form of SORT.

参数:

key - key

返回:

sorted values

另请参阅:

sortStore(String, String), sort(String, SortingParams), sortStore(String, SortingParams, String)

sort

List<String> sort(String key,
                  redis.clients.jedis.SortingParams sortingParameters)

Sort a Set or a List accordingly to the specified parameters.

examples:

Given are the following sets and key/values:

 x = [1, 2, 3]
 y = [a, b, c]

 k1 = z
 k2 = y
 k3 = x

 w1 = 9
 w2 = 8
 w3 = 7
 

Sort Order:

 sort(x) or sort(x, sp.asc())
 -> [1, 2, 3]

 sort(x, sp.desc())
 -> [3, 2, 1]

 sort(y)
 -> [c, a, b]

 sort(y, sp.alpha())
 -> [a, b, c]

 sort(y, sp.alpha().desc())
 -> [c, a, b]
 

Limit (e.g. for Pagination):

 sort(x, sp.limit(0, 2))
 -> [1, 2]

 sort(y, sp.alpha().desc().limit(1, 2))
 -> [b, a]
 

Sorting by external keys:

 sort(x, sb.by(w*))
 -> [3, 2, 1]

 sort(x, sb.by(w*).desc())
 -> [1, 2, 3]
 

Getting external keys:

 sort(x, sp.by(w*).get(k*))
 -> [x, y, z]

 sort(x, sp.by(w*).get(#).get(k*))
 -> [3, x, 2, y, 1, z]
 

参数:

key - key

sortingParameters - sorting parameters

返回:

sorted values

sortStore

Long sortStore(String key,
               String destKey)

Sort a Set or a List and Store the Result at dstkey.

Sort the elements contained in the List, Set, or Sorted Set value at key and store the result at dstkey. By default sorting is numeric with elements being compared as double precision floating point numbers. This is the simplest form of SORT.

参数:

key - key

destKey - target key

返回:

The number of elements of the list at dstkey.

sortStore

Long sortStore(String key,
               redis.clients.jedis.SortingParams sortingParameters,
               String destKey)

Sort a Set or a List and Store the Result at dstkey.

Sort the elements contained in the List, Set, or Sorted Set value at key and store the result at dstkey. By default sorting is numeric with elements being compared as double precision floating point numbers. This is the simplest form of SORT.

参数:

key - key

sortingParameters - param

destKey - target key

返回:

The number of elements of the list at dstkey.

geoAdd

Long geoAdd(String key,
            double longitude,
            double latitude,
            String value)

Add a geo location of value

参数:

key - key to geo

longitude - longitude

latitude - latitude

value - value

返回:

status code

geoAdd

Long geoAdd(String key,
            Map<String,redis.clients.jedis.GeoCoordinate> memberCoordinateMap)

geoDistant

Double geoDistant(String key,
                  String source,
                  String target)

geoDistant

Double geoDistant(String key,
                  String source,
                  String target,
                  redis.clients.jedis.GeoUnit unit)

geoHash

List<String> geoHash(String key,
                     String... values)

geoPos

List<redis.clients.jedis.GeoCoordinate> geoPos(String key,
                                               String... values)

geoRadius

List<redis.clients.jedis.GeoRadiusResponse> geoRadius(String key,
                                                      double longitude,
                                                      double latitude,
                                                      double radius,
                                                      redis.clients.jedis.GeoUnit unit)

Find values that distant is in radius with longitude and latitude.

参数:

key - key

longitude - lon

latitude - lat

radius - radius

unit - unit

返回:

members.

geoRadiusReadonly

List<redis.clients.jedis.GeoRadiusResponse> geoRadiusReadonly(String key,
                                                              double longitude,
                                                              double latitude,
                                                              double radius,
                                                              redis.clients.jedis.GeoUnit unit)

geoRadius

List<redis.clients.jedis.GeoRadiusResponse> geoRadius(String key,
                                                      double longitude,
                                                      double latitude,
                                                      double radius,
                                                      redis.clients.jedis.GeoUnit unit,
                                                      redis.clients.jedis.params.GeoRadiusParam param)

geoRadiusReadonly

List<redis.clients.jedis.GeoRadiusResponse> geoRadiusReadonly(String key,
                                                              double longitude,
                                                              double latitude,
                                                              double radius,
                                                              redis.clients.jedis.GeoUnit unit,
                                                              redis.clients.jedis.params.GeoRadiusParam param)

geoRadiusByMember

List<redis.clients.jedis.GeoRadiusResponse> geoRadiusByMember(String key,
                                                              String member,
                                                              double radius,
                                                              redis.clients.jedis.GeoUnit unit)

geoRadiusByMemberReadonly

List<redis.clients.jedis.GeoRadiusResponse> geoRadiusByMemberReadonly(String key,
                                                                      String member,
                                                                      double radius,
                                                                      redis.clients.jedis.GeoUnit unit)

geoRadiusByMember

List<redis.clients.jedis.GeoRadiusResponse> geoRadiusByMember(String key,
                                                              String member,
                                                              double radius,
                                                              redis.clients.jedis.GeoUnit unit,
                                                              redis.clients.jedis.params.GeoRadiusParam param)

geoRadiusByMemberReadonly

List<redis.clients.jedis.GeoRadiusResponse> geoRadiusByMemberReadonly(String key,
                                                                      String member,
                                                                      double radius,
                                                                      redis.clients.jedis.GeoUnit unit,
                                                                      redis.clients.jedis.params.GeoRadiusParam param)

subscribe

void subscribe(redis.clients.jedis.JedisPubSub jedisPubSub,
               String... channels)

subscribe channels ..

参数:

jedisPubSub - callback when channels has publish message

channels - changes

publish

Long publish(String channel,
             String message)

publish message to channel.

参数:

channel - target channel.

message - message

返回:

status code

patternSubscribe

void patternSubscribe(redis.clients.jedis.JedisPubSub jedisPubSub,
                      String... patterns)

subscribe channels in patterns...

参数:

jedisPubSub - callback

patterns - channel pattern

eval

Object eval(String script,
            List<String> keys,
            List<String> args)

Eval a script in lua . redis 127.0.0.1:6379> eval "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1 key2 first second 1) "key1" 2) "key2" 3) "first" 4) "second"

参数:

script - script content

keys - keys

args - arg

返回:

object

eval

Object eval(String script,
            int keyCount,
            String... params)

eval

Object eval(String script)

evalSha

Object evalSha(String sha1)

evalSha

Object evalSha(String sha1,
               List<String> keys,
               List<String> args)

evalSha

Object evalSha(String sha1,
               int keyCount,
               String... params)

scriptExists

Boolean scriptExists(String sha1)

scriptExists

List<Boolean> scriptExists(String... sha1)

scriptLoad

String scriptLoad(String script)