Redis命令参考

String set(String key, String value);
String set(byte[] key, byte[] value);
String set(String key, String value, SetParams params);
String set(byte[] key, byte[] value, SetParams params);
String get(String key);
byte[] get(byte[] key);
Long del(String key);
Long del(byte[] key);
Boolean exists(String key);
Boolean exists(byte[] key);
Long persist(String key);
Long persist(byte[] key);
String type(String key);
String type(byte[] key);
byte[] dump(String key);
byte[] dump(byte[] key);
String restore(String key, Long ttl, byte[] serializedValue);
String restore(byte[] key, Long ttl, byte[] serializedValue);
Long expire(String key, Long seconds);
Long expire(byte[] key, Long seconds);
Long pexpire(String key, Long seconds);
Long pexpire(byte[] key, Long milliseconds);
Long expireAt(String key, Long unixTime);
Long expireAt(byte[] key, Long unixTime);
Long pexpireAt(String key, Long millisecondsTimestamp);
Long pexpireAt(byte[] key, Long millisecondsTimestamp);
Long ttl(String key);
Long ttl(byte[] key);
Long pttl(String key);
Long pttl(byte[] key);
Long touch(String key);
Long touch(byte[] key);
Boolean setbit(String key, Long offset, boolean value);
Boolean setbit(byte[] key, long offset, boolean value);
Boolean setbit(String key, Long offset, String value);
Boolean setbit(byte[] key, Long offset, byte[] value);
Boolean getbit(String key, Long offset);
Boolean getbit(byte[] key, long offset);
Long setrange(String key, Long offset, String value);
Long setrange(byte[] key, Long offset, byte[] value);
String getrange(String key, Long startOffset, Long endOffset);
byte[] getrange(byte[] key, long startOffset, long endOffset);
String getSet(String key, String value);
byte[] getSet(byte[] key, byte[] value);
Long setnx(String key, String value);
Long setnx(byte[] key, byte[] value);
String setex(String key, Long seconds, String value);
String setex(byte[] key, Long ttl, byte[] value);
String psetex(String key, Long milliseconds, String value);
String psetex(byte[] key, Long milliseconds, byte[] value);
Long decrBy(String key, Long decrement);
Long decrBy(byte[] key, Long decrement);
Long decr(String key);
Long decr(byte[] key);
Long incrBy(String key, Long increment);
Long incrBy(byte[] key, Long increment);
Double incrByFloat(String key, Double increment);
Double incrByFloat(byte[] key, Double increment);
Long incr(String key);
Long incr(byte[] key);
Long append(String key, String value);
Long append(byte[] key, byte[] value);
String substr(String key, Integer start, Integer end);
byte[] substr(byte[] key, Integer start, Integer end);
Long strlen(String key);
Long strlen(byte[] key);
Long del(String... key);
Long del(byte[]... key);
Set<String> keys(String expression);
Set<byte[]> keys(byte[] expression);
Long unlink(final String key);
Long unlink(final byte[] key);
Long unlink(final String... keys);
Long unlink(final byte[]... keys);
ScanResult<String> scan(String cursor, ScanParams params);
ScanResult<byte[]> scan(byte[] cursor, ScanParams params);
List<String> mget(String... keys);
List<byte[]> mget(byte[]... keys);
String mset(String... keysvalues);
Long msetnx(String... keysvalues);
String rename(String oldkey, String newkey);
String rename(byte[] oldkey, byte[] newkey);
Long renamenx(String oldkey, String newkey);
Long renamenx(byte[] oldkey, byte[] newkey);
String lindex(String key, Long index);
byte[] lindex(byte[] key, Long index);
Long linsert(String key, Boolean isBefore, String pivot, String value);
Long linsert(byte[] key, Boolean isBefore, byte[] pivot, byte[] value);
Long llen(String key);
Long llen(byte[] key);
String lpop(String key);
byte[] lpop(byte[] key);
Long lpush(String key, String... string);
Long lpush(byte[] key, byte[]... string);
Long lpushx(String key, String... string);
Long lpushx(byte[] key, byte[]... string);
List<String> lrange(String key, Long start, Long stop);
List<byte[]> lrange(byte[] key, Long start, Long stop);
Long lrem(String key, Long count, String value);
Long lrem(byte[] key, Long count, byte[] value);
String lset(String key, Long index, String value);
String lset(byte[] key, Long index, byte[] value);
String ltrim(String key, Long start, Long stop);
String ltrim(byte[] key, Long start, Long stop);
String rpop(String key);
byte[] rpop(byte[] key);
List<String> rpop(String key, int count);
List<byte[]> rpop(byte[] key, int count);
String rpoplpush(String srckey, String dstkey);
byte[] rpoplpush(byte[] srckey, byte[] dstkey);
Long rpush(String key, String... string);
Long rpush(byte[] key, byte[]... string);
Long rpushx(String key, String... string);
Long rpushx(byte[] key, byte[]... string);
Long hdel(String key, String... field);
Long hdel(byte[] key, byte[]... field);
Boolean hexists(String key, String field);
Boolean hexists(byte[] key, byte[] field);
String hget(String key, String field);
byte[] hget(byte[] key, byte[] field);
Map<String, String> hgetAll(String key);
Map<byte[], byte[]> hgetAll(byte[] key);
Long hincrBy(String key, String field, Long value);
Long hincrBy(byte[] key, byte[] field, Long value);
Double hincrByFloat(String key, String field, Double value);
Double hincrByFloat(byte[] key, byte[] field, Double value);
Set<String> hkeys(String key);
Set<byte[]> hkeys(byte[] key);
Long hlen(String key);
Long hlen(byte[] key);
List<String> hmget(String key, String... fields);
List<byte[]> hmget(byte[] key, byte[]... fields);
String hmset(String key, Map<String, String> hash);
String hmset(byte[] key, Map<byte[], byte[]> hash);
Long hset(String key, String field, String value);
Long hset(byte[] key, byte[] field, byte[] value);
Long hset(String key, Map<String, String> hash);
Long hset(byte[] key, Map<byte[], byte[]> hash);
Long hsetnx(String key, String field, String value);
Long hsetnx(byte[] key, byte[] field, byte[] value);
Long hstrlen(String key, String field);
Long hstrlen(byte[] key, byte[] field);
List<String> hvals(String key);
List<byte[]> hvals(byte[] key);
ScanResult<Map.Entry<String, String>> hscan(String key, String cursor);
ScanResult<Map.Entry<byte[], byte[]>> hscan(byte[] key, byte[] cursor);
ScanResult<Map.Entry<String, String>> hscan(final String key, final String cursor, final ScanParams params);
ScanResult<Map.Entry<byte[], byte[]>> hscan(final byte[] key, final byte[] cursor, final ScanParams params);
Long sadd(final String key, final String... member);
Long sadd(final byte[] key, final byte[]... member);
Long scard(final String key);
Long scard(final byte[] key);
Set<String> sdiff(final String... keys);
Set<byte[]> sdiff(final byte[]... keys);
Long sdiffstore(final String dstkey, final String... keys);
Set<String> sinter(final String... keys);
Set<byte[]> sinter(final byte[]... keys);
Long sinterstore(final String dstkey, final String... keys);
Boolean sismember(final String key, final String member);
Boolean sismember(final byte[] key, final byte[] member);
Set<String> smembers(final String key);
Set<byte[]> smembers(final byte[] key);
Long smove(final String srckey, final String dstkey, final String member);
Long smove(final byte[] srckey, final byte[] dstkey, final byte[] member);
String spop(final String key);
byte[] spop(final byte[] key);
Set<String> spop(final String key, final Long count);
Set<byte[]> spop(final byte[] key, final Long count);
String srandmember(final String key);
byte[] srandmember(final byte[] key);
List<String> srandmember(final String key, final Integer count);
List<byte[]> srandmember(final byte[] key, final Integer count);
Long srem(final String key, final String... member);
Long srem(final byte[] key, final byte[]... member);
Set<String> sunion(final String... keys);
Set<byte[]> sunion(final byte[]... keys);
Long sunionstore(final String dstkey, final String... keys);
Long sunionstore(final byte[] dstkey, final byte[]... keys);
ScanResult<String> sscan(final String key, final String cursor);
ScanResult<byte[]> sscan(final byte[] key, final byte[] cursor);
Long zadd(String key, Double score, String member);
Long zadd(byte[] key, Double score, byte[] member);
Long zadd(String key, Double score, String member, ZAddParams params);
Long zadd(byte[] key, Double score, byte[] member, ZAddParams params);
Long zadd(String key, Map<String, Double> scoreMembers);
Long zadd(byte[] key, Map<byte[], Double> scoreMembers);
Long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params);
Long zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params);
Set<String> zrange(String key, Long start, Long stop);
Set<byte[]> zrange(byte[] key, Long start, Long stop);
Long zrem(String key, String... members);
Long zrem(byte[] key, byte[]... members);
Double zincrby(String key, Double increment, String member);
Double zincrby(byte[] key, Double increment, byte[] member);
Double zincrby(String key, Double increment, String member, ZIncrByParams params);
Double zincrby(byte[] key, Double increment, byte[] member, ZIncrByParams params);
Long zrank(String key, String member);
Long zrank(byte[] key, byte[] member);
Long zrevrank(String key, String member);
Long zrevrank(byte[] key, byte[] member);
Set<String> zrevrange(String key, Long start, Long stop);
Set<byte[]> zrevrange(byte[] key, Long start, Long stop);
Set<Tuple> zrangeWithScores(String key, Long start, Long stop);
Set<Tuple> zrangeWithScores(byte[] key, Long start, Long stop);
Set<Tuple> zrevrangeWithScores(String key, Long start, Long stop);
Set<Tuple> zrevrangeWithScores(byte[] key, Long start, Long stop);
Long zcard(String key);
Long zcard(byte[] key);
Double zscore(String key, String member);
Double zscore(byte[] key, byte[] member);
Tuple zpopmax(String key);
Tuple zpopmax(byte[] key);
Set<Tuple> zpopmax(String key, Integer count);
Set<Tuple> zpopmax(byte[] key, Integer count);
Tuple zpopmin(String key);
Tuple zpopmin(byte[] key);
Set<Tuple> zpopmin(String key, Integer count);
Set<Tuple> zpopmin(byte[] key, Integer count);
List<String> sort(String key);
List<byte[]> sort(byte[] key);
List<String> sort(String key, SortingParams sortingParameters);
List<byte[]> sort(byte[] key, SortingParams sortingParameters);
Long zcount(String key, Double min, Double max);
Long zcount(byte[] key, Double min, Double max);
Long zcount(String key, String min, String max);
Long zcount(byte[] key, byte[] min, byte[] max);
Set<String> zrangeByScore(String key, Double min, Double max);
Set<byte[]> zrangeByScore(byte[] key, Double min, Double max);
Set<String> zrangeByScore(String key, String min, String max);
Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max);
Set<String> zrevrangeByScore(String key, Double max, Double min);
Set<byte[]> zrevrangeByScore(byte[] key, Double max, Double min);
Set<String> zrangeByScore(String key, Double min, Double max, Integer offset, Integer count);
Set<byte[]> zrangeByScore(byte[] key, Double min, Double max, Integer offset, Integer count);
Set<String> zrevrangeByScore(String key, String max, String min);
Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min);
Set<String> zrangeByScore(String key, String min, String max, Integer offset, Integer count);
Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, Integer offset, Integer count);
Set<String> zrevrangeByScore(String key, Double max, Double min, Integer offset, Integer count);
Set<byte[]> zrevrangeByScore(byte[] key, Double max, Double min, Integer offset, Integer count);
Set<Tuple> zrangeByScoreWithScores(String key, Double min, Double max);
Set<Tuple> zrangeByScoreWithScores(byte[] key, Double min, Double max);
Set<Tuple> zrevrangeByScoreWithScores(String key, Double max, Double min);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, Double max, Double min);
Set<Tuple> zrangeByScoreWithScores(String key, Double min, Double max, Integer offset, Integer count);
Set<Tuple> zrangeByScoreWithScores(byte[] key, Double min, Double max, Integer offset, Integer count);
Set<String> zrevrangeByScore(String key, String max, String min, Integer offset, Integer count);
Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min, Integer offset, Integer count);
Set<Tuple> zrangeByScoreWithScores(String key, String min, String max);
Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max);
Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min);
Set<Tuple> zrangeByScoreWithScores(String key, String min, String max, Integer offset, Integer count);
Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, Integer offset, Integer count);
Set<Tuple> zrevrangeByScoreWithScores(String key, Double max, Double min, Integer offset, Integer count);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, Double max, Double min, Integer offset, Integer count);
Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, Integer offset, Integer count);
Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, Integer offset, Integer count);
Long zremrangeByRank(String key, Long start, Long stop);
Long zremrangeByRank(byte[] key, Long start, Long stop);
Long zremrangeByScore(String key, Double min, Double max);
Long zremrangeByScore(byte[] key, Double min, Double max);
Long zremrangeByScore(String key, String min, String max);
Long zremrangeByScore(byte[] key, byte[] min, byte[] max);
Long zinterstore(String dstkey, String... sets);
Long zinterstore(byte[] dstkey, byte[]... sets);
Long zlexcount(String key, String min, String max);
Long zlexcount(byte[] key, byte[] min, byte[] max);
Set<String> zrangeByLex(String key, String min, String max);
Set<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max);
Set<String> zrangeByLex(String key, String min, String max, Integer offset, Integer count);
Set<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max, Integer offset, Integer count);
Set<String> zrevrangeByLex(String key, String max, String min);
Set<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min);
Set<String> zrevrangeByLex(String key, String max, String min, Integer offset, Integer count);
Set<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, Integer offset, Integer count);
Long zremrangeByLex(String key, String min, String max);
Long zremrangeByLex(byte[] key, byte[] min, byte[] max);
Object eval(String script, Integer keyCount, String... params);
Object eval(byte[] script, Integer keyCount, byte[]... params);
Object eval(String script, List<String> keys, List<String> args);
Object eval(byte[] script, List<byte[]> keys, List<byte[]> args);
Object eval(String script, String sampleKey);
Object eval(byte[] script, byte[] sampleKey);
Object evalsha(String sha1, String sampleKey);
Object evalsha(byte[] sha1, byte[] sampleKey);
Object evalsha(String sha1, List<String> keys, List<String> args);
Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args);
Object evalsha(String sha1, Integer keyCount, String... params);
Object evalsha(byte[] sha1, Integer keyCount, byte[]... params);
Boolean scriptExists(String sha1, String sampleKey);
List<Boolean> scriptExists(String sampleKey, String... sha1);
String scriptLoad(String script, String sampleKey);
String scriptFlush(String sampleKey);
String scriptKill(String sampleKey);
List<Long> scriptExists(byte[]... sha1);
byte[] scriptLoad(byte[] script);
String scriptFlush();
String scriptFlush(FlushMode flushMode);
String scriptKill();
Boolean scriptExists(String sha1);
List<Boolean> scriptExists(String... sha1);
String scriptLoad(String script);
List<Long> scriptExists(byte[] sampleKey, byte[]... sha1);
byte[] scriptLoad(byte[] script, byte[] sampleKey);
String scriptFlush(byte[] sampleKey);
String scriptFlush(byte[] sampleKey, FlushMode flushMode);
String scriptKill(byte[] sampleKey);
List<String> blpop(Integer timeout, String key);
List<byte[]> blpop(Integer timeout, byte[] key);
List<String> blpop(Integer timeout, String... keys);
List<byte[]> blpop(Integer timeout, byte[]... keys);
List<String> brpop(Integer timeout, String key);
List<byte[]> brpop(Integer timeout, byte[] key);
List<String> brpop(Integer timeout, String... keys);
List<byte[]> brpop(Integer timeout, byte[]... keys);
String brpoplpush(String source, String destination, Integer timeout);
byte[] brpoplpush(byte[] source, byte[] destination, Integer timeout);
String watch(String... keys);
String watch(byte[]... keys);
String unwatch();
KeyedZSetElement bzpopmax(Double timeout, String... keys);
KeyedZSetElement bzpopmin(Double timeout, String... keys);
ScanResult<Tuple> zscan(String key, String cursor);
ScanResult<Tuple> zscan(byte[] key, byte[] cursor);
ScanResult<Tuple> zscan(final String key, final String cursor, final ScanParams params);
ScanResult<Tuple> zscan(final byte[] key, final byte[] cursor, final ScanParams params);
Long geoadd(String key, Double longitude, Double latitude, String member);
Long geoadd(byte[] key, Double longitude, Double latitude, byte[] member);
Long geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap);
Long geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap);
List<GeoRadiusResponse> georadius(String key, Double longitude, Double latitude, Double radius, GeoUnit unit);
List<GeoRadiusResponse> georadius(byte[] key, Double longitude, Double latitude, Double radius, GeoUnit unit);
List<GeoCoordinate> geopos(String key, String... members);
List<GeoCoordinate> geopos(byte[] key, byte[]... members);
Double geodist(String key, String member1, String member2);
Double geodist(byte[] key, byte[] member1, byte[] member2);
Double geodist(String key, String member1, String member2, GeoUnit unit);
Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit);
List<String> geohash(String key, String... members);
List<byte[]> geohash(byte[] key, byte[]... members);
Long publish(String channel, String message);
Long publish(byte[] channel, byte[] message);
Long pubsubNumPat();
List<String> pubsubChannels(String pattern);
List<String> pubsubChannels();
Map<String, String> pubsubNumSub(String... channels);
String psubscribe(JedisPubSub jedisPubSub, String... patterns);
String subscribe(JedisPubSub jedisPubSub, String... channels);
String psubscribe(BinaryJedisPubSub jedisPubSub, byte[]... patterns);
String subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels);
String ping();
String info();
String info(final String section);
String clusterInfo();