org.jredis

Interface JRedisFuture

All Known Implementing Classes:

JRedisAsyncClient, JRedisChunkedPipeline, JRedisFutureSupport, JRedisPipeline

public interface JRedisFuture

The asynchronous interface to Redis.

This is effectively a one to one mapping to Redis commands. Depending on the implementation either the redis response and/or redis write are asynchronous. Regardless, each method returns an extension of Future and the returned results conforms to the contract of that interface (which you should review).

If your request results in a RedisException, the call to Future.get() (of either flavor) will raise a ExecutionException with Throwable.getCause() returning the underlying RedisException.

Similarly, if the request results in either ClientRuntimeException or ProviderException, the Future's ExecutionException will wrap these as the cause.

Beyond that , just be aware that an implementation may throw ClientRuntimeException or an extension to report problems (typically connectivity) or ProviderException (to highlight implementation features/bugs). These are RuntimeException that have been encountered while trying to queue your request.

Note that this interface provides no guarantees whatsoever regarding the execution of your requests beyond the strict ordering of the requests per your invocations. Specifically, in the event of connection issues, this interface's contract does not place any requirements on the implementation beyond to notify the user of such issues either during a call to this interface, or, on the attempt to get the result of a pending response on Future.get(). Refer to the documentation of the implementation of JRedisFuture for the specifics of behavior in context of errors.

Since:

alpha.0

Version:

alpha.0, 04/02/09

Author:

Joubin (alphazero@sensesay.net)

Method Summary

Modifier and Type	Method and Description
<K> Future<Long>	append(K key, byte[] value)
<K> Future<Long>	append(K key, Number numberValue)
<K> Future<Long>	append(K key, String stringValue)
<K,T extends Serializable> Future<Long>	append(K key, T object)
<K> Future<String>	bgrewriteaof()
<K> Future<ResponseStatus>	bgsave()
<K> Future<Long>	dbsize()
<K> Future<ObjectInfo>	debug(K key)
<K> Future<Long>	decr(K key)
<K> Future<Long>	decrby(K key, int delta)
<K> Future<Long>	del(K... keys)
<K> Future<byte[]>	echo(byte[] msg)
<K> Future<byte[]>	echo(Number msg)
<K> Future<byte[]>	echo(String msg)
<K,T extends Serializable> Future<byte[]>	echo(T msg)
<K> Future<Boolean>	exists(K key)
<K> Future<Boolean>	expire(K key, int ttlseconds)
<K> Future<Boolean>	expireat(K key, long epochtimeMillisecs)
Future<ResponseStatus>	flush() Optional connection control command.
<K> Future<ResponseStatus>	flushall() Flushes all dbs in the connect Redis server, regardless of which db was selected on connect time.
<K> Future<ResponseStatus>	flushdb() Flushes the db you selected when connecting to Redis server.
<K> Future<byte[]>	get(K key)
<K> Future<Boolean>	getbit(K key, int offset)
<K> Future<byte[]>	getset(K key, byte[] value)
<K> Future<byte[]>	getset(K key, Number numberValue)
<K> Future<byte[]>	getset(K key, String stringValue)
<K,T extends Serializable> Future<byte[]>	getset(K key, T object)
<K> Future<Boolean>	hdel(K key, K entry)
<K> Future<Boolean>	hexists(K key, K entry)
<K> Future<byte[]>	hget(K key, K entry)
<K> Future<Map<byte[],byte[]>>	hgetall(K key)
<K> Future<Long>	hincrby(K key, K entry, long increment)
<K> Future<List<byte[]>>	hkeys(K key)
<K> Future<Long>	hlen(K key)
<K> Future<Boolean>	hset(K key, K entry, byte[] value)
<K> Future<Boolean>	hset(K key, K entry, Number number)
<K> Future<Boolean>	hset(K key, K entry, String string)
<K,T extends Serializable> Future<Boolean>	hset(K key, K entry, T object)
<K> Future<List<byte[]>>	hvals(K key)
<K> Future<Long>	incr(K key)
<K> Future<Long>	incrby(K key, int delta)
<K> Future<Map<String,String>>	info()
<K> Future<List<byte[]>>	keys() Convenience method.
<K> Future<List<byte[]>>	keys(K pattern)
<K> Future<Long>	lastsave()
<K> Future<byte[]>	lindex(K listkey, long index)
<K> Future<Long>	llen(K listkey) Given a 'list' key, returns the number of items in the list.
<K> Future<byte[]>	lpop(K listkey)
<K> Future<Long>	lpush(K listkey, byte[] value)
<K> Future<Long>	lpush(K listkey, Number numberValue)
<K> Future<Long>	lpush(K listkey, String stringValue)
<K,T extends Serializable> Future<Long>	lpush(K listkey, T object)
<K> Future<List<byte[]>>	lrange(K listkey, long from, long to)
<K> Future<Long>	lrem(K listkey, byte[] value, int count)
<K> Future<Long>	lrem(K listkey, Number numberValue, int count)
<K> Future<Long>	lrem(K listkey, String stringValue, int count)
<K,T extends Serializable> Future<Long>	lrem(K listkey, T object, int count)
<K> Future<ResponseStatus>	lset(K key, long index, byte[] value)
<K> Future<ResponseStatus>	lset(K key, long index, Number numberValue)
<K> Future<ResponseStatus>	lset(K key, long index, String stringValue)
<K,T extends Serializable> Future<ResponseStatus>	lset(K key, long index, T object)
<K> Future<ResponseStatus>	ltrim(K listkey, long keepFrom, long keepTo)
<K> Future<List<byte[]>>	mget(String... keys)
<K> Future<Boolean>	move(K key, int dbIndex) Moves the given key from the currently selected db to the one indicated by dbIndex.
<K> Future<ResponseStatus>	mset(KeyValueSet.ByteArrays<K> mappings)
<K> Future<ResponseStatus>	mset(KeyValueSet.Numbers<K> mappings)
<K,T extends Serializable> Future<ResponseStatus>	mset(KeyValueSet.Objects<K,T> mappings)
<K> Future<ResponseStatus>	mset(KeyValueSet.Strings<K> mappings)
<K> Future<ResponseStatus>	mset(Map<K,byte[]> keyValueMap)
<K> Future<Boolean>	msetnx(KeyValueSet.ByteArrays<K> mappings)
<K> Future<Boolean>	msetnx(KeyValueSet.Numbers<K> mappings)
<K,T extends Serializable> Future<Boolean>	msetnx(KeyValueSet.Objects<K,T> mappings)
<K> Future<Boolean>	msetnx(KeyValueSet.Strings<K> mappings)
<K> Future<Boolean>	msetnx(Map<K,byte[]> keyValueMap)
<K> Future<ResponseStatus>	ping() Ping redis
<K> Future<ResponseStatus>	quit() Disconnects the client.
<K> Future<byte[]>	randomkey()
<K> Future<ResponseStatus>	rename(K oldkey, K newkey)
<K> Future<Boolean>	renamenx(K oldkey, K brandnewkey)
<K> Future<byte[]>	rpop(K listkey)
<K> Future<byte[]>	rpoplpush(String srcList, String destList)
<K> Future<Long>	rpush(K listkey, byte[] value)
<K> Future<Long>	rpush(K listkey, Number numberValue)
<K> Future<Long>	rpush(K listkey, String stringValue)
<K,T extends Serializable> Future<Long>	rpush(K listkey, T object)
<K> Future<Boolean>	sadd(K setkey, byte[] member)
<K> Future<Boolean>	sadd(K setkey, Number numberValue)
<K> Future<Boolean>	sadd(K setkey, String stringValue)
<K,T extends Serializable> Future<Boolean>	sadd(K setkey, T object)
<K> Future<ResponseStatus>	save()
<K> Future<Long>	scard(K setKey)
<K> Future<List<byte[]>>	sdiff(K set1, K... sets)
<K> Future<ResponseStatus>	sdiffstore(K destSetKey, K... sets)
<K> Future<ResponseStatus>	set(K key, byte[] value) Bind the value to key.
<K> Future<ResponseStatus>	set(K key, Number numberValue) Convenient method for String numeric values binding
<K> Future<ResponseStatus>	set(K key, String stringValue) Convenient method for String data binding
<K,T extends Serializable> Future<ResponseStatus>	set(K key, T object) Binds the given java Object to the key.
<K> Future<Boolean>	setbit(K key, int offset, boolean value)
<K> Future<Boolean>	setnx(K key, byte[] value)
<K> Future<Boolean>	setnx(K key, Number numberValue)
<K> Future<Boolean>	setnx(K key, String stringValue)
<K,T extends Serializable> Future<Boolean>	setnx(K key, T object)
<K> Future<List<byte[]>>	sinter(K set1, K... sets)
<K> Future<ResponseStatus>	sinterstore(K destSetKey, K... sets)
<K> Future<Boolean>	sismember(K setkey, byte[] member)
<K> Future<Boolean>	sismember(K setkey, Number numberValue)
<K> Future<Boolean>	sismember(K setkey, String stringValue)
<K,T extends Serializable> Future<Boolean>	sismember(K setkey, T object)
<K> Future<ResponseStatus>	slaveof(String host, int port)
<K> Future<ResponseStatus>	slaveofnone() Convenience method.
<K> Future<List<byte[]>>	smembers(K setkey)
<K> Future<Boolean>	smove(K srcKey, K destKey, byte[] member)
<K> Future<Boolean>	smove(K srcKey, K destKey, Number numberValue)
<K> Future<Boolean>	smove(K srcKey, K destKey, String stringValue)
<K,T extends Serializable> Future<Boolean>	smove(K srcKey, K destKey, T object)
<K> Sort	sort(K key) For Usage details regarding sort semantics, see JRedis.sort(K).
<K> Future<byte[]>	spop(K setkey)
<K> Future<byte[]>	srandmember(K setkey)
<K> Future<Boolean>	srem(K setkey, byte[] member)
<K> Future<Boolean>	srem(K setkey, Number numberValue)
<K> Future<Boolean>	srem(K setkey, String stringValue)
<K,T extends Serializable> Future<Boolean>	srem(K setkey, T object)
<K> Future<byte[]>	substr(K listkey, long from, long to)
<K> Future<List<byte[]>>	sunion(K set1, K... sets)
<K> Future<ResponseStatus>	sunionstore(K destSetKey, K... sets)
<K> Future<Long>	ttl(K key)
<K> Future<RedisType>	type(K key)
<K> Future<Boolean>	zadd(K setkey, double score, byte[] member)
<K> Future<Boolean>	zadd(K setkey, double score, Number numberValue)
<K> Future<Boolean>	zadd(K setkey, double score, String stringValue)
<K,T extends Serializable> Future<Boolean>	zadd(K setkey, double score, T object)
<K> Future<Long>	zcard(K setKey)
<K> Future<Long>	zcount(K setkey, double minScore, double maxScore)
<K> Future<Double>	zincrby(K setkey, double score, byte[] member)
<K> Future<Double>	zincrby(K setkey, double score, Number numberValue)
<K> Future<Double>	zincrby(K setkey, double score, String stringValue)
<K,T extends Serializable> Future<Double>	zincrby(K setkey, double score, T object)
<K> Future<List<byte[]>>	zrange(K setkey, long from, long to)
<K> Future<List<byte[]>>	zrangebyscore(K setkey, double minScore, double maxScore)
<K> Future<List<ZSetEntry>>	zrangebyscoreSubset(K setkey, double minScore, double maxScore)
<K> Future<List<ZSetEntry>>	zrangeSubset(K setkey, long from, long to) Equivalent to JRedis#zrange(String, long, long) with the Command.Option#WITHSCORES.
<K> Future<Long>	zrank(K setkey, byte[] member)
<K> Future<Long>	zrank(K setkey, Number numberValue)
<K> Future<Long>	zrank(K setkey, String stringValue)
<K,T extends Serializable> Future<Long>	zrank(K setkey, T object)
<K> Future<Boolean>	zrem(K setkey, byte[] member)
<K> Future<Boolean>	zrem(K setkey, Number numberValue)
<K> Future<Boolean>	zrem(K setkey, String stringValue)
<K,T extends Serializable> Future<Boolean>	zrem(K setkey, T object)
<K> Future<Long>	zremrangebyrank(K setkey, long minRank, long maxRank)
<K> Future<Long>	zremrangebyscore(K setkey, double minScore, double maxScore)
<K> Future<List<byte[]>>	zrevrange(K setkey, long from, long to)
<K> Future<List<ZSetEntry>>	zrevrangeSubset(K setkey, long from, long to) Equivalent to JRedis#zrange(String, long, long) with the Command.Option#WITHSCORES.
<K> Future<Long>	zrevrank(K setkey, byte[] member)
<K> Future<Long>	zrevrank(K setkey, Number numberValue)
<K> Future<Long>	zrevrank(K setkey, String stringValue)
<K,T extends Serializable> Future<Long>	zrevrank(K setkey, T object)
<K> Future<Double>	zscore(K setkey, byte[] member)
<K> Future<Double>	zscore(K setkey, Number numberValue)
<K> Future<Double>	zscore(K setkey, String stringValue)
<K,T extends Serializable> Future<Double>	zscore(K setkey, T object)

Method Detail

ping

<K> Future<ResponseStatus> ping()

Ping redis

quit

<K> Future<ResponseStatus> quit()

Disconnects the client.

flush

Future<ResponseStatus> flush()

Optional connection control command.

Type Parameters:

K -

Returns:

set

<K> Future<ResponseStatus> set(K key,
                               byte[] value)

Bind the value to key.

Parameters:

key - any UTF-8 String

value - any bytes. For current data size limitations, refer to Redis documentation.

Throws:

ProviderException - on un-documented features/bug

ClientRuntimeException - on errors due to operating environment (Redis or network)

set

<K> Future<ResponseStatus> set(K key,
                               String stringValue)

Convenient method for String data binding

Parameters:

key -

stringValue -

See Also:

JRedis#set(String, byte[])}

set

<K> Future<ResponseStatus> set(K key,
                               Number numberValue)

Convenient method for String numeric values binding

Parameters:

key -

numberValue -

See Also:

JRedis#set(String, byte[])}

set

<K,T extends Serializable> Future<ResponseStatus> set(K key,
                                                      T object)

Binds the given java Object to the key. Serialization format is implementation specific. Simple implementations may apply the basic Serializable protocol.

Type Parameters:

T -

Parameters:

key -

object -

See Also:

JRedis#set(String, byte[])}

setnx

<K> Future<Boolean> setnx(K key,
                          byte[] value)

Parameters:

key -

value -

Returns:

setnx

<K> Future<Boolean> setnx(K key,
                          String stringValue)

setnx

<K> Future<Boolean> setnx(K key,
                          Number numberValue)

setnx

<K,T extends Serializable> Future<Boolean> setnx(K key,
                                                 T object)

setbit

<K> Future<Boolean> setbit(K key,
                           int offset,
                           boolean value)

get

<K> Future<byte[]> get(K key)

Parameters:

key -

Returns:

getset

<K> Future<byte[]> getset(K key,
                          byte[] value)

getset

<K> Future<byte[]> getset(K key,
                          String stringValue)

getset

<K> Future<byte[]> getset(K key,
                          Number numberValue)

getset

<K,T extends Serializable> Future<byte[]> getset(K key,
                                                 T object)

getbit

<K> Future<Boolean> getbit(K key,
                           int offset)

mget

<K> Future<List<byte[]>> mget(String... keys)

Parameters:

key -

moreKeys -

Returns:

mset

<K> Future<ResponseStatus> mset(Map<K,byte[]> keyValueMap)

Parameters:

keyValueMap - a Mapping of String key names to byte[] values.

Returns:

Future indicating if all of sets were OK or not

Throws:

RedisException

mset

<K> Future<ResponseStatus> mset(KeyValueSet.ByteArrays<K> mappings)

mset

<K> Future<ResponseStatus> mset(KeyValueSet.Strings<K> mappings)

mset

<K> Future<ResponseStatus> mset(KeyValueSet.Numbers<K> mappings)

mset

<K,T extends Serializable> Future<ResponseStatus> mset(KeyValueSet.Objects<K,T> mappings)

msetnx

<K> Future<Boolean> msetnx(Map<K,byte[]> keyValueMap)

Parameters:

keyValueMap - a Mapping of String key names to byte[] values.

Returns:

Future indicating if all of sets were OK or not

Throws:

RedisException

msetnx

<K> Future<Boolean> msetnx(KeyValueSet.ByteArrays<K> mappings)

msetnx

<K> Future<Boolean> msetnx(KeyValueSet.Strings<K> mappings)

msetnx

<K> Future<Boolean> msetnx(KeyValueSet.Numbers<K> mappings)

msetnx

<K,T extends Serializable> Future<Boolean> msetnx(KeyValueSet.Objects<K,T> mappings)

incr

<K> Future<Long> incr(K key)

Parameters:

key -

Returns:

incrby

<K> Future<Long> incrby(K key,
                        int delta)

Parameters:

key -

delta -

Returns:

decr

<K> Future<Long> decr(K key)

Parameters:

key -

Returns:

decrby

<K> Future<Long> decrby(K key,
                        int delta)

Parameters:

key -

delta -

Returns:

substr

<K> Future<byte[]> substr(K listkey,
                          long from,
                          long to)

Parameters:

listkey -

from -

to -

Returns:

append

<K> Future<Long> append(K key,
                        byte[] value)

Parameters:

key -

value -

Returns:

the length (byte count) of appended key.

append

<K> Future<Long> append(K key,
                        String stringValue)

append

<K> Future<Long> append(K key,
                        Number numberValue)

append

<K,T extends Serializable> Future<Long> append(K key,
                                               T object)

exists

<K> Future<Boolean> exists(K key)

Parameters:

key -

Returns:

del

<K> Future<Long> del(K... keys)

Parameters:

keys - one or more, non-null, non-zero-length, keys to be deleted

Returns:

Future of number keys actually deleted.

type

<K> Future<RedisType> type(K key)

Parameters:

key -

Returns:

keys

<K> Future<List<byte[]>> keys(K pattern)

Parameters:

pattern -

Returns:

keys

<K> Future<List<byte[]>> keys()

Convenience method. Equivalent to calling jredis.keys("*");

Returns:

See Also:

JRedis#keys(String)}

randomkey

<K> Future<byte[]> randomkey()

Returns:

rename

<K> Future<ResponseStatus> rename(K oldkey,
                                  K newkey)

Parameters:

oldkey -

newkey -

renamenx

<K> Future<Boolean> renamenx(K oldkey,
                             K brandnewkey)

Parameters:

oldkey -

brandnewkey -

Returns:

dbsize

<K> Future<Long> dbsize()

Returns:

expire

<K> Future<Boolean> expire(K key,
                           int ttlseconds)

Parameters:

key -

ttlseconds -

Returns:

expireat

<K> Future<Boolean> expireat(K key,
                             long epochtimeMillisecs)

Parameters:

key -

UNIX - epoch-time in milliseconds. Note that Redis expects epochtime in seconds. Implementations are responsible for converting to seconds. method

Returns:

See Also:

System#currentTimeMillis()}

ttl

<K> Future<Long> ttl(K key)

Parameters:

key -

Returns:

rpush

<K> Future<Long> rpush(K listkey,
                       byte[] value)

Parameters:

listkey -

value -

rpush

<K> Future<Long> rpush(K listkey,
                       String stringValue)

rpush

<K> Future<Long> rpush(K listkey,
                       Number numberValue)

rpush

<K,T extends Serializable> Future<Long> rpush(K listkey,
                                              T object)

lpush

<K> Future<Long> lpush(K listkey,
                       byte[] value)

Parameters:

listkey -

value -

lpush

<K> Future<Long> lpush(K listkey,
                       String stringValue)

lpush

<K> Future<Long> lpush(K listkey,
                       Number numberValue)

lpush

<K,T extends Serializable> Future<Long> lpush(K listkey,
                                              T object)

lset

<K> Future<ResponseStatus> lset(K key,
                                long index,
                                byte[] value)

Parameters:

key -

index -

value -

lset

<K> Future<ResponseStatus> lset(K key,
                                long index,
                                String stringValue)

lset

<K> Future<ResponseStatus> lset(K key,
                                long index,
                                Number numberValue)

lset

<K,T extends Serializable> Future<ResponseStatus> lset(K key,
                                                       long index,
                                                       T object)

lrem

<K> Future<Long> lrem(K listkey,
                      byte[] value,
                      int count)

Parameters:

listKey -

value -

count -

Returns:

lrem

<K> Future<Long> lrem(K listkey,
                      String stringValue,
                      int count)

lrem

<K> Future<Long> lrem(K listkey,
                      Number numberValue,
                      int count)

lrem

<K,T extends Serializable> Future<Long> lrem(K listkey,
                                             T object,
                                             int count)

llen

<K> Future<Long> llen(K listkey)

Given a 'list' key, returns the number of items in the list.

Parameters:

listkey -

Returns:

lrange

<K> Future<List<byte[]>> lrange(K listkey,
                                long from,
                                long to)

Parameters:

listkey -

from -

to -

Returns:

ltrim

<K> Future<ResponseStatus> ltrim(K listkey,
                                 long keepFrom,
                                 long keepTo)

Parameters:

listkey -

keepFrom -

keepTo -

lindex

<K> Future<byte[]> lindex(K listkey,
                          long index)

Parameters:

listkey -

index -

Returns:

lpop

<K> Future<byte[]> lpop(K listkey)

Parameters:

listKey -

Returns:

rpop

<K> Future<byte[]> rpop(K listkey)

Parameters:

listKey -

Returns:

rpoplpush

<K> Future<byte[]> rpoplpush(String srcList,
                             String destList)

Parameters:

srcList -

destList -

Returns:

sadd

<K> Future<Boolean> sadd(K setkey,
                         byte[] member)

Parameters:

setkey -

member -

Returns:

sadd

<K> Future<Boolean> sadd(K setkey,
                         String stringValue)

sadd

<K> Future<Boolean> sadd(K setkey,
                         Number numberValue)

sadd

<K,T extends Serializable> Future<Boolean> sadd(K setkey,
                                                T object)

srem

<K> Future<Boolean> srem(K setkey,
                         byte[] member)

Parameters:

setKey -

member -

Returns:

srem

<K> Future<Boolean> srem(K setkey,
                         String stringValue)

srem

<K> Future<Boolean> srem(K setkey,
                         Number numberValue)

srem

<K,T extends Serializable> Future<Boolean> srem(K setkey,
                                                T object)

sismember

<K> Future<Boolean> sismember(K setkey,
                              byte[] member)

Parameters:

setKey -

member -

Returns:

sismember

<K> Future<Boolean> sismember(K setkey,
                              String stringValue)

sismember

<K> Future<Boolean> sismember(K setkey,
                              Number numberValue)

sismember

<K,T extends Serializable> Future<Boolean> sismember(K setkey,
                                                     T object)

smove

<K> Future<Boolean> smove(K srcKey,
                          K destKey,
                          byte[] member)

Parameters:

srcKey -

destKey -

member -

Returns:

smove

<K> Future<Boolean> smove(K srcKey,
                          K destKey,
                          String stringValue)

smove

<K> Future<Boolean> smove(K srcKey,
                          K destKey,
                          Number numberValue)

smove

<K,T extends Serializable> Future<Boolean> smove(K srcKey,
                                                 K destKey,
                                                 T object)

scard

<K> Future<Long> scard(K setKey)

Parameters:

setKey -

Returns:

sinter

<K> Future<List<byte[]>> sinter(K set1,
                                K... sets)

Parameters:

set1 -

sets -

Returns:

sinterstore

<K> Future<ResponseStatus> sinterstore(K destSetKey,
                                       K... sets)

Parameters:

destSetKey -

sets -

sunion

<K> Future<List<byte[]>> sunion(K set1,
                                K... sets)

Parameters:

set1 -

sets -

Returns:

sunionstore

<K> Future<ResponseStatus> sunionstore(K destSetKey,
                                       K... sets)

Parameters:

destSetKey -

sets -

sdiff

<K> Future<List<byte[]>> sdiff(K set1,
                               K... sets)

Parameters:

set1 -

sets -

Returns:

sdiffstore

<K> Future<ResponseStatus> sdiffstore(K destSetKey,
                                      K... sets)

Parameters:

destSetKey -

sets -

smembers

<K> Future<List<byte[]>> smembers(K setkey)

Parameters:

setkey -

Returns:

srandmember

<K> Future<byte[]> srandmember(K setkey)

Parameters:

setkey -

Returns:

spop

<K> Future<byte[]> spop(K setkey)

Parameters:

setkey -

Returns:

zadd

<K> Future<Boolean> zadd(K setkey,
                         double score,
                         byte[] member)

Parameters:

setkey -

score -

member -

Returns:

zadd

<K> Future<Boolean> zadd(K setkey,
                         double score,
                         String stringValue)

zadd

<K> Future<Boolean> zadd(K setkey,
                         double score,
                         Number numberValue)

zadd

<K,T extends Serializable> Future<Boolean> zadd(K setkey,
                                                double score,
                                                T object)

zrem

<K> Future<Boolean> zrem(K setkey,
                         byte[] member)

Parameters:

setKey -

member -

Returns:

zrem

<K> Future<Boolean> zrem(K setkey,
                         String stringValue)

zrem

<K> Future<Boolean> zrem(K setkey,
                         Number numberValue)

zrem

<K,T extends Serializable> Future<Boolean> zrem(K setkey,
                                                T object)

zcard

<K> Future<Long> zcard(K setKey)

Parameters:

setKey -

Returns:

zscore

<K> Future<Double> zscore(K setkey,
                          byte[] member)

Parameters:

setkey -

member -

Returns:

zscore

<K> Future<Double> zscore(K setkey,
                          String stringValue)

zscore

<K> Future<Double> zscore(K setkey,
                          Number numberValue)

zscore

<K,T extends Serializable> Future<Double> zscore(K setkey,
                                                 T object)

zrank

<K> Future<Long> zrank(K setkey,
                       byte[] member)

Parameters:

setkey -

member -

Returns:

zrank

<K> Future<Long> zrank(K setkey,
                       String stringValue)

zrank

<K> Future<Long> zrank(K setkey,
                       Number numberValue)

zrank

<K,T extends Serializable> Future<Long> zrank(K setkey,
                                              T object)

zrevrank

<K> Future<Long> zrevrank(K setkey,
                          byte[] member)

Parameters:

setkey -

member -

Returns:

zrevrank

<K> Future<Long> zrevrank(K setkey,
                          String stringValue)

zrevrank

<K> Future<Long> zrevrank(K setkey,
                          Number numberValue)

zrevrank

<K,T extends Serializable> Future<Long> zrevrank(K setkey,
                                                 T object)

zrange

<K> Future<List<byte[]>> zrange(K setkey,
                                long from,
                                long to)

Parameters:

setkey -

from -

to -

Returns:

zrevrange

<K> Future<List<byte[]>> zrevrange(K setkey,
                                   long from,
                                   long to)

Parameters:

setkey -

from -

to -

Returns:

zrangeSubset

<K> Future<List<ZSetEntry>> zrangeSubset(K setkey,
                                         long from,
                                         long to)

Equivalent to JRedis#zrange(String, long, long) with the Command.Option#WITHSCORES. Unlike the general ZRANGE command that only returns the values, this method returns both values and associated scores for the specified range.

Parameters:

setkey -

from -

to -

Returns:

See Also:

JRedis#zrange(String, long, long), ZSetEntry

zrevrangeSubset

<K> Future<List<ZSetEntry>> zrevrangeSubset(K setkey,
                                            long from,
                                            long to)

Equivalent to JRedis#zrange(String, long, long) with the Command.Option#WITHSCORES. Unlike the general ZRANGE command that only returns the values, this method returns both values and associated scores for the specified range.

Parameters:

setkey -

from -

to -

Returns:

See Also:

JRedis#zrevrange(String, long, long), ZSetEntry

zincrby

<K> Future<Double> zincrby(K setkey,
                           double score,
                           byte[] member)

Parameters:

setkey -

score -

member -

Returns:

zincrby

<K> Future<Double> zincrby(K setkey,
                           double score,
                           String stringValue)

zincrby

<K> Future<Double> zincrby(K setkey,
                           double score,
                           Number numberValue)

zincrby

<K,T extends Serializable> Future<Double> zincrby(K setkey,
                                                  double score,
                                                  T object)

zrangebyscore

<K> Future<List<byte[]>> zrangebyscore(K setkey,
                                       double minScore,
                                       double maxScore)

Parameters:

setkey -

from -

to -

Returns:

zrangebyscoreSubset

<K> Future<List<ZSetEntry>> zrangebyscoreSubset(K setkey,
                                                double minScore,
                                                double maxScore)

Parameters:

setkey -

minScore -

maxScore -

Returns:

zremrangebyscore

<K> Future<Long> zremrangebyscore(K setkey,
                                  double minScore,
                                  double maxScore)

Parameters:

setkey -

from -

to -

Returns:

number of removed elements

zcount

<K> Future<Long> zcount(K setkey,
                        double minScore,
                        double maxScore)

Parameters:

setkey -

minScore -

maxScore -

Returns:

number of removed elements

zremrangebyrank

<K> Future<Long> zremrangebyrank(K setkey,
                                 long minRank,
                                 long maxRank)

Parameters:

setkey -

from -

to -

Returns:

number of removed elements

hset

<K> Future<Boolean> hset(K key,
                         K entry,
                         byte[] value)

Parameters:

key -

field -

value -

Returns:

hset

<K> Future<Boolean> hset(K key,
                         K entry,
                         String string)

Parameters:

key -

field -

string -

Returns:

hset

<K> Future<Boolean> hset(K key,
                         K entry,
                         Number number)

Parameters:

key -

field -

number -

Returns:

hset

<K,T extends Serializable> Future<Boolean> hset(K key,
                                                K entry,
                                                T object)

Type Parameters:

T -

Parameters:

key -

field -

object -

Returns:

hget

<K> Future<byte[]> hget(K key,
                        K entry)

Parameters:

key -

field -

Returns:

hincrby

<K> Future<Long> hincrby(K key,
                         K entry,
                         long increment)

Parameters:

key -

entry -

increment -

Returns:

hexists

<K> Future<Boolean> hexists(K key,
                            K entry)

Parameters:

key -

field -

Returns:

true if the spec'd field exists for the spec'd (hash type) key

hdel

<K> Future<Boolean> hdel(K key,
                         K entry)

Parameters:

key -

field -

Returns:

true if the spec'd field exists for the spec'd (hash type) key

hlen

<K> Future<Long> hlen(K key)

Parameters:

key -

field -

Returns:

# of fields/entries for the given hash type key

hkeys

<K> Future<List<byte[]>> hkeys(K key)

Parameters:

key -

Returns:

list of keys in the given hashtable.

Throws:

RedisException

hvals

<K> Future<List<byte[]>> hvals(K key)

Parameters:

key -

Returns:

list of values in the given hashtable.

Throws:

RedisException

hgetall

<K> Future<Map<byte[],byte[]>> hgetall(K key)

Parameters:

key -

Returns:

the given hash as a Map

Throws:

RedisException

flushdb

<K> Future<ResponseStatus> flushdb()

Flushes the db you selected when connecting to Redis server. Typically, implementations will select db 0 on connecting if non was specified. Remember that there is no roll-back.

Returns:

flushall

<K> Future<ResponseStatus> flushall()

Flushes all dbs in the connect Redis server, regardless of which db was selected on connect time. Remember that there is no rollback.

Returns:

move

<K> Future<Boolean> move(K key,
                         int dbIndex)

Moves the given key from the currently selected db to the one indicated by dbIndex.

Parameters:

key -

dbIndex -

Returns:

sort

<K> Sort sort(K key)

For Usage details regarding sort semantics, see JRedis.sort(K). The only difference in usage is that you must use the Query.execAsync() method which returns a Future instances.

Usage:

 Future>  futureResults = redis.sort("my-list-or-set-key").BY("weight*").LIMIT(1, 11).GET("object*").DESC().ALPHA().execAsync();
 List results = futureResult.get();  // wait for the asynchronous response to be processed
 for(byte[] item : results) {
     // do something with item ..
  }
 

See Also:

Redis, Future

save

<K> Future<ResponseStatus> save()

bgsave

<K> Future<ResponseStatus> bgsave()

bgrewriteaof

<K> Future<String> bgrewriteaof()

Returns:

ack message.

lastsave

<K> Future<Long> lastsave()

Returns:

info

<K> Future<Map<String,String>> info()

Returns:

slaveof

<K> Future<ResponseStatus> slaveof(String host,
                                   int port)

Parameters:

host - ip address

port -

slaveofnone

<K> Future<ResponseStatus> slaveofnone()

Convenience method. Turns off replication.

echo

<K> Future<byte[]> echo(byte[] msg)

Parameters:

msg -

Returns:

echo

<K> Future<byte[]> echo(String msg)

echo

<K> Future<byte[]> echo(Number msg)

echo

<K,T extends Serializable> Future<byte[]> echo(T msg)

debug

<K> Future<ObjectInfo> debug(K key)

Parameters:

key -

Returns: