From 85ce39ca3e251cf79904088f6f0ecf3c91432070 Mon Sep 17 00:00:00 2001 From: Yaourt Date: Thu, 4 Nov 2010 12:22:40 +0100 Subject: [PATCH] BinaryClient is born --- .../redis/clients/jedis/BinaryClient.java | 714 ++++++++++++++++++ .../java/redis/clients/jedis/Connection.java | 17 +- .../java/redis/clients/jedis/Protocol.java | 173 ++++- .../redis/clients/jedis/SortingParams.java | 35 +- .../java/redis/clients/jedis/ZParams.java | 29 +- .../redis/clients/util/RedisOutputStream.java | 22 +- 6 files changed, 945 insertions(+), 45 deletions(-) create mode 100644 src/main/java/redis/clients/jedis/BinaryClient.java diff --git a/src/main/java/redis/clients/jedis/BinaryClient.java b/src/main/java/redis/clients/jedis/BinaryClient.java new file mode 100644 index 0000000..245a0c9 --- /dev/null +++ b/src/main/java/redis/clients/jedis/BinaryClient.java @@ -0,0 +1,714 @@ +package redis.clients.jedis; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import redis.clients.jedis.Protocol.Command; +import redis.clients.jedis.Protocol.Keyword; +import static redis.clients.jedis.Protocol.toByteArray; + +import static redis.clients.jedis.Protocol.Command.*; +import static redis.clients.jedis.Protocol.Keyword.*; +public class BinaryClient extends Connection { + public enum LIST_POSITION { + BEFORE, AFTER; + public final byte[] raw; + private LIST_POSITION() { + raw = name().getBytes(Protocol.UTF8); + } + } + + private boolean isInMulti; + + public boolean isInMulti() { + return isInMulti; + } + + public BinaryClient(final String host) { + super(host); + } + + public BinaryClient(final String host, final int port) { + super(host, port); + } + + public void ping() { + sendCommand(PING); + } + + public void set(final byte[] key, final byte[] value) { + sendCommand(Command.SET, key, value); + } + + public void get(final byte[] key) { + sendCommand(Command.GET, key); + } + + public void quit() { + sendCommand(QUIT); + } + + public void exists(final byte[] key) { + sendCommand(EXISTS, key); + } + + public void del(final byte[]... keys) { + sendCommand(DEL, keys); + } + + public void type(final byte[] key) { + sendCommand(TYPE, key); + } + + public void flushDB() { + sendCommand(FLUSHDB); + } + + public void keys(final byte[] pattern) { + sendCommand(KEYS, pattern); + } + + public void randomKey() { + sendCommand(RANDOMKEY); + } + + public void rename(final byte[] oldkey, final byte[] newkey) { + sendCommand(RENAME, oldkey, newkey); + } + + public void renamenx(final byte[] oldkey, final byte[] newkey) { + sendCommand(RENAMENX, oldkey, newkey); + } + + public void dbSize() { + sendCommand(DBSIZE); + } + + public void expire(final byte[] key, final int seconds) { + sendCommand(EXPIRE, key, toByteArray(seconds)); + } + + public void expireAt(final byte[] key, final long unixTime) { + sendCommand(EXPIREAT, key, toByteArray(unixTime)); + } + + public void ttl(final byte[] key) { + sendCommand(TTL, key); + } + + public void select(final int index) { + sendCommand(SELECT, toByteArray(index)); + } + + public void move(final byte[] key, final int dbIndex) { + sendCommand(MOVE, key, toByteArray(dbIndex)); + } + + public void flushAll() { + sendCommand(FLUSHALL); + } + + public void getSet(final byte[] key, final byte[] value) { + sendCommand(GETSET, key, value); + } + + public void mget(final byte[]... keys) { + sendCommand(MGET, keys); + } + + public void setnx(final byte[] key, final byte[] value) { + sendCommand(SETNX, key, value); + } + + public void setex( + final byte[] key, + final int seconds, + final byte[] value) { + sendCommand(SETEX, key, toByteArray(seconds), value); + } + + public void mset(final byte[]... keysvalues) { + sendCommand(MSET, keysvalues); + } + + public void msetnx(final byte[]... keysvalues) { + sendCommand(MSETNX, keysvalues); + } + + public void decrBy(final byte[] key, final int integer) { + sendCommand(DECRBY, key, toByteArray(integer)); + } + + public void decr(final byte[] key) { + sendCommand(DECR, key); + } + + public void incrBy(final byte[] key, final int integer) { + sendCommand(INCRBY, key, toByteArray(integer)); + } + + public void incr(final byte[] key) { + sendCommand(INCR, key); + } + + public void append(final byte[] key, final byte[] value) { + sendCommand(APPEND, key, value); + } + + public void substr(final byte[] key, final int start, final int end) { + sendCommand(SUBSTR, key, toByteArray(start), toByteArray(end)); + } + + public void hset( + final byte[] key, + final byte[] field, + final byte[] value) { + sendCommand(HSET, key, field, value); + } + + public void hget(final byte[] key, final byte[] field) { + sendCommand(HGET, key, field); + } + + public void hsetnx( + final byte[] key, + final byte[] field, + final byte[] value) { + sendCommand(HSETNX, key, field, value); + } + + public void hmset(final byte[] key, final Map hash) { + final List params = new ArrayList(); + params.add(key); + + for (final byte[] field : hash.keySet()) { + params.add(field); + params.add(hash.get(field)); + } + sendCommand(HMSET, params.toArray(new byte[params.size()][])); + } + + public void hmget(final byte[] key, final byte[]... fields) { + final byte[][] params = new byte[fields.length + 1][]; + params[0] = key; + System.arraycopy(fields, 0, params, 1, fields.length); + sendCommand(HMGET, params); + } + + public void hincrBy(final byte[] key, final byte[] field, final int value) { + sendCommand(HINCRBY, key, field, toByteArray(value)); + } + + public void hexists(final byte[] key, final byte[] field) { + sendCommand(HEXISTS, key, field); + } + + public void hdel(final byte[] key, final byte[] field) { + sendCommand(HDEL, key, field); + } + + public void hlen(final byte[] key) { + sendCommand(HLEN, key); + } + + public void hkeys(final byte[] key) { + sendCommand(HKEYS, key); + } + + public void hvals(final byte[] key) { + sendCommand(HVALS, key); + } + + public void hgetAll(final byte[] key) { + sendCommand(HGETALL, key); + } + + public void rpush(final byte[] key, final byte[] string) { + sendCommand(RPUSH, key, string); + } + + public void lpush(final byte[] key, final byte[] string) { + sendCommand(LPUSH, key, string); + } + + public void llen(final byte[] key) { + sendCommand(LLEN, key); + } + + public void lrange(final byte[] key, final int start, final int end) { + sendCommand(LRANGE, key, toByteArray(start), toByteArray(end)); + } + + public void ltrim(final byte[] key, final int start, final int end) { + sendCommand(LTRIM, key, toByteArray(start), toByteArray(end)); + } + + public void lindex(final byte[] key, final int index) { + sendCommand(LINDEX, key, toByteArray(index)); + } + + public void lset(final byte[] key, final int index, final byte[] value) { + sendCommand(LSET, key, toByteArray(index), value); + } + + public void lrem(final byte[] key, int count, final byte[] value) { + sendCommand(LREM, key, toByteArray(count), value); + } + + public void lpop(final byte[] key) { + sendCommand(LPOP, key); + } + + public void rpop(final byte[] key) { + sendCommand(RPOP, key); + } + + public void rpoplpush(final byte[] srckey, final byte[] dstkey) { + sendCommand(RPOPLPUSH, srckey, dstkey); + } + + public void sadd(final byte[] key, final byte[] member) { + sendCommand(SADD, key, member); + } + + public void smembers(final byte[] key) { + sendCommand(SMEMBERS, key); + } + + public void srem(final byte[] key, final byte[] member) { + sendCommand(SREM, key, member); + } + + public void spop(final byte[] key) { + sendCommand(SPOP, key); + } + + public void smove( + final byte[] srckey, + final byte[] dstkey, + final byte[] member) { + sendCommand(SMOVE, srckey, dstkey, member); + } + + public void scard(final byte[] key) { + sendCommand(SCARD, key); + } + + public void sismember(final byte[] key, final byte[] member) { + sendCommand(SISMEMBER, key, member); + } + + public void sinter(final byte[]... keys) { + sendCommand(SINTER, keys); + } + + public void sinterstore(final byte[] dstkey, final byte[]... keys) { + final byte[][] params = new byte[keys.length + 1][]; + params[0] = dstkey; + System.arraycopy(keys, 0, params, 1, keys.length); + sendCommand(SINTERSTORE, params); + } + + public void sunion(final byte[]... keys) { + sendCommand(SUNION, keys); + } + + public void sunionstore(final byte[] dstkey, final byte[]... keys) { + byte[][] params = new byte[keys.length + 1][]; + params[0] = dstkey; + System.arraycopy(keys, 0, params, 1, keys.length); + sendCommand(SUNIONSTORE, params); + } + + public void sdiff(final byte[]... keys) { + sendCommand(SDIFF, keys); + } + + public void sdiffstore(final byte[] dstkey, final byte[]... keys) { + byte[][] params = new byte[keys.length + 1][]; + params[0] = dstkey; + System.arraycopy(keys, 0, params, 1, keys.length); + sendCommand(SDIFFSTORE, params); + } + + public void srandmember(final byte[] key) { + sendCommand(SRANDMEMBER, key); + } + + public void zadd( + final byte[] key, + final double score, + final byte[] member) { + sendCommand(ZADD, key, toByteArray(score), member); + } + + public void zrange(final byte[] key, final int start, final int end) { + sendCommand(ZRANGE, key, toByteArray(start), toByteArray(end)); + } + + public void zrem(final byte[] key, final byte[] member) { + sendCommand(ZREM, key, member); + } + + public void zincrby( + final byte[] key, + final double score, + final byte[] member) { + sendCommand(ZINCRBY, key, toByteArray(score), member); + } + + public void zrank(final byte[] key, final byte[] member) { + sendCommand(ZRANK, key, member); + } + + public void zrevrank(final byte[] key, final byte[] member) { + sendCommand(ZREVRANK, key, member); + } + + public void zrevrange( + final byte[] key, + final int start, + final int end) { + sendCommand( + ZREVRANGE, + key, + toByteArray(start), + toByteArray(end)); + } + + public void zrangeWithScores( + final byte[] key, + final int start, + final int end) { + sendCommand( + ZRANGE, + key, + toByteArray(start), + toByteArray(end), + WITHSCORES.raw); + } + + public void zrevrangeWithScores( + final byte[] key, + final int start, + final int end) { + sendCommand( + ZREVRANGE, + key, + toByteArray(start), + toByteArray(end), + WITHSCORES.raw); + } + + public void zcard(final byte[] key) { + sendCommand(ZCARD, key); + } + + public void zscore(final byte[] key, final byte[] member) { + sendCommand(ZSCORE, key, member); + } + + public void multi() { + sendCommand(MULTI); + isInMulti = true; + } + + public void discard() { + sendCommand(DISCARD); + isInMulti = false; + } + + public void exec() { + sendCommand(EXEC); + isInMulti = false; + } + + public void watch(final byte[] key) { + sendCommand(WATCH, key); + } + + public void unwatch() { + sendCommand(UNWATCH); + } + + public void sort(final byte[] key) { + sendCommand(SORT, key); + } + + public void sort(final byte[] key, final SortingParams sortingParameters) { + final List args = new ArrayList(); + args.add(key); + args.addAll(sortingParameters.getParams()); + sendCommand(SORT, args.toArray(new byte[args.size()][])); + } + + public void blpop(final byte[][] args) { + sendCommand(BLPOP, args); + } + + public void sort( + final byte[] key, + final SortingParams sortingParameters, + final byte[] dstkey) { + final List args = new ArrayList(); + args.add(key); + args.addAll(sortingParameters.getParams()); + args.add(STORE.raw); + args.add(dstkey); + sendCommand(SORT, args.toArray(new byte[args.size()][])); + } + + public void sort(final byte[] key, final byte[] dstkey) { + sendCommand(SORT, key, STORE.raw, dstkey); + } + + public void brpop(final byte[][] args) { + sendCommand(BRPOP, args); + } + + public void auth(final String password) { + sendCommand(AUTH, password); + } + + public void subscribe(final String... channels) { + sendCommand(SUBSCRIBE, channels); + } + + public void publish(final String channel, final String message) { + sendCommand(PUBLISH, channel, message); + } + + public void unsubscribe() { + sendCommand(UNSUBSCRIBE); + } + + public void unsubscribe(final String... channels) { + sendCommand(UNSUBSCRIBE, channels); + } + + public void psubscribe(final String[] patterns) { + sendCommand(PSUBSCRIBE, patterns); + } + + public void punsubscribe() { + sendCommand(PUNSUBSCRIBE); + } + + public void punsubscribe(final String... patterns) { + sendCommand(PUNSUBSCRIBE, patterns); + } + + public void zcount(final byte[] key, final double min, final double max) { + sendCommand(ZCOUNT, key, toByteArray(min), toByteArray(max)); + } + + public void zrangeByScore( + final byte[] key, + final double min, + final double max) { + sendCommand( + ZRANGEBYSCORE, + key, + toByteArray(min), + toByteArray(max)); + } + + public void zrangeByScore( + final byte[] key, + final byte[] min, + final byte[] max) { + sendCommand(ZRANGEBYSCORE, key, min, max); + } + + public void zrangeByScore( + final byte[] key, + final double min, + final double max, + final int offset, + int count) { + sendCommand( + ZRANGEBYSCORE, + key, + toByteArray(min), + toByteArray(max), + LIMIT.raw, + toByteArray(offset), + toByteArray(count)); + } + + public void zrangeByScoreWithScores( + final byte[] key, + final double min, + final double max) { + sendCommand( + ZRANGEBYSCORE, + key, + toByteArray(min), + toByteArray(max), + WITHSCORES.raw); + } + + public void zrangeByScoreWithScores( + final byte[] key, + final double min, + final double max, + final int offset, + final int count) { + sendCommand( + ZRANGEBYSCORE, + key, + toByteArray(min), + toByteArray(max), + LIMIT.raw, + toByteArray(offset), + toByteArray(count), + WITHSCORES.raw); + } + + public void zremrangeByRank( + final byte[] key, + final int start, + final int end) { + sendCommand( + ZREMRANGEBYRANK, + key, + toByteArray(start), + toByteArray(end)); + } + + public void zremrangeByScore( + final byte[] key, + final double start, + final double end) { + sendCommand( + ZREMRANGEBYSCORE, + key, + toByteArray(start), + toByteArray(end)); + } + + public void zunionstore(final byte[] dstkey, final byte[]... sets) { + final byte[][] params = new byte[sets.length + 2][]; + params[0] = dstkey; + params[1] = toByteArray(sets.length); + System.arraycopy(sets, 0, params, 2, sets.length); + sendCommand(ZUNIONSTORE, params); + } + + public void zunionstore( + final byte[] dstkey, + final ZParams params, + final byte[]... sets) { + final List args = new ArrayList(); + args.add(dstkey); + args.add(Protocol.toByteArray(sets.length)); + for (final byte[] set : sets) { + args.add(set); + } + args.addAll(params.getParams()); + sendCommand(ZUNIONSTORE, args.toArray(new byte[args.size()][])); + } + + public void zinterstore(final byte[] dstkey, final byte[]... sets) { + final byte[][] params = new byte[sets.length + 2][]; + params[0] = dstkey; + params[1] = Protocol.toByteArray(sets.length); + System.arraycopy(sets, 0, params, 2, sets.length); + sendCommand(ZINTERSTORE, params); + } + + public void zinterstore( + final byte[] dstkey, + final ZParams params, + final byte[]... sets) { + final List args = new ArrayList(); + args.add(dstkey); + args.add(Protocol.toByteArray(sets.length)); + for (final byte[] set : sets) { + args.add(set); + } + args.addAll(params.getParams()); + sendCommand(ZINTERSTORE, args.toArray(new byte[args.size()][])); + } + + public void save() { + sendCommand(SAVE); + } + + public void bgsave() { + sendCommand(BGSAVE); + } + + public void bgrewriteaof() { + sendCommand(BGREWRITEAOF); + } + + public void lastsave() { + sendCommand(LASTSAVE); + } + + public void shutdown() { + sendCommand(SHUTDOWN); + } + + public void info() { + sendCommand(INFO); + } + + public void monitor() { + sendCommand(MONITOR); + } + + public void slaveof(final String host, final int port) { + sendCommand(SLAVEOF, host, String.valueOf(port)); + } + + public void slaveofNoOne() { + sendCommand(SLAVEOF, NO.raw, ONE.raw); + } + + public void configGet(final String pattern) { + sendCommand(CONFIG, Keyword.GET.name(), pattern); + } + + public void configSet(final String parameter, final String value) { + sendCommand(CONFIG, Keyword.SET.name(), parameter, value); + } + + public void strlen(final byte[] key) { + sendCommand(STRLEN, key); + } + + public void sync() { + sendCommand(SYNC); + } + + public void lpushx(final byte[] key, final byte[] string) { + sendCommand(LPUSHX, key, string); + } + + public void persist(final byte[] key) { + sendCommand(PERSIST, key); + } + + public void rpushx(final byte[] key, final byte[] string) { + sendCommand(RPUSHX, key, string); + } + + public void echo(final byte[] string) { + sendCommand(ECHO, string); + } + + public void linsert( + final byte[] key, + final LIST_POSITION where, + final byte[] pivot, + final byte[] value) { + sendCommand(LINSERT, key, where.raw, pivot, value); + } + + public void debug(final DebugParams params) { + sendCommand(DEBUG, params.getCommand()); + } +} \ No newline at end of file diff --git a/src/main/java/redis/clients/jedis/Connection.java b/src/main/java/redis/clients/jedis/Connection.java index 4802570..d375592 100644 --- a/src/main/java/redis/clients/jedis/Connection.java +++ b/src/main/java/redis/clients/jedis/Connection.java @@ -7,6 +7,7 @@ import java.net.UnknownHostException; import java.util.ArrayList; import java.util.List; +import redis.clients.jedis.Protocol.Command; import redis.clients.util.RedisInputStream; import redis.clients.util.RedisOutputStream; @@ -49,7 +50,15 @@ public class Connection { this.host = host; } - protected Connection sendCommand(final String name, final String... args) { + protected Connection sendCommand(final Command cmd, final String... args) { + final byte[][] bargs = new byte[args.length][]; + for(int i=0; i < args.length; i++) { + bargs[i] = args[i].getBytes(Protocol.UTF8); + } + return sendCommand(cmd, bargs); + } + + protected Connection sendCommand(final Command cmd, final byte[]... args) { try { connect(); } catch (UnknownHostException e) { @@ -57,12 +66,12 @@ public class Connection { } catch (IOException e) { throw new JedisException("Could not connect to redis-server", e); } - protocol.sendCommand(outputStream, name, args); + protocol.sendCommand(outputStream, cmd, args); pipelinedCommands++; return this; } - protected Connection sendCommand(final String name, final byte[]... args) { + protected Connection sendCommand(final Command cmd) { try { connect(); } catch (UnknownHostException e) { @@ -70,7 +79,7 @@ public class Connection { } catch (IOException e) { throw new JedisException("Could not connect to redis-server", e); } - protocol.sendCommand(outputStream, name, args); + protocol.sendCommand(outputStream, cmd, (byte[])null); pipelinedCommands++; return this; } diff --git a/src/main/java/redis/clients/jedis/Protocol.java b/src/main/java/redis/clients/jedis/Protocol.java index aef07c3..c8ed6fc 100644 --- a/src/main/java/redis/clients/jedis/Protocol.java +++ b/src/main/java/redis/clients/jedis/Protocol.java @@ -19,7 +19,7 @@ public final class Protocol { public static final byte PLUS_BYTE = '+'; public static final byte MINUS_BYTE = '-'; public static final byte COLON_BYTE = ':'; - +/* public void sendCommand(final RedisOutputStream os, final String name, final String... args) { try { os.write(ASTERISK_BYTE); @@ -43,14 +43,20 @@ public final class Protocol { throw new JedisException(e); } } +*/ + public void sendCommand(final RedisOutputStream os, final Command command, final byte[]... args) { + sendCommand(os, command.raw, args); + } - public void sendCommand(final RedisOutputStream os, final String name, final byte[]... args) { + private void sendCommand(final RedisOutputStream os, final byte[] command, final byte[]... args) { try { os.write(ASTERISK_BYTE); os.writeIntCrLf(args.length + 1); os.write(DOLLAR_BYTE); - os.writeIntCrLf(name.length()); - os.writeAsciiCrLf(name); + os.writeIntCrLf(command.length); + os.write(command); + os.writeCrLf(); +// os.writeAsciiCrLf(command); for (final byte[] arg : args) { os.write(DOLLAR_BYTE); @@ -136,4 +142,163 @@ public final class Protocol { public Object read(final RedisInputStream is) { return process(is); } + + public static final byte[] toByteArray(final int value) { + return String.valueOf(value).getBytes(Protocol.UTF8); + } + + public static final byte[] toByteArray(final long value) { + return String.valueOf(value).getBytes(Protocol.UTF8); + } + + public static final byte[] toByteArray(final double value) { + return String.valueOf(value).getBytes(Protocol.UTF8); + } + + public static enum Command { + PING, + SET, + GET, + QUIT, + EXISTS, + DEL, + TYPE, + FLUSHDB, + KEYS, + RANDOMKEY, + RENAME, + RENAMENX, + RENAMEX, + DBSIZE, + EXPIRE, + EXPIREAT, + TTL, + SELECT, + MOVE, + FLUSHALL, + GETSET, + MGET, + SETNX, + SETEX, + MSET, + MSETNX, + DECRBY, + DECR, + INCRBY, + INCR, + APPEND, + SUBSTR, + HSET, + HGET, + HSETNX, + HMSET, + HMGET, + HINCRBY, + HEXISTS, + HDEL, + HLEN, + HKEYS, + HVALS, + HGETALL, + RPUSH, + LPUSH, + LLEN, + LRANGE, + LTRIM, + LINDEX, + LSET, + LREM, + LPOP, + RPOP, + RPOPLPUSH, + SADD, + SMEMBERS, + SREM, + SPOP, + SMOVE, + SCARD, + SISMEMBER, + SINTER, + SINTERSTORE, + SUNION, + SUNIONSTORE, + SDIFF, + SDIFFSTORE, + SRANDMEMBER, + ZADD, + ZRANGE, + ZREM, + ZINCRBY, + ZRANK, + ZREVRANK, + ZREVRANGE, + ZCARD, + ZSCORE, + MULTI, + DISCARD, + EXEC, + WATCH, + UNWATCH, + SORT, + BLPOP, + BRPOP, + AUTH, + SUBSCRIBE, + PUBLISH, + UNSUBSCRIBE, + PSUBSCRIBE, + PUNSUBSCRIBE, + ZCOUNT, + ZRANGEBYSCORE, + ZREMRANGEBYRANK, + ZREMRANGEBYSCORE, + ZUNIONSTORE, + ZINTERSTORE, + SAVE, + BGSAVE, + BGREWRITEAOF, + LASTSAVE, + SHUTDOWN, + INFO, + MONITOR, + SLAVEOF, + CONFIG, + STRLEN, + SYNC, + LPUSHX, + PERSIST, + RPUSHX, + ECHO, + LINSERT, + DEBUG; + + public final byte[] raw; + + Command() { + raw = this.name().getBytes(UTF8); + } + } + + public static enum Keyword { + AGGREGATE, + ALPHA, + ASC, + BY, + DESC, + GET, + NO, + NOSORT, + ONE, + LIMIT, + SET, + STORE, + WEIGHTS, + WITHSCORES; + public final byte[] raw; + + Keyword() { + raw = this.name().getBytes(UTF8); + } + + } } \ No newline at end of file diff --git a/src/main/java/redis/clients/jedis/SortingParams.java b/src/main/java/redis/clients/jedis/SortingParams.java index dcd415d..66fd997 100644 --- a/src/main/java/redis/clients/jedis/SortingParams.java +++ b/src/main/java/redis/clients/jedis/SortingParams.java @@ -4,13 +4,13 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; - +import static redis.clients.jedis.Protocol.Keyword.*; /** * Builder Class for {@link Jedis#sort(String, SortingParams) SORT} Parameters. * */ public class SortingParams { - private List params = new ArrayList(); + private List params = new ArrayList(); /** * Sort by weight in keys. @@ -25,9 +25,9 @@ public class SortingParams { * @param pattern * @return the SortingParams Object */ - public SortingParams by(String pattern) { - params.add("BY"); - params.add(pattern); + public SortingParams by(final String pattern) { + params.add(BY.raw); + params.add(pattern.getBytes(Protocol.UTF8)); return this; } @@ -40,11 +40,12 @@ public class SortingParams { * @return the SortingParams Object */ public SortingParams nosort() { - params.add("BY nosort"); + params.add(BY.raw); + params.add(NOSORT.raw); return this; } - public Collection getParams() { + public Collection getParams() { return Collections.unmodifiableCollection(params); } @@ -54,7 +55,7 @@ public class SortingParams { * @return the sortingParams Object */ public SortingParams desc() { - params.add("DESC"); + params.add(DESC.raw); return this; } @@ -64,7 +65,7 @@ public class SortingParams { * @return the SortingParams Object */ public SortingParams asc() { - params.add("ASC"); + params.add(ASC.raw); return this; } @@ -76,10 +77,10 @@ public class SortingParams { * @param count * @return the SortingParams Object */ - public SortingParams limit(int start, int count) { - params.add("LIMIT"); - params.add(String.valueOf(start)); - params.add(String.valueOf(count)); + public SortingParams limit(final int start, final int count) { + params.add(LIMIT.raw); + params.add(Protocol.toByteArray(start)); + params.add(Protocol.toByteArray(count)); return this; } @@ -90,7 +91,7 @@ public class SortingParams { * @return the SortingParams Object */ public SortingParams alpha() { - params.add("ALPHA"); + params.add(ALPHA.raw); return this; } @@ -110,9 +111,9 @@ public class SortingParams { * @return the SortingParams Object */ public SortingParams get(String... patterns) { - for (String pattern : patterns) { - params.add("GET"); - params.add(pattern); + for (final String pattern : patterns) { + params.add(GET.raw); + params.add(pattern.getBytes(Protocol.UTF8)); } return this; } diff --git a/src/main/java/redis/clients/jedis/ZParams.java b/src/main/java/redis/clients/jedis/ZParams.java index 86d9078..a260397 100644 --- a/src/main/java/redis/clients/jedis/ZParams.java +++ b/src/main/java/redis/clients/jedis/ZParams.java @@ -5,29 +5,36 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static redis.clients.jedis.Protocol.Keyword.*; + public class ZParams { public enum Aggregate { - SUM, MIN, MAX + SUM, MIN, MAX; + + public final byte[] raw; + Aggregate() { + raw = name().getBytes(Protocol.UTF8); + } } - private List params = new ArrayList(); + private List params = new ArrayList(); - public ZParams weights(int... weights) { - params.add("WEIGHTS"); - for (int weight : weights) { - params.add(String.valueOf(weight)); + public ZParams weights(final int... weights) { + params.add(WEIGHTS.raw); + for (final int weight : weights) { + params.add(Protocol.toByteArray(weight)); } return this; } - public Collection getParams() { - return Collections.unmodifiableCollection(params); + public Collection getParams() { + return Collections.unmodifiableCollection(params); } - public ZParams aggregate(Aggregate aggregate) { - params.add("AGGREGATE"); - params.add(aggregate.name()); + public ZParams aggregate(final Aggregate aggregate) { + params.add(AGGREGATE.raw); + params.add(aggregate.raw); return this; } } diff --git a/src/main/java/redis/clients/util/RedisOutputStream.java b/src/main/java/redis/clients/util/RedisOutputStream.java index c5f4bc2..5708d43 100644 --- a/src/main/java/redis/clients/util/RedisOutputStream.java +++ b/src/main/java/redis/clients/util/RedisOutputStream.java @@ -12,11 +12,11 @@ public final class RedisOutputStream extends FilterOutputStream { protected int count; - public RedisOutputStream(OutputStream out) { + public RedisOutputStream(final OutputStream out) { this(out, 8192); } - public RedisOutputStream(OutputStream out, int size) { + public RedisOutputStream(final OutputStream out, final int size) { super(out); if (size <= 0) { throw new IllegalArgumentException("Buffer size <= 0"); @@ -31,14 +31,18 @@ public final class RedisOutputStream extends FilterOutputStream { } } - public void write(int b) throws IOException { - buf[count++] = (byte) b; + public void write(final byte b) throws IOException { + buf[count++] = b; if (count == buf.length) { flushBuffer(); } } + + public void write(final byte[] b) throws IOException { + write(b, 0, b.length); + } - public void write(byte b[], int off, int len) throws IOException { + public void write(final byte b[], final int off, final int len) throws IOException { if (len >= buf.length) { flushBuffer(); out.write(b, off, len); @@ -52,7 +56,7 @@ public final class RedisOutputStream extends FilterOutputStream { } } - public void writeAsciiCrLf(String in) throws IOException { + public void writeAsciiCrLf(final String in) throws IOException { final int size = in.length(); for (int i = 0; i != size; ++i) { @@ -65,11 +69,11 @@ public final class RedisOutputStream extends FilterOutputStream { writeCrLf(); } - public static boolean isSurrogate(char ch) { + public static boolean isSurrogate(final char ch) { return ch >= Character.MIN_SURROGATE && ch <= Character.MAX_SURROGATE; } - public static int utf8Length (String str) { + public static int utf8Length (final String str) { int strLen = str.length(), utfLen = 0; for(int i = 0; i != strLen; ++i) { char c = str.charAt(i); @@ -96,7 +100,7 @@ public final class RedisOutputStream extends FilterOutputStream { buf[count++] = '\n'; } - public void writeUtf8CrLf(String str) throws IOException { + public void writeUtf8CrLf(final String str) throws IOException { int strLen = str.length(); int i;