diff --git a/src/main/java/redis/clients/jedis/BinaryClient.java b/src/main/java/redis/clients/jedis/BinaryClient.java
index 63d0d4b399..36be25f21e 100644
--- a/src/main/java/redis/clients/jedis/BinaryClient.java
+++ b/src/main/java/redis/clients/jedis/BinaryClient.java
@@ -347,7 +347,7 @@ public void lset(final byte[] key, final long index, final byte[] value) {
     sendCommand(LSET, key, toByteArray(index), value);
   }
 
-  public void lrem(final byte[] key, long count, final byte[] value) {
+  public void lrem(final byte[] key, final long count, final byte[] value) {
     sendCommand(LREM, key, toByteArray(count), value);
   }
 
@@ -660,28 +660,28 @@ public void zrevrangeByScore(final byte[] key, final String max, final String mi
   }
 
   public void zrangeByScore(final byte[] key, final double min, final double max, final int offset,
-      int count) {
+      final int count) {
 
     sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max), LIMIT.raw, toByteArray(offset),
       toByteArray(count));
   }
 
   public void zrangeByScore(final byte[] key, final String min, final String max, final int offset,
-      int count) {
+      final int count) {
 
     sendCommand(ZRANGEBYSCORE, key, min.getBytes(), max.getBytes(), LIMIT.raw, toByteArray(offset),
       toByteArray(count));
   }
 
   public void zrevrangeByScore(final byte[] key, final double max, final double min,
-      final int offset, int count) {
+      final int offset, final int count) {
 
     sendCommand(ZREVRANGEBYSCORE, key, toByteArray(max), toByteArray(min), LIMIT.raw, toByteArray(offset),
       toByteArray(count));
   }
 
   public void zrevrangeByScore(final byte[] key, final String max, final String min,
-      final int offset, int count) {
+      final int offset, final int count) {
 
     sendCommand(ZREVRANGEBYSCORE, key, max.getBytes(), min.getBytes(), LIMIT.raw,
       toByteArray(offset), toByteArray(count));
@@ -734,12 +734,12 @@ public void zrevrangeByScoreWithScores(final byte[] key, final String max, final
   }
 
   public void zrangeByScore(final byte[] key, final byte[] min, final byte[] max, final int offset,
-      int count) {
+      final int count) {
     sendCommand(ZRANGEBYSCORE, key, min, max, LIMIT.raw, toByteArray(offset), toByteArray(count));
   }
 
   public void zrevrangeByScore(final byte[] key, final byte[] max, final byte[] min,
-      final int offset, int count) {
+      final int offset, final int count) {
     sendCommand(ZREVRANGEBYSCORE, key, max, min, LIMIT.raw, toByteArray(offset), toByteArray(count));
   }
 
@@ -835,7 +835,7 @@ public void zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min,
     sendCommand(ZREVRANGEBYLEX, key, max, min, LIMIT.raw, toByteArray(offset), toByteArray(count));
   }
 
-  public void zremrangeByLex(byte[] key, byte[] min, byte[] max) {
+  public void zremrangeByLex(final byte[] key, final byte[] min, final byte[] max) {
     sendCommand(ZREMRANGEBYLEX, key, min, max);
   }
 
@@ -928,15 +928,15 @@ public void configResetStat() {
     sendCommand(CONFIG, Keyword.RESETSTAT.name());
   }
 
-  public void setbit(byte[] key, long offset, byte[] value) {
+  public void setbit(final byte[] key, final long offset, final byte[] value) {
     sendCommand(SETBIT, key, toByteArray(offset), value);
   }
 
-  public void setbit(byte[] key, long offset, boolean value) {
+  public void setbit(final byte[] key, final long offset, final boolean value) {
     sendCommand(SETBIT, key, toByteArray(offset), toByteArray(value));
   }
 
-  public void getbit(byte[] key, long offset) {
+  public void getbit(final byte[] key, final long offset) {
     sendCommand(GETBIT, key, toByteArray(offset));
   }
 
@@ -948,11 +948,11 @@ public void bitpos(final byte[] key, final boolean value, final BitPosParams par
     sendCommand(BITPOS, args.toArray(new byte[args.size()][]));
   }
 
-  public void setrange(byte[] key, long offset, byte[] value) {
+  public void setrange(final byte[] key, final long offset, final byte[] value) {
     sendCommand(SETRANGE, key, toByteArray(offset), value);
   }
 
-  public void getrange(byte[] key, long startOffset, long endOffset) {
+  public void getrange(final byte[] key, final long startOffset, final long endOffset) {
     sendCommand(GETRANGE, key, toByteArray(startOffset), toByteArray(endOffset));
   }
 
@@ -976,7 +976,7 @@ public void resetState() {
     if (isInWatch()) unwatch();
   }
 
-  private void sendEvalCommand(Command command, byte[] script, byte[] keyCount, byte[][] params) {
+  private void sendEvalCommand(final Command command, final byte[] script, final byte[] keyCount, final byte[][] params) {
 
     final byte[][] allArgs = new byte[params.length + 2][];
 
@@ -989,19 +989,19 @@ private void sendEvalCommand(Command command, byte[] script, byte[] keyCount, by
     sendCommand(command, allArgs);
   }
 
-  public void eval(byte[] script, byte[] keyCount, byte[][] params) {
+  public void eval(final byte[] script, final byte[] keyCount, final byte[][] params) {
     sendEvalCommand(EVAL, script, keyCount, params);
   }
 
-  public void eval(byte[] script, int keyCount, byte[]... params) {
+  public void eval(final byte[] script, final int keyCount, final byte[]... params) {
     eval(script, toByteArray(keyCount), params);
   }
 
-  public void evalsha(byte[] sha1, byte[] keyCount, byte[]... params) {
+  public void evalsha(final byte[] sha1, final byte[] keyCount, final byte[]... params) {
     sendEvalCommand(EVALSHA, sha1, keyCount, params);
   }
 
-  public void evalsha(byte[] sha1, int keyCount, byte[]... params) {
+  public void evalsha(final byte[] sha1, final int keyCount, final byte[]... params) {
     sendEvalCommand(EVALSHA, sha1, toByteArray(keyCount), params);
   }
 
@@ -1009,7 +1009,7 @@ public void scriptFlush() {
     sendCommand(SCRIPT, Keyword.FLUSH.raw);
   }
 
-  public void scriptExists(byte[]... sha1) {
+  public void scriptExists(final byte[]... sha1) {
     byte[][] args = new byte[sha1.length + 1][];
     args[0] = Keyword.EXISTS.raw;
     for (int i = 0; i < sha1.length; i++)
@@ -1018,7 +1018,7 @@ public void scriptExists(byte[]... sha1) {
     sendCommand(SCRIPT, args);
   }
 
-  public void scriptLoad(byte[] script) {
+  public void scriptLoad(final byte[] script) {
     sendCommand(SCRIPT, Keyword.LOAD.raw, script);
   }
 
@@ -1030,7 +1030,7 @@ public void slowlogGet() {
     sendCommand(SLOWLOG, Keyword.GET.raw);
   }
 
-  public void slowlogGet(long entries) {
+  public void slowlogGet(final long entries) {
     sendCommand(SLOWLOG, Keyword.GET.raw, toByteArray(entries));
   }
 
@@ -1042,27 +1042,27 @@ public void slowlogLen() {
     sendCommand(SLOWLOG, LEN.raw);
   }
 
-  public void objectRefcount(byte[] key) {
+  public void objectRefcount(final byte[] key) {
     sendCommand(OBJECT, REFCOUNT.raw, key);
   }
 
-  public void objectIdletime(byte[] key) {
+  public void objectIdletime(final byte[] key) {
     sendCommand(OBJECT, IDLETIME.raw, key);
   }
 
-  public void objectEncoding(byte[] key) {
+  public void objectEncoding(final byte[] key) {
     sendCommand(OBJECT, ENCODING.raw, key);
   }
 
-  public void bitcount(byte[] key) {
+  public void bitcount(final byte[] key) {
     sendCommand(BITCOUNT, key);
   }
 
-  public void bitcount(byte[] key, long start, long end) {
+  public void bitcount(final byte[] key, final long start, final long end) {
     sendCommand(BITCOUNT, key, toByteArray(start), toByteArray(end));
   }
 
-  public void bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
+  public void bitop(final BitOP op, final byte[] destKey, final byte[]... srcKeys) {
     Keyword kw = Keyword.AND;
     int len = srcKeys.length;
     switch (op) {
@@ -1149,7 +1149,7 @@ public void migrate(final byte[] host, final int port, final byte[] key, final i
       toByteArray(timeout));
   }
 
-  public void hincrByFloat(final byte[] key, final byte[] field, double increment) {
+  public void hincrByFloat(final byte[] key, final byte[] field, final double increment) {
     sendCommand(HINCRBYFLOAT, key, field, toByteArray(increment));
   }
 
@@ -1184,7 +1184,7 @@ public void zscan(final byte[] key, final byte[] cursor, final ScanParams params
     sendCommand(ZSCAN, args.toArray(new byte[args.size()][]));
   }
 
-  public void waitReplicas(int replicas, long timeout) {
+  public void waitReplicas(final int replicas, final long timeout) {
     sendCommand(WAIT, toByteArray(replicas), toByteArray(timeout));
   }
 
@@ -1216,11 +1216,11 @@ public void readonly() {
     sendCommand(READONLY);
   }
 
-  public void geoadd(byte[] key, double longitude, double latitude, byte[] member) {
+  public void geoadd(final byte[] key, final double longitude, final double latitude, final byte[] member) {
     sendCommand(GEOADD, key, toByteArray(longitude), toByteArray(latitude), member);
   }
 
-  public void geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap) {
+  public void geoadd(final byte[] key, final Map<byte[], GeoCoordinate> memberCoordinateMap) {
     List<byte[]> args = new ArrayList<byte[]>(memberCoordinateMap.size() * 3 + 1);
     args.add(key);
     args.addAll(convertGeoCoordinateMapToByteArrays(memberCoordinateMap));
@@ -1231,43 +1231,43 @@ public void geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap) {
     sendCommand(GEOADD, argsArray);
   }
 
-  public void geodist(byte[] key, byte[] member1, byte[] member2) {
+  public void geodist(final byte[] key, final byte[] member1, final byte[] member2) {
     sendCommand(GEODIST, key, member1, member2);
   }
 
-  public void geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
+  public void geodist(final byte[] key, final byte[] member1, final byte[] member2, final GeoUnit unit) {
     sendCommand(GEODIST, key, member1, member2, unit.raw);
   }
 
-  public void geohash(byte[] key, byte[]... members) {
+  public void geohash(final byte[] key, final byte[]... members) {
     sendCommand(GEOHASH, joinParameters(key, members));
   }
 
-  public void geopos(byte[] key, byte[][] members) {
+  public void geopos(final byte[] key, final byte[][] members) {
     sendCommand(GEOPOS, joinParameters(key, members));
   }
 
-  public void georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
+  public void georadius(final byte[] key, final double longitude, final double latitude, final double radius, final GeoUnit unit) {
     sendCommand(GEORADIUS, key, toByteArray(longitude), toByteArray(latitude), toByteArray(radius),
       unit.raw);
   }
 
-  public void georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit,
-      GeoRadiusParam param) {
+  public void georadius(final byte[] key, final double longitude, final double latitude, final double radius, final GeoUnit unit,
+      final GeoRadiusParam param) {
     sendCommand(GEORADIUS, param.getByteParams(key, toByteArray(longitude), toByteArray(latitude),
       toByteArray(radius), unit.raw));
   }
 
-  public void georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit) {
+  public void georadiusByMember(final byte[] key, final byte[] member, final double radius, final GeoUnit unit) {
     sendCommand(GEORADIUSBYMEMBER, key, member, toByteArray(radius), unit.raw);
   }
 
-  public void georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit,
-      GeoRadiusParam param) {
+  public void georadiusByMember(final byte[] key, final byte[] member, final double radius, final GeoUnit unit,
+      final GeoRadiusParam param) {
     sendCommand(GEORADIUSBYMEMBER, param.getByteParams(key, member, toByteArray(radius), unit.raw));
   }
 
-  public void moduleLoad(byte[] path) {
+  public void moduleLoad(final byte[] path) {
     sendCommand(MODULE, Keyword.LOAD.raw, path);
   }
 
@@ -1275,7 +1275,7 @@ public void moduleList() {
     sendCommand(MODULE, Keyword.LIST.raw);
   }
 
-  public void moduleUnload(byte[] name) {
+  public void moduleUnload(final byte[] name) {
     sendCommand(MODULE, Keyword.UNLOAD.raw, name);
   }
 
@@ -1291,7 +1291,7 @@ private ArrayList<byte[]> convertScoreMembersToByteArrays(final Map<byte[], Doub
   }
 
   private List<byte[]> convertGeoCoordinateMapToByteArrays(
-      Map<byte[], GeoCoordinate> memberCoordinateMap) {
+      final Map<byte[], GeoCoordinate> memberCoordinateMap) {
     List<byte[]> args = new ArrayList<byte[]>(memberCoordinateMap.size() * 3);
 
     for (Entry<byte[], GeoCoordinate> entry : memberCoordinateMap.entrySet()) {
diff --git a/src/main/java/redis/clients/jedis/BinaryJedis.java b/src/main/java/redis/clients/jedis/BinaryJedis.java
index ac60ae4d6b..1b1a523334 100644
--- a/src/main/java/redis/clients/jedis/BinaryJedis.java
+++ b/src/main/java/redis/clients/jedis/BinaryJedis.java
@@ -552,14 +552,14 @@ public Long ttl(final byte[] key) {
    * @return Integer reply: The number of keys that were touched.
    */
   @Override
-  public Long touch(byte[]... keys) {
+  public Long touch(final byte[]... keys) {
     checkIsInMultiOrPipeline();
     client.touch(keys);
     return client.getIntegerReply();
   }
 
   @Override
-  public Long touch(byte[] key) {
+  public Long touch(final byte[] key) {
     checkIsInMultiOrPipeline();
     client.touch(key);
     return client.getIntegerReply();
@@ -1677,7 +1677,7 @@ public Long zadd(final byte[] key, final double score, final byte[] member) {
   }
 
   @Override
-  public Long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
+  public Long zadd(final byte[] key, final double score, final byte[] member, final ZAddParams params) {
     checkIsInMultiOrPipeline();
     client.zadd(key, score, member, params);
     return client.getIntegerReply();
@@ -1691,7 +1691,7 @@ public Long zadd(final byte[] key, final Map<byte[], Double> scoreMembers) {
   }
 
   @Override
-  public Long zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
+  public Long zadd(final byte[] key, final Map<byte[], Double> scoreMembers, final ZAddParams params) {
     checkIsInMultiOrPipeline();
     client.zadd(key, scoreMembers, params);
     return client.getIntegerReply();
@@ -1749,7 +1749,7 @@ public Double zincrby(final byte[] key, final double score, final byte[] member)
   }
 
   @Override
-  public Double zincrby(byte[] key, double score, byte[] member, ZIncrByParams params) {
+  public Double zincrby(final byte[] key, final double score, final byte[] member, final ZIncrByParams params) {
     checkIsInMultiOrPipeline();
     client.zincrby(key, score, member, params);
     String newscore = client.getBulkReply();
@@ -2206,7 +2206,7 @@ public List<byte[]> brpop(final int timeout, final byte[]... keys) {
   }
 
   @Override
-  public List<byte[]> blpop(byte[]... args) {
+  public List<byte[]> blpop(final byte[]... args) {
     checkIsInMultiOrPipeline();
     client.blpop(args);
     client.setTimeoutInfinite();
@@ -2218,7 +2218,7 @@ public List<byte[]> blpop(byte[]... args) {
   }
 
   @Override
-  public List<byte[]> brpop(byte[]... args) {
+  public List<byte[]> brpop(final byte[]... args) {
     checkIsInMultiOrPipeline();
     client.brpop(args);
     client.setTimeoutInfinite();
@@ -2783,14 +2783,14 @@ public Set<byte[]> zrangeByLex(final byte[] key, final byte[] min, final byte[]
   }
 
   @Override
-  public Set<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min) {
+  public Set<byte[]> zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min) {
     checkIsInMultiOrPipeline();
     client.zrevrangeByLex(key, max, min);
     return SetFromList.of(client.getBinaryMultiBulkReply());
   }
 
   @Override
-  public Set<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count) {
+  public Set<byte[]> zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min, final int offset, final int count) {
     checkIsInMultiOrPipeline();
     client.zrevrangeByLex(key, max, min, offset, count);
     return SetFromList.of(client.getBinaryMultiBulkReply());
@@ -3143,7 +3143,7 @@ public Client getClient() {
    * @return the element
    */
   @Override
-  public byte[] brpoplpush(byte[] source, byte[] destination, int timeout) {
+  public byte[] brpoplpush(final byte[] source, final byte[] destination, final int timeout) {
     client.brpoplpush(source, destination, timeout);
     client.setTimeoutInfinite();
     try {
@@ -3161,13 +3161,13 @@ public byte[] brpoplpush(byte[] source, byte[] destination, int timeout) {
    * @return
    */
   @Override
-  public Boolean setbit(byte[] key, long offset, boolean value) {
+  public Boolean setbit(final byte[] key, final long offset, final boolean value) {
     client.setbit(key, offset, value);
     return client.getIntegerReply() == 1;
   }
 
   @Override
-  public Boolean setbit(byte[] key, long offset, byte[] value) {
+  public Boolean setbit(final byte[] key, final long offset, final byte[] value) {
     client.setbit(key, offset, value);
     return client.getIntegerReply() == 1;
   }
@@ -3179,7 +3179,7 @@ public Boolean setbit(byte[] key, long offset, byte[] value) {
    * @return
    */
   @Override
-  public Boolean getbit(byte[] key, long offset) {
+  public Boolean getbit(final byte[] key, final long offset) {
     client.getbit(key, offset);
     return client.getIntegerReply() == 1;
   }
@@ -3194,25 +3194,25 @@ public Long bitpos(final byte[] key, final boolean value, final BitPosParams par
   }
 
   @Override
-  public Long setrange(byte[] key, long offset, byte[] value) {
+  public Long setrange(final byte[] key, final long offset, final byte[] value) {
     client.setrange(key, offset, value);
     return client.getIntegerReply();
   }
 
   @Override
-  public byte[] getrange(byte[] key, long startOffset, long endOffset) {
+  public byte[] getrange(final byte[] key, final long startOffset, final long endOffset) {
     client.getrange(key, startOffset, endOffset);
     return client.getBinaryBulkReply();
   }
 
   @Override
-  public Long publish(byte[] channel, byte[] message) {
+  public Long publish(final byte[] channel, final byte[] message) {
     client.publish(channel, message);
     return client.getIntegerReply();
   }
 
   @Override
-  public void subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels) {
+  public void subscribe(BinaryJedisPubSub jedisPubSub, final byte[]... channels) {
     client.setTimeoutInfinite();
     try {
       jedisPubSub.proceed(client, channels);
@@ -3222,7 +3222,7 @@ public void subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels) {
   }
 
   @Override
-  public void psubscribe(BinaryJedisPubSub jedisPubSub, byte[]... patterns) {
+  public void psubscribe(BinaryJedisPubSub jedisPubSub, final byte[]... patterns) {
     client.setTimeoutInfinite();
     try {
       jedisPubSub.proceedWithPatterns(client, patterns);
@@ -3242,7 +3242,7 @@ public int getDB() {
    * @return Script result
    */
   @Override
-  public Object eval(byte[] script, List<byte[]> keys, List<byte[]> args) {
+  public Object eval(final byte[] script, final List<byte[]> keys, final List<byte[]> args) {
     return eval(script, toByteArray(keys.size()), getParamsWithBinary(keys, args));
   }
 
@@ -3261,7 +3261,7 @@ protected static byte[][] getParamsWithBinary(List<byte[]> keys, List<byte[]> ar
   }
 
   @Override
-  public Object eval(byte[] script, byte[] keyCount, byte[]... params) {
+  public Object eval(final byte[] script, final byte[] keyCount, final byte[]... params) {
     client.setTimeoutInfinite();
     try {
       client.eval(script, keyCount, params);
@@ -3272,27 +3272,27 @@ public Object eval(byte[] script, byte[] keyCount, byte[]... params) {
   }
 
   @Override
-  public Object eval(byte[] script, int keyCount, byte[]... params) {
+  public Object eval(final byte[] script, final int keyCount, final byte[]... params) {
     return eval(script, toByteArray(keyCount), params);
   }
 
   @Override
-  public Object eval(byte[] script) {
+  public Object eval(final byte[] script) {
     return eval(script, 0);
   }
 
   @Override
-  public Object evalsha(byte[] sha1) {
+  public Object evalsha(final byte[] sha1) {
     return evalsha(sha1, 1);
   }
 
   @Override
-  public Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
+  public Object evalsha(final byte[] sha1, final List<byte[]> keys, final List<byte[]> args) {
     return evalsha(sha1, keys.size(), getParamsWithBinary(keys, args));
   }
 
   @Override
-  public Object evalsha(byte[] sha1, int keyCount, byte[]... params) {
+  public Object evalsha(final byte[] sha1, final int keyCount, final byte[]... params) {
     client.setTimeoutInfinite();
     try {
       client.evalsha(sha1, keyCount, params);
@@ -3308,20 +3308,20 @@ public String scriptFlush() {
     return client.getStatusCodeReply();
   }
 
-  public Long scriptExists(byte[] sha1) {
+  public Long scriptExists(final byte[] sha1) {
     byte[][] a = new byte[1][];
     a[0] = sha1;
     return scriptExists(a).get(0);
   }
 
   @Override
-  public List<Long> scriptExists(byte[]... sha1) {
+  public List<Long> scriptExists(final byte[]... sha1) {
     client.scriptExists(sha1);
     return client.getIntegerMultiBulkReply();
   }
 
   @Override
-  public byte[] scriptLoad(byte[] script) {
+  public byte[] scriptLoad(final byte[] script) {
     client.scriptLoad(script);
     return client.getBinaryBulkReply();
   }
@@ -3351,25 +3351,25 @@ public List<byte[]> slowlogGetBinary() {
   }
 
   @Override
-  public List<byte[]> slowlogGetBinary(long entries) {
+  public List<byte[]> slowlogGetBinary(final long entries) {
     client.slowlogGet(entries);
     return client.getBinaryMultiBulkReply();
   }
 
   @Override
-  public Long objectRefcount(byte[] key) {
+  public Long objectRefcount(final byte[] key) {
     client.objectRefcount(key);
     return client.getIntegerReply();
   }
 
   @Override
-  public byte[] objectEncoding(byte[] key) {
+  public byte[] objectEncoding(final byte[] key) {
     client.objectEncoding(key);
     return client.getBinaryBulkReply();
   }
 
   @Override
-  public Long objectIdletime(byte[] key) {
+  public Long objectIdletime(final byte[] key) {
     client.objectIdletime(key);
     return client.getIntegerReply();
   }
@@ -3381,13 +3381,13 @@ public Long bitcount(final byte[] key) {
   }
 
   @Override
-  public Long bitcount(final byte[] key, long start, long end) {
+  public Long bitcount(final byte[] key, final long start, final long end) {
     client.bitcount(key, start, end);
     return client.getIntegerReply();
   }
 
   @Override
-  public Long bitop(BitOP op, final byte[] destKey, byte[]... srcKeys) {
+  public Long bitop(final BitOP op, final byte[] destKey, final byte[]... srcKeys) {
     client.bitop(op, destKey, srcKeys);
     return client.getIntegerReply();
   }
@@ -3502,7 +3502,7 @@ public String migrate(final byte[] host, final int port, final byte[] key,
    * the method. Sorry :S
    */
   @Override
-  public Long waitReplicas(int replicas, long timeout) {
+  public Long waitReplicas(final int replicas, final long timeout) {
     checkIsInMultiOrPipeline();
     client.waitReplicas(replicas, timeout);
     return client.getIntegerReply();
@@ -3530,7 +3530,7 @@ public String pfmerge(final byte[] destkey, final byte[]... sourcekeys) {
   }
 
   @Override
-  public Long pfcount(byte[]... keys) {
+  public Long pfcount(final byte[]... keys) {
     checkIsInMultiOrPipeline();
     client.pfcount(keys);
     return client.getIntegerReply();
@@ -3606,21 +3606,21 @@ public ScanResult<Tuple> zscan(final byte[] key, final byte[] cursor, final Scan
   }
 
   @Override
-  public Long geoadd(byte[] key, double longitude, double latitude, byte[] member) {
+  public Long geoadd(final byte[] key, final double longitude, final double latitude, final byte[] member) {
     checkIsInMultiOrPipeline();
     client.geoadd(key, longitude, latitude, member);
     return client.getIntegerReply();
   }
 
   @Override
-  public Long geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap) {
+  public Long geoadd(final byte[] key, final Map<byte[], GeoCoordinate> memberCoordinateMap) {
     checkIsInMultiOrPipeline();
     client.geoadd(key, memberCoordinateMap);
     return client.getIntegerReply();
   }
 
   @Override
-  public Double geodist(byte[] key, byte[] member1, byte[] member2) {
+  public Double geodist(final byte[] key, final byte[] member1, final byte[] member2) {
     checkIsInMultiOrPipeline();
     client.geodist(key, member1, member2);
     String dval = client.getBulkReply();
@@ -3628,7 +3628,7 @@ public Double geodist(byte[] key, byte[] member1, byte[] member2) {
   }
 
   @Override
-  public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
+  public Double geodist(final byte[] key, final byte[] member1, final byte[] member2, final GeoUnit unit) {
     checkIsInMultiOrPipeline();
     client.geodist(key, member1, member2, unit);
     String dval = client.getBulkReply();
@@ -3636,46 +3636,46 @@ public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit)
   }
 
   @Override
-  public List<byte[]> geohash(byte[] key, byte[]... members) {
+  public List<byte[]> geohash(final byte[] key, final byte[]... members) {
     checkIsInMultiOrPipeline();
     client.geohash(key, members);
     return client.getBinaryMultiBulkReply();
   }
 
   @Override
-  public List<GeoCoordinate> geopos(byte[] key, byte[]... members) {
+  public List<GeoCoordinate> geopos(final byte[] key, final byte[]... members) {
     checkIsInMultiOrPipeline();
     client.geopos(key, members);
     return BuilderFactory.GEO_COORDINATE_LIST.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude,
-      double radius, GeoUnit unit) {
+  public List<GeoRadiusResponse> georadius(final byte[] key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit) {
     checkIsInMultiOrPipeline();
     client.georadius(key, longitude, latitude, radius, unit);
     return BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude,
-      double radius, GeoUnit unit, GeoRadiusParam param) {
+  public List<GeoRadiusResponse> georadius(final byte[] key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
     checkIsInMultiOrPipeline();
     client.georadius(key, longitude, latitude, radius, unit, param);
     return BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius,
-      GeoUnit unit) {
+  public List<GeoRadiusResponse> georadiusByMember(final byte[] key, final byte[] member, final double radius,
+      final GeoUnit unit) {
     checkIsInMultiOrPipeline();
     client.georadiusByMember(key, member, radius, unit);
     return BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius,
-      GeoUnit unit, GeoRadiusParam param) {
+  public List<GeoRadiusResponse> georadiusByMember(final byte[] key, final byte[] member, final double radius,
+      final GeoUnit unit, final GeoRadiusParam param) {
     checkIsInMultiOrPipeline();
     client.georadiusByMember(key, member, radius, unit, param);
     return BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT.build(client.getObjectMultiBulkReply());
@@ -3793,14 +3793,14 @@ protected static <E> SetFromList<E> of(List<E> list) {
   }
 
   @Override
-  public List<Long> bitfield(byte[] key, byte[]... arguments) {
+  public List<Long> bitfield(final byte[] key, final byte[]... arguments) {
     checkIsInMultiOrPipeline();
     client.bitfield(key, arguments);
     return client.getIntegerMultiBulkReply();
   }
 
   @Override
-  public Long hstrlen(byte[] key, byte[] field) {
+  public Long hstrlen(final byte[] key, final byte[] field) {
     checkIsInMultiOrPipeline();
     client.hstrlen(key, field);
     return client.getIntegerReply();
diff --git a/src/main/java/redis/clients/jedis/BinaryJedisCluster.java b/src/main/java/redis/clients/jedis/BinaryJedisCluster.java
index 7029367b95..46a085b154 100644
--- a/src/main/java/redis/clients/jedis/BinaryJedisCluster.java
+++ b/src/main/java/redis/clients/jedis/BinaryJedisCluster.java
@@ -1304,7 +1304,7 @@ public Object execute(Jedis connection) {
   }
 
   @Override
-  public Object eval(final byte[] script, byte[] key) {
+  public Object eval(final byte[] script, final byte[] key) {
     return new JedisClusterCommand<Object>(connectionHandler, maxAttempts) {
       @Override
       public Object execute(Jedis connection) {
@@ -1314,7 +1314,7 @@ public Object execute(Jedis connection) {
   }
 
   @Override
-  public Object evalsha(final byte[] sha1, byte[] key) {
+  public Object evalsha(final byte[] sha1, final byte[] key) {
     return new JedisClusterCommand<Object>(connectionHandler, maxAttempts) {
       @Override
       public Object execute(Jedis connection) {
@@ -1374,7 +1374,7 @@ public String execute(Jedis connection) {
   }
 
   @Override
-  public String scriptKill(byte[] key) {
+  public String scriptKill(final byte[] key) {
     return new JedisClusterCommand<String>(connectionHandler, maxAttempts) {
       @Override
       public String execute(Jedis connection) {
diff --git a/src/main/java/redis/clients/jedis/BinaryShardedJedis.java b/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
index d6e7a61eb6..208464cfd7 100644
--- a/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
+++ b/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
@@ -54,109 +54,109 @@ protected Jedis create(JedisShardInfo shard) {
   }
 
   @Override
-  public String set(byte[] key, byte[] value) {
+  public String set(final byte[] key, final byte[] value) {
     Jedis j = getShard(key);
     return j.set(key, value);
   }
 
   @Override
-  public String set(byte[] key, byte[] value, SetParams params) {
+  public String set(final byte[] key, final byte[] value, SetParams params) {
     Jedis j = getShard(key);
     return j.set(key, value, params);
   }
 
   @Override
-  public byte[] get(byte[] key) {
+  public byte[] get(final byte[] key) {
     Jedis j = getShard(key);
     return j.get(key);
   }
 
   @Override
-  public Boolean exists(byte[] key) {
+  public Boolean exists(final byte[] key) {
     Jedis j = getShard(key);
     return j.exists(key);
   }
 
   @Override
-  public String type(byte[] key) {
+  public String type(final byte[] key) {
     Jedis j = getShard(key);
     return j.type(key);
   }
 
   @Override
-  public Long expire(byte[] key, int seconds) {
+  public Long expire(final byte[] key, final int seconds) {
     Jedis j = getShard(key);
     return j.expire(key, seconds);
   }
 
   @Override
-  public Long pexpire(byte[] key, final long milliseconds) {
+  public Long pexpire(final byte[] key, final long milliseconds) {
     Jedis j = getShard(key);
     return j.pexpire(key, milliseconds);
   }
 
   @Override
-  public Long expireAt(byte[] key, long unixTime) {
+  public Long expireAt(final byte[] key, final long unixTime) {
     Jedis j = getShard(key);
     return j.expireAt(key, unixTime);
   }
 
   @Override
-  public Long pexpireAt(byte[] key, long millisecondsTimestamp) {
+  public Long pexpireAt(final byte[] key, final long millisecondsTimestamp) {
     Jedis j = getShard(key);
     return j.pexpireAt(key, millisecondsTimestamp);
   }
 
   @Override
-  public Long ttl(byte[] key) {
+  public Long ttl(final byte[] key) {
     Jedis j = getShard(key);
     return j.ttl(key);
   }
 
   @Override
-  public Long touch(byte[] key) {
+  public Long touch(final byte[] key) {
     Jedis j = getShard(key);
     return j.touch(key);
   }
 
   @Override
-  public byte[] getSet(byte[] key, byte[] value) {
+  public byte[] getSet(final byte[] key, final byte[] value) {
     Jedis j = getShard(key);
     return j.getSet(key, value);
   }
 
   @Override
-  public Long setnx(byte[] key, byte[] value) {
+  public Long setnx(final byte[] key, final byte[] value) {
     Jedis j = getShard(key);
     return j.setnx(key, value);
   }
 
   @Override
-  public String setex(byte[] key, int seconds, byte[] value) {
+  public String setex(final byte[] key, final int seconds, final byte[] value) {
     Jedis j = getShard(key);
     return j.setex(key, seconds, value);
   }
 
   @Override
-  public String psetex(byte[] key, long milliseconds, byte[] value) {
+  public String psetex(final byte[] key, final long milliseconds, final byte[] value) {
     Jedis j = getShard(key);
     return j.psetex(key, milliseconds, value);
   }
 
   @Override
-  public Long decrBy(byte[] key, long integer) {
+  public Long decrBy(final byte[] key, final long integer) {
     Jedis j = getShard(key);
     return j.decrBy(key, integer);
   }
 
   @Override
-  public Long decr(byte[] key) {
+  public Long decr(final byte[] key) {
     Jedis j = getShard(key);
     return j.decr(key);
   }
 
   @Override
-  public Long del(byte[] key) {
+  public Long del(final byte[] key) {
     Jedis j = getShard(key);
     return j.del(key);
   }
@@ -168,121 +168,121 @@ public Long unlink(final byte[] key) {
   }
 
   @Override
-  public Long incrBy(byte[] key, long integer) {
+  public Long incrBy(final byte[] key, final long integer) {
     Jedis j = getShard(key);
     return j.incrBy(key, integer);
   }
 
   @Override
-  public Double incrByFloat(byte[] key, double integer) {
+  public Double incrByFloat(final byte[] key, final double integer) {
     Jedis j = getShard(key);
     return j.incrByFloat(key, integer);
   }
 
   @Override
-  public Long incr(byte[] key) {
+  public Long incr(final byte[] key) {
     Jedis j = getShard(key);
     return j.incr(key);
   }
 
   @Override
-  public Long append(byte[] key, byte[] value) {
+  public Long append(final byte[] key, final byte[] value) {
     Jedis j = getShard(key);
     return j.append(key, value);
   }
 
   @Override
-  public byte[] substr(byte[] key, int start, int end) {
+  public byte[] substr(final byte[] key, final int start, final int end) {
     Jedis j = getShard(key);
     return j.substr(key, start, end);
   }
 
   @Override
-  public Long hset(byte[] key, byte[] field, byte[] value) {
+  public Long hset(final byte[] key, final byte[] field, final byte[] value) {
     Jedis j = getShard(key);
     return j.hset(key, field, value);
   }
 
   @Override
-  public byte[] hget(byte[] key, byte[] field) {
+  public byte[] hget(final byte[] key, final byte[] field) {
     Jedis j = getShard(key);
     return j.hget(key, field);
   }
 
   @Override
-  public Long hsetnx(byte[] key, byte[] field, byte[] value) {
+  public Long hsetnx(final byte[] key, final byte[] field, final byte[] value) {
     Jedis j = getShard(key);
     return j.hsetnx(key, field, value);
   }
 
   @Override
-  public String hmset(byte[] key, Map<byte[], byte[]> hash) {
+  public String hmset(final byte[] key, final Map<byte[], byte[]> hash) {
     Jedis j = getShard(key);
     return j.hmset(key, hash);
   }
 
   @Override
-  public List<byte[]> hmget(byte[] key, byte[]... fields) {
+  public List<byte[]> hmget(final byte[] key, final byte[]... fields) {
     Jedis j = getShard(key);
     return j.hmget(key, fields);
   }
 
   @Override
-  public Long hincrBy(byte[] key, byte[] field, long value) {
+  public Long hincrBy(final byte[] key, final byte[] field, final long value) {
     Jedis j = getShard(key);
     return j.hincrBy(key, field, value);
   }
 
   @Override
-  public Double hincrByFloat(byte[] key, byte[] field, double value) {
+  public Double hincrByFloat(final byte[] key, final byte[] field, final double value) {
     Jedis j = getShard(key);
     return j.hincrByFloat(key, field, value);
   }
 
   @Override
-  public Boolean hexists(byte[] key, byte[] field) {
+  public Boolean hexists(final byte[] key, final byte[] field) {
     Jedis j = getShard(key);
     return j.hexists(key, field);
   }
 
   @Override
-  public Long hdel(byte[] key, byte[]... fields) {
+  public Long hdel(final byte[] key, final byte[]... fields) {
     Jedis j = getShard(key);
     return j.hdel(key, fields);
   }
 
   @Override
-  public Long hlen(byte[] key) {
+  public Long hlen(final byte[] key) {
     Jedis j = getShard(key);
     return j.hlen(key);
   }
 
   @Override
-  public Set<byte[]> hkeys(byte[] key) {
+  public Set<byte[]> hkeys(final byte[] key) {
     Jedis j = getShard(key);
     return j.hkeys(key);
   }
 
   @Override
-  public Collection<byte[]> hvals(byte[] key) {
+  public Collection<byte[]> hvals(final byte[] key) {
     Jedis j = getShard(key);
     return j.hvals(key);
   }
 
   @Override
-  public Map<byte[], byte[]> hgetAll(byte[] key) {
+  public Map<byte[], byte[]> hgetAll(final byte[] key) {
     Jedis j = getShard(key);
     return j.hgetAll(key);
   }
 
   @Override
-  public Long rpush(byte[] key, byte[]... strings) {
+  public Long rpush(final byte[] key, final byte[]... strings) {
     Jedis j = getShard(key);
     return j.rpush(key, strings);
   }
 
   @Override
-  public Long lpush(byte[] key, byte[]... strings) {
+  public Long lpush(final byte[] key, final byte[]... strings) {
     Jedis j = getShard(key);
     return j.lpush(key, strings);
   }
@@ -294,7 +294,7 @@ public Long strlen(final byte[] key) {
   }
 
   @Override
-  public Long lpushx(byte[] key, byte[]... string) {
+  public Long lpushx(final byte[] key, final byte[]... string) {
     Jedis j = getShard(key);
     return j.lpushx(key, string);
   }
@@ -306,341 +306,341 @@ public Long persist(final byte[] key) {
   }
 
   @Override
-  public Long rpushx(byte[] key, byte[]... string) {
+  public Long rpushx(final byte[] key, final byte[]... string) {
     Jedis j = getShard(key);
     return j.rpushx(key, string);
   }
 
   @Override
-  public Long llen(byte[] key) {
+  public Long llen(final byte[] key) {
     Jedis j = getShard(key);
     return j.llen(key);
   }
 
   @Override
-  public List<byte[]> lrange(byte[] key, long start, long end) {
+  public List<byte[]> lrange(final byte[] key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.lrange(key, start, end);
   }
 
   @Override
-  public String ltrim(byte[] key, long start, long end) {
+  public String ltrim(final byte[] key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.ltrim(key, start, end);
   }
 
   @Override
-  public byte[] lindex(byte[] key, long index) {
+  public byte[] lindex(final byte[] key, final long index) {
     Jedis j = getShard(key);
     return j.lindex(key, index);
   }
 
   @Override
-  public String lset(byte[] key, long index, byte[] value) {
+  public String lset(final byte[] key, final long index, final byte[] value) {
     Jedis j = getShard(key);
     return j.lset(key, index, value);
   }
 
   @Override
-  public Long lrem(byte[] key, long count, byte[] value) {
+  public Long lrem(final byte[] key, final long count, final byte[] value) {
     Jedis j = getShard(key);
     return j.lrem(key, count, value);
   }
 
   @Override
-  public byte[] lpop(byte[] key) {
+  public byte[] lpop(final byte[] key) {
     Jedis j = getShard(key);
     return j.lpop(key);
   }
 
   @Override
-  public byte[] rpop(byte[] key) {
+  public byte[] rpop(final byte[] key) {
     Jedis j = getShard(key);
     return j.rpop(key);
   }
 
   @Override
-  public Long sadd(byte[] key, byte[]... members) {
+  public Long sadd(final byte[] key, final byte[]... members) {
     Jedis j = getShard(key);
     return j.sadd(key, members);
   }
 
   @Override
-  public Set<byte[]> smembers(byte[] key) {
+  public Set<byte[]> smembers(final byte[] key) {
     Jedis j = getShard(key);
     return j.smembers(key);
   }
 
   @Override
-  public Long srem(byte[] key, byte[]... members) {
+  public Long srem(final byte[] key, final byte[]... members) {
     Jedis j = getShard(key);
     return j.srem(key, members);
   }
 
   @Override
-  public byte[] spop(byte[] key) {
+  public byte[] spop(final byte[] key) {
     Jedis j = getShard(key);
     return j.spop(key);
   }
 
   @Override
-  public Set<byte[]> spop(byte[] key, long count) {
+  public Set<byte[]> spop(final byte[] key, final long count) {
     Jedis j = getShard(key);
     return j.spop(key, count);
   }
 
   @Override
-  public Long scard(byte[] key) {
+  public Long scard(final byte[] key) {
     Jedis j = getShard(key);
     return j.scard(key);
   }
 
   @Override
-  public Boolean sismember(byte[] key, byte[] member) {
+  public Boolean sismember(final byte[] key, final byte[] member) {
     Jedis j = getShard(key);
     return j.sismember(key, member);
   }
 
   @Override
-  public byte[] srandmember(byte[] key) {
+  public byte[] srandmember(final byte[] key) {
     Jedis j = getShard(key);
     return j.srandmember(key);
   }
 
   @Override
-  public List srandmember(byte[] key, int count) {
+  public List srandmember(final byte[] key, final int count) {
     Jedis j = getShard(key);
     return j.srandmember(key, count);
   }
 
   @Override
-  public Long zadd(byte[] key, double score, byte[] member) {
+  public Long zadd(final byte[] key, final double score, final byte[] member) {
     Jedis j = getShard(key);
     return j.zadd(key, score, member);
   }
 
   @Override
-  public Long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
+  public Long zadd(final byte[] key, final double score, final byte[] member, final ZAddParams params) {
     Jedis j = getShard(key);
     return j.zadd(key, score, member, params);
   }
 
   @Override
-  public Long zadd(byte[] key, Map<byte[], Double> scoreMembers) {
+  public Long zadd(final byte[] key, final Map<byte[], Double> scoreMembers) {
     Jedis j = getShard(key);
     return j.zadd(key, scoreMembers);
   }
 
   @Override
-  public Long zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
+  public Long zadd(final byte[] key, final Map<byte[], Double> scoreMembers, final ZAddParams params) {
     Jedis j = getShard(key);
     return j.zadd(key, scoreMembers, params);
   }
 
   @Override
-  public Set<byte[]> zrange(byte[] key, long start, long end) {
+  public Set<byte[]> zrange(final byte[] key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zrange(key, start, end);
   }
 
   @Override
-  public Long zrem(byte[] key, byte[]... members) {
+  public Long zrem(final byte[] key, final byte[]... members) {
     Jedis j = getShard(key);
     return j.zrem(key, members);
   }
 
   @Override
-  public Double zincrby(byte[] key, double score, byte[] member) {
+  public Double zincrby(final byte[] key, final double score, final byte[] member) {
     Jedis j = getShard(key);
     return j.zincrby(key, score, member);
   }
 
   @Override
-  public Double zincrby(byte[] key, double score, byte[] member, ZIncrByParams params) {
+  public Double zincrby(final byte[] key, final double score, final byte[] member, ZIncrByParams params) {
     Jedis j = getShard(key);
     return j.zincrby(key, score, member, params);
   }
 
   @Override
-  public Long zrank(byte[] key, byte[] member) {
+  public Long zrank(final byte[] key, final byte[] member) {
     Jedis j = getShard(key);
     return j.zrank(key, member);
   }
 
   @Override
-  public Long zrevrank(byte[] key, byte[] member) {
+  public Long zrevrank(final byte[] key, final byte[] member) {
     Jedis j = getShard(key);
     return j.zrevrank(key, member);
   }
 
   @Override
-  public Set<byte[]> zrevrange(byte[] key, long start, long end) {
+  public Set<byte[]> zrevrange(final byte[] key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zrevrange(key, start, end);
   }
 
   @Override
-  public Set<Tuple> zrangeWithScores(byte[] key, long start, long end) {
+  public Set<Tuple> zrangeWithScores(final byte[] key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zrangeWithScores(key, start, end);
   }
 
   @Override
-  public Set<Tuple> zrevrangeWithScores(byte[] key, long start, long end) {
+  public Set<Tuple> zrevrangeWithScores(final byte[] key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zrevrangeWithScores(key, start, end);
   }
 
   @Override
-  public Long zcard(byte[] key) {
+  public Long zcard(final byte[] key) {
     Jedis j = getShard(key);
     return j.zcard(key);
   }
 
   @Override
-  public Double zscore(byte[] key, byte[] member) {
+  public Double zscore(final byte[] key, final byte[] member) {
     Jedis j = getShard(key);
     return j.zscore(key, member);
   }
 
   @Override
-  public List<byte[]> sort(byte[] key) {
+  public List<byte[]> sort(final byte[] key) {
     Jedis j = getShard(key);
     return j.sort(key);
   }
 
   @Override
-  public List<byte[]> sort(byte[] key, SortingParams sortingParameters) {
+  public List<byte[]> sort(final byte[] key, SortingParams sortingParameters) {
     Jedis j = getShard(key);
     return j.sort(key, sortingParameters);
   }
 
   @Override
-  public Long zcount(byte[] key, double min, double max) {
+  public Long zcount(final byte[] key, final double min, final double max) {
     Jedis j = getShard(key);
     return j.zcount(key, min, max);
   }
 
   @Override
-  public Long zcount(byte[] key, byte[] min, byte[] max) {
+  public Long zcount(final byte[] key, final byte[] min, final byte[] max) {
     Jedis j = getShard(key);
     return j.zcount(key, min, max);
   }
 
   @Override
-  public Set<byte[]> zrangeByScore(byte[] key, double min, double max) {
+  public Set<byte[]> zrangeByScore(final byte[] key, final double min, final double max) {
     Jedis j = getShard(key);
     return j.zrangeByScore(key, min, max);
   }
 
   @Override
-  public Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
+  public Set<byte[]> zrangeByScore(final byte[] key, final double min, final double max, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrangeByScore(key, min, max, offset, count);
   }
 
   @Override
-  public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
+  public Set<Tuple> zrangeByScoreWithScores(final byte[] key, final double min, final double max) {
     Jedis j = getShard(key);
     return j.zrangeByScoreWithScores(key, min, max);
   }
 
   @Override
-  public Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset,
-      int count) {
+  public Set<Tuple> zrangeByScoreWithScores(final byte[] key, final double min, final double max, final int offset,
+      final int count) {
     Jedis j = getShard(key);
     return j.zrangeByScoreWithScores(key, min, max, offset, count);
   }
 
   @Override
-  public Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max) {
+  public Set<byte[]> zrangeByScore(final byte[] key, final byte[] min, final byte[] max) {
     Jedis j = getShard(key);
     return j.zrangeByScore(key, min, max);
   }
 
   @Override
-  public Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
+  public Set<Tuple> zrangeByScoreWithScores(final byte[] key, final byte[] min, final byte[] max) {
     Jedis j = getShard(key);
     return j.zrangeByScoreWithScores(key, min, max);
   }
 
   @Override
-  public Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset,
-      int count) {
+  public Set<Tuple> zrangeByScoreWithScores(final byte[] key, final byte[] min, final byte[] max, final int offset,
+      final int count) {
     Jedis j = getShard(key);
     return j.zrangeByScoreWithScores(key, min, max, offset, count);
   }
 
   @Override
-  public Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
+  public Set<byte[]> zrangeByScore(final byte[] key, final byte[] min, final byte[] max, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrangeByScore(key, min, max, offset, count);
   }
 
   @Override
-  public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
+  public Set<byte[]> zrevrangeByScore(final byte[] key, final double max, final double min) {
     Jedis j = getShard(key);
     return j.zrevrangeByScore(key, max, min);
   }
 
   @Override
-  public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
+  public Set<byte[]> zrevrangeByScore(final byte[] key, final double max, final double min, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByScore(key, max, min, offset, count);
   }
 
   @Override
-  public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
+  public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key, final double max, final double min) {
     Jedis j = getShard(key);
     return j.zrevrangeByScoreWithScores(key, max, min);
   }
 
   @Override
-  public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset,
-      int count) {
+  public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key, final double max, final double min, final int offset,
+      final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
   }
 
   @Override
-  public Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
+  public Set<byte[]> zrevrangeByScore(final byte[] key, final byte[] max, final byte[] min) {
     Jedis j = getShard(key);
     return j.zrevrangeByScore(key, max, min);
   }
 
   @Override
-  public Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
+  public Set<byte[]> zrevrangeByScore(final byte[] key, final byte[] max, final byte[] min, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByScore(key, max, min, offset, count);
   }
 
   @Override
-  public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
+  public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key, final byte[] max, final byte[] min) {
     Jedis j = getShard(key);
     return j.zrevrangeByScoreWithScores(key, max, min);
   }
 
   @Override
-  public Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset,
-      int count) {
+  public Set<Tuple> zrevrangeByScoreWithScores(final byte[] key, final byte[] max, final byte[] min, final int offset,
+      final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
   }
 
   @Override
-  public Long zremrangeByRank(byte[] key, long start, long end) {
+  public Long zremrangeByRank(final byte[] key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zremrangeByRank(key, start, end);
   }
 
   @Override
-  public Long zremrangeByScore(byte[] key, double start, double end) {
+  public Long zremrangeByScore(final byte[] key, final double start, final double end) {
     Jedis j = getShard(key);
     return j.zremrangeByScore(key, start, end);
   }
 
   @Override
-  public Long zremrangeByScore(byte[] key, byte[] start, byte[] end) {
+  public Long zremrangeByScore(final byte[] key, final byte[] start, final byte[] end) {
     Jedis j = getShard(key);
     return j.zremrangeByScore(key, start, end);
   }
@@ -665,13 +665,13 @@ public Set<byte[]> zrangeByLex(final byte[] key, final byte[] min, final byte[]
   }
 
   @Override
-  public Set<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min) {
+  public Set<byte[]> zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min) {
     Jedis j = getShard(key);
     return j.zrevrangeByLex(key, max, min);
   }
 
   @Override
-  public Set<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count) {
+  public Set<byte[]> zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByLex(key, max, min, offset, count);
   }
@@ -683,7 +683,7 @@ public Long zremrangeByLex(final byte[] key, final byte[] min, final byte[] max)
   }
 
   @Override
-  public Long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
+  public Long linsert(final byte[] key, final LIST_POSITION where, final byte[] pivot, final byte[] value) {
     Jedis j = getShard(key);
     return j.linsert(key, where, pivot, value);
   }
@@ -694,81 +694,81 @@ public ShardedJedisPipeline pipelined() {
     return pipeline;
   }
 
-  public Long objectRefcount(byte[] key) {
+  public Long objectRefcount(final byte[] key) {
     Jedis j = getShard(key);
     return j.objectRefcount(key);
   }
 
-  public byte[] objectEncoding(byte[] key) {
+  public byte[] objectEncoding(final byte[] key) {
     Jedis j = getShard(key);
     return j.objectEncoding(key);
   }
 
-  public Long objectIdletime(byte[] key) {
+  public Long objectIdletime(final byte[] key) {
     Jedis j = getShard(key);
     return j.objectIdletime(key);
   }
 
   @Override
-  public Boolean setbit(byte[] key, long offset, boolean value) {
+  public Boolean setbit(final byte[] key, final long offset, boolean value) {
     Jedis j = getShard(key);
     return j.setbit(key, offset, value);
   }
 
   @Override
-  public Boolean setbit(byte[] key, long offset, byte[] value) {
+  public Boolean setbit(final byte[] key, final long offset, final byte[] value) {
     Jedis j = getShard(key);
     return j.setbit(key, offset, value);
   }
 
   @Override
-  public Boolean getbit(byte[] key, long offset) {
+  public Boolean getbit(final byte[] key, final long offset) {
     Jedis j = getShard(key);
     return j.getbit(key, offset);
   }
 
   @Override
-  public Long setrange(byte[] key, long offset, byte[] value) {
+  public Long setrange(final byte[] key, final long offset, final byte[] value) {
     Jedis j = getShard(key);
     return j.setrange(key, offset, value);
   }
 
   @Override
-  public byte[] getrange(byte[] key, long startOffset, long endOffset) {
+  public byte[] getrange(final byte[] key, final long startOffset, final long endOffset) {
     Jedis j = getShard(key);
     return j.getrange(key, startOffset, endOffset);
   }
 
   @Override
-  public Long move(byte[] key, int dbIndex) {
+  public Long move(final byte[] key, final int dbIndex) {
     Jedis j = getShard(key);
     return j.move(key, dbIndex);
   }
 
   @Override
-  public byte[] echo(byte[] arg) {
+  public byte[] echo(final byte[] arg) {
     Jedis j = getShard(arg);
     return j.echo(arg);
   }
 
-  public List<byte[]> brpop(byte[] arg) {
+  public List<byte[]> brpop(final byte[] arg) {
     Jedis j = getShard(arg);
     return j.brpop(arg);
   }
 
-  public List<byte[]> blpop(byte[] arg) {
+  public List<byte[]> blpop(final byte[] arg) {
     Jedis j = getShard(arg);
     return j.blpop(arg);
   }
 
   @Override
-  public Long bitcount(byte[] key) {
+  public Long bitcount(final byte[] key) {
     Jedis j = getShard(key);
     return j.bitcount(key);
   }
 
   @Override
-  public Long bitcount(byte[] key, long start, long end) {
+  public Long bitcount(final byte[] key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.bitcount(key, start, end);
   }
@@ -786,113 +786,113 @@ public long pfcount(final byte[] key) {
   }
 
   @Override
-  public Long geoadd(byte[] key, double longitude, double latitude, byte[] member) {
+  public Long geoadd(final byte[] key, final double longitude, final double latitude, final byte[] member) {
     Jedis j = getShard(key);
     return j.geoadd(key, longitude, latitude, member);
   }
 
   @Override
-  public Long geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap) {
+  public Long geoadd(final byte[] key, final Map<byte[], GeoCoordinate> memberCoordinateMap) {
     Jedis j = getShard(key);
     return j.geoadd(key, memberCoordinateMap);
   }
 
   @Override
-  public Double geodist(byte[] key, byte[] member1, byte[] member2) {
+  public Double geodist(final byte[] key, final byte[] member1, final byte[] member2) {
     Jedis j = getShard(key);
     return j.geodist(key, member1, member2);
   }
 
   @Override
-  public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
+  public Double geodist(final byte[] key, final byte[] member1, final byte[] member2, final GeoUnit unit) {
     Jedis j = getShard(key);
     return j.geodist(key, member1, member2, unit);
   }
 
   @Override
-  public List<byte[]> geohash(byte[] key, byte[]... members) {
+  public List<byte[]> geohash(final byte[] key, final byte[]... members) {
     Jedis j = getShard(key);
     return j.geohash(key, members);
   }
 
   @Override
-  public List<GeoCoordinate> geopos(byte[] key, byte[]... members) {
+  public List<GeoCoordinate> geopos(final byte[] key, final byte[]... members) {
     Jedis j = getShard(key);
     return j.geopos(key, members);
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude,
-      double radius, GeoUnit unit) {
+  public List<GeoRadiusResponse> georadius(final byte[] key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit) {
     Jedis j = getShard(key);
     return j.georadius(key, longitude, latitude, radius, unit);
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude,
-      double radius, GeoUnit unit, GeoRadiusParam param) {
+  public List<GeoRadiusResponse> georadius(final byte[] key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
     Jedis j = getShard(key);
     return j.georadius(key, longitude, latitude, radius, unit, param);
   }
 
   @Override
-  public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius,
-      GeoUnit unit) {
+  public List<GeoRadiusResponse> georadiusByMember(final byte[] key, final byte[] member, final double radius,
+      final GeoUnit unit) {
     Jedis j = getShard(key);
     return j.georadiusByMember(key, member, radius, unit);
   }
 
   @Override
-  public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius,
-      GeoUnit unit, GeoRadiusParam param) {
+  public List<GeoRadiusResponse> georadiusByMember(final byte[] key, final byte[] member, final double radius,
+      final GeoUnit unit, final GeoRadiusParam param) {
     Jedis j = getShard(key);
     return j.georadiusByMember(key, member, radius, unit, param);
   }
 
   @Override
-  public ScanResult<Map.Entry<byte[], byte[]>> hscan(byte[] key, byte[] cursor) {
+  public ScanResult<Map.Entry<byte[], byte[]>> hscan(final byte[] key, final byte[] cursor) {
     Jedis j = getShard(key);
     return j.hscan(key, cursor);
   }
 
   @Override
-  public ScanResult<Map.Entry<byte[], byte[]>> hscan(byte[] key, byte[] cursor, ScanParams params) {
+  public ScanResult<Map.Entry<byte[], byte[]>> hscan(final byte[] key, final byte[] cursor, final ScanParams params) {
     Jedis j = getShard(key);
     return j.hscan(key, cursor, params);
   }
 
   @Override
-  public ScanResult<byte[]> sscan(byte[] key, byte[] cursor) {
+  public ScanResult<byte[]> sscan(final byte[] key, final byte[] cursor) {
     Jedis j = getShard(key);
     return j.sscan(key, cursor);
   }
 
   @Override
-  public ScanResult<byte[]> sscan(byte[] key, byte[] cursor, ScanParams params) {
+  public ScanResult<byte[]> sscan(final byte[] key, final byte[] cursor, final ScanParams params) {
     Jedis j = getShard(key);
     return j.sscan(key, cursor, params);
   }
 
   @Override
-  public ScanResult<Tuple> zscan(byte[] key, byte[] cursor) {
+  public ScanResult<Tuple> zscan(final byte[] key, final byte[] cursor) {
     Jedis j = getShard(key);
     return j.zscan(key, cursor);
   }
 
   @Override
-  public ScanResult<Tuple> zscan(byte[] key, byte[] cursor, ScanParams params) {
+  public ScanResult<Tuple> zscan(final byte[] key, final byte[] cursor, final ScanParams params) {
     Jedis j = getShard(key);
     return j.zscan(key, cursor, params);
   }
 
   @Override
-  public List<Long> bitfield(byte[] key, byte[]... arguments) {
+  public List<Long> bitfield(final byte[] key, final byte[]... arguments) {
     Jedis j = getShard(key);
     return j.bitfield(key, arguments);
  }
 
   @Override
-  public Long hstrlen(byte[] key, byte[] field) {
+  public Long hstrlen(final byte[] key, final byte[] field) {
     Jedis j = getShard(key);
     return j.hstrlen(key, field);
   }
diff --git a/src/main/java/redis/clients/jedis/Client.java b/src/main/java/redis/clients/jedis/Client.java
index 9b4002267e..022836060e 100644
--- a/src/main/java/redis/clients/jedis/Client.java
+++ b/src/main/java/redis/clients/jedis/Client.java
@@ -308,7 +308,7 @@ public void lset(final String key, final long index, final String value) {
   }
 
   @Override
-  public void lrem(final String key, long count, final String value) {
+  public void lrem(final String key, final long count, final String value) {
     lrem(SafeEncoder.encode(key), count, SafeEncoder.encode(value));
   }
 
@@ -438,7 +438,7 @@ public void zadd(final String key, final double score, final String member,
   }
 
   @Override
-  public void zadd(String key, Map<String, Double> scoreMembers) {
+  public void zadd(final String key, final Map<String, Double> scoreMembers) {
     HashMap<byte[], Double> binaryScoreMembers = convertScoreMembersToBinary(scoreMembers);
     zadd(SafeEncoder.encode(key), binaryScoreMembers);
   }
@@ -465,7 +465,7 @@ public void zincrby(final String key, final double score, final String member) {
   }
 
   @Override
-  public void zincrby(String key, double score, String member, ZIncrByParams params) {
+  public void zincrby(final String key, final double score, final String member, final ZIncrByParams params) {
     zincrby(SafeEncoder.encode(key), score, SafeEncoder.encode(member), params);
   }
 
@@ -593,7 +593,7 @@ public void zrangeByScore(final String key, final String min, final String max)
 
   @Override
   public void zrangeByScore(final String key, final double min, final double max, final int offset,
-      int count) {
+      final int count) {
     zrangeByScore(SafeEncoder.encode(key), toByteArray(min), toByteArray(max), offset, count);
   }
 
@@ -615,7 +615,7 @@ public void zrevrangeByScore(final String key, final double max, final double mi
   }
 
   public void zrangeByScore(final String key, final String min, final String max, final int offset,
-      int count) {
+      final int count) {
     zrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(min), SafeEncoder.encode(max),
       offset, count);
   }
@@ -640,12 +640,12 @@ public void zrevrangeByScore(final String key, final String max, final String mi
 
   @Override
   public void zrevrangeByScore(final String key, final double max, final double min,
-      final int offset, int count) {
+      final int offset, final int count) {
     zrevrangeByScore(SafeEncoder.encode(key), toByteArray(max), toByteArray(min), offset, count);
   }
 
   public void zrevrangeByScore(final String key, final String max, final String min,
-      final int offset, int count) {
+      final int offset, final int count) {
     zrevrangeByScore(SafeEncoder.encode(key), SafeEncoder.encode(max), SafeEncoder.encode(min),
       offset, count);
   }
@@ -740,11 +740,11 @@ public void zrangeByLex(final String key, final String min, final String max, fi
       count);
   }
 
-  public void zrevrangeByLex(String key, String max, String min) {
+  public void zrevrangeByLex(final String key, final String max, final String min) {
     zrevrangeByLex(SafeEncoder.encode(key), SafeEncoder.encode(max), SafeEncoder.encode(min));
   }
 
-  public void zrevrangeByLex(String key, String max, String min, int offset, int count) {
+  public void zrevrangeByLex(final String key, final String max, final String min, final int offset, final int count) {
     zrevrangeByLex(SafeEncoder.encode(key), SafeEncoder.encode(max), SafeEncoder.encode(min),
       offset, count);
   }
@@ -785,7 +785,7 @@ public void linsert(final String key, final LIST_POSITION where, final String pi
   }
 
   @Override
-  public void brpoplpush(String source, String destination, int timeout) {
+  public void brpoplpush(final String source, final String destination, final int timeout) {
     brpoplpush(SafeEncoder.encode(source), SafeEncoder.encode(destination), timeout);
   }
 
@@ -800,7 +800,7 @@ public void setbit(final String key, final long offset, final String value) {
   }
 
   @Override
-  public void getbit(String key, long offset) {
+  public void getbit(final String key, final long offset) {
     getbit(SafeEncoder.encode(key), offset);
   }
 
@@ -809,12 +809,12 @@ public void bitpos(final String key, final boolean value, final BitPosParams par
   }
 
   @Override
-  public void setrange(String key, long offset, String value) {
+  public void setrange(final String key, final long offset, final String value) {
     setrange(SafeEncoder.encode(key), offset, SafeEncoder.encode(value));
   }
 
   @Override
-  public void getrange(String key, long startOffset, long endOffset) {
+  public void getrange(final String key, final long startOffset, final long endOffset) {
     getrange(SafeEncoder.encode(key), startOffset, endOffset);
   }
 
@@ -854,7 +854,7 @@ public void subscribe(final String... channels) {
     subscribe(cs);
   }
 
-  public void pubsubChannels(String pattern) {
+  public void pubsubChannels(final String pattern) {
     pubsub(Protocol.PUBSUB_CHANNELS, pattern);
   }
 
@@ -862,29 +862,29 @@ public void pubsubNumPat() {
     pubsub(Protocol.PUBSUB_NUM_PAT);
   }
 
-  public void pubsubNumSub(String... channels) {
+  public void pubsubNumSub(final String... channels) {
     pubsub(Protocol.PUBSUB_NUMSUB, channels);
   }
 
   @Override
-  public void configSet(String parameter, String value) {
+  public void configSet(final String parameter, final String value) {
     configSet(SafeEncoder.encode(parameter), SafeEncoder.encode(value));
   }
 
   @Override
-  public void configGet(String pattern) {
+  public void configGet(final String pattern) {
     configGet(SafeEncoder.encode(pattern));
   }
 
-  public void eval(String script, int keyCount, String... params) {
+  public void eval(final String script, final int keyCount, final String... params) {
     eval(SafeEncoder.encode(script), toByteArray(keyCount), getByteParams(params));
   }
 
-  public void evalsha(String sha1, int keyCount, String... params) {
+  public void evalsha(final String sha1, final int keyCount, final String... params) {
     evalsha(SafeEncoder.encode(sha1), toByteArray(keyCount), getByteParams(params));
   }
 
-  public void scriptExists(String... sha1) {
+  public void scriptExists(final String... sha1) {
     final byte[][] bsha1 = new byte[sha1.length][];
     for (int i = 0; i < bsha1.length; i++) {
       bsha1[i] = SafeEncoder.encode(sha1[i]);
@@ -892,22 +892,22 @@ public void scriptExists(String... sha1) {
     scriptExists(bsha1);
   }
 
-  public void scriptLoad(String script) {
+  public void scriptLoad(final String script) {
     scriptLoad(SafeEncoder.encode(script));
   }
 
   @Override
-  public void objectRefcount(String key) {
+  public void objectRefcount(final String key) {
     objectRefcount(SafeEncoder.encode(key));
   }
 
   @Override
-  public void objectIdletime(String key) {
+  public void objectIdletime(final String key) {
     objectIdletime(SafeEncoder.encode(key));
   }
 
   @Override
-  public void objectEncoding(String key) {
+  public void objectEncoding(final String key) {
     objectEncoding(SafeEncoder.encode(key));
   }
 
@@ -917,12 +917,12 @@ public void bitcount(final String key) {
   }
 
   @Override
-  public void bitcount(final String key, long start, long end) {
+  public void bitcount(final String key, final long start, final long end) {
     bitcount(SafeEncoder.encode(key), start, end);
   }
 
   @Override
-  public void bitop(BitOP op, final String destKey, String... srcKeys) {
+  public void bitop(final BitOP op, final String destKey, final String... srcKeys) {
     bitop(op, SafeEncoder.encode(destKey), getByteParams(srcKeys));
   }
 
@@ -982,7 +982,7 @@ public void migrate(final String host, final int port, final String key, final i
   }
 
   @Override
-  public void hincrByFloat(final String key, final String field, double increment) {
+  public void hincrByFloat(final String key, final String field, final double increment) {
     hincrByFloat(SafeEncoder.encode(key), SafeEncoder.encode(field), increment);
   }
 
@@ -1047,7 +1047,7 @@ public void clusterMeet(final String ip, final int port) {
     cluster(Protocol.CLUSTER_MEET, ip, String.valueOf(port));
   }
 
-  public void clusterReset(Reset resetType) {
+  public void clusterReset(final Reset resetType) {
     cluster(Protocol.CLUSTER_RESET, resetType.toString());
   }
 
@@ -1082,7 +1082,7 @@ public void clusterSetSlotImporting(final int slot, final String nodeId) {
       nodeId);
   }
 
-  public void pfadd(String key, final String... elements) {
+  public void pfadd(final String key, final String... elements) {
     pfadd(SafeEncoder.encode(key), SafeEncoder.encodeMany(elements));
   }
 
@@ -1138,45 +1138,45 @@ public void clusterSlots() {
     cluster(Protocol.CLUSTER_SLOTS);
   }
 
-  public void geoadd(String key, double longitude, double latitude, String member) {
+  public void geoadd(final String key, final double longitude, final double latitude, final String member) {
     geoadd(SafeEncoder.encode(key), longitude, latitude, SafeEncoder.encode(member));
   }
 
-  public void geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap) {
+  public void geoadd(final String key, final Map<String, GeoCoordinate> memberCoordinateMap) {
     geoadd(SafeEncoder.encode(key), convertMemberCoordinateMapToBinary(memberCoordinateMap));
   }
 
-  public void geodist(String key, String member1, String member2) {
+  public void geodist(final String key, final String member1, final String member2) {
     geodist(SafeEncoder.encode(key), SafeEncoder.encode(member1), SafeEncoder.encode(member2));
   }
 
-  public void geodist(String key, String member1, String member2, GeoUnit unit) {
+  public void geodist(final String key, final String member1, final String member2, final GeoUnit unit) {
     geodist(SafeEncoder.encode(key), SafeEncoder.encode(member1), SafeEncoder.encode(member2), unit);
   }
 
-  public void geohash(String key, String... members) {
+  public void geohash(final String key, final String... members) {
     geohash(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
   }
 
-  public void geopos(String key, String[] members) {
+  public void geopos(final String key, final String[] members) {
     geopos(SafeEncoder.encode(key), SafeEncoder.encodeMany(members));
   }
 
-  public void georadius(String key, double longitude, double latitude, double radius, GeoUnit unit) {
+  public void georadius(final String key, final double longitude, final double latitude, final double radius, final GeoUnit unit) {
     georadius(SafeEncoder.encode(key), longitude, latitude, radius, unit);
   }
 
-  public void georadius(String key, double longitude, double latitude, double radius, GeoUnit unit,
-      GeoRadiusParam param) {
+  public void georadius(final String key, final double longitude, final double latitude, final double radius, final GeoUnit unit,
+      final GeoRadiusParam param) {
     georadius(SafeEncoder.encode(key), longitude, latitude, radius, unit, param);
   }
 
-  public void georadiusByMember(String key, String member, double radius, GeoUnit unit) {
+  public void georadiusByMember(final String key, final String member, final double radius, final GeoUnit unit) {
     georadiusByMember(SafeEncoder.encode(key), SafeEncoder.encode(member), radius, unit);
   }
 
-  public void georadiusByMember(String key, String member, double radius, GeoUnit unit,
-      GeoRadiusParam param) {
+  public void georadiusByMember(final String key, final String member, final double radius, final GeoUnit unit,
+      final GeoRadiusParam param) {
     georadiusByMember(SafeEncoder.encode(key), SafeEncoder.encode(member), radius, unit, param);
   }
 
@@ -1188,19 +1188,19 @@ private byte[][] getByteParams(String... params) {
     return p;
   }
 
-  public void moduleLoad(String path) {
+  public void moduleLoad(final String path) {
     moduleLoad(SafeEncoder.encode(path));
   }
   public void moduleLoad() {
     moduleList();
   }
 
-  public void moduleUnload(String name) {
+  public void moduleUnload(final String name) {
     moduleUnload(SafeEncoder.encode(name));
   }
-  private HashMap<byte[], Double> convertScoreMembersToBinary(Map<String, Double> scoreMembers) {
-    HashMap<byte[], Double> binaryScoreMembers = new HashMap<byte[], Double>();
 
+  private HashMap<byte[], Double> convertScoreMembersToBinary(final Map<String, Double> scoreMembers) {
+    HashMap<byte[], Double> binaryScoreMembers = new HashMap<byte[], Double>();
     for (Entry<String, Double> entry : scoreMembers.entrySet()) {
       binaryScoreMembers.put(SafeEncoder.encode(entry.getKey()), entry.getValue());
     }
@@ -1208,9 +1208,8 @@ private HashMap<byte[], Double> convertScoreMembersToBinary(Map<String, Double>
   }
 
   private HashMap<byte[], GeoCoordinate> convertMemberCoordinateMapToBinary(
-      Map<String, GeoCoordinate> memberCoordinateMap) {
+      final Map<String, GeoCoordinate> memberCoordinateMap) {
     HashMap<byte[], GeoCoordinate> binaryMemberCoordinateMap = new HashMap<byte[], GeoCoordinate>();
-
     for (Entry<String, GeoCoordinate> entry : memberCoordinateMap.entrySet()) {
       binaryMemberCoordinateMap.put(SafeEncoder.encode(entry.getKey()), entry.getValue());
     }
diff --git a/src/main/java/redis/clients/jedis/Jedis.java b/src/main/java/redis/clients/jedis/Jedis.java
index 133890a58d..610a952db3 100644
--- a/src/main/java/redis/clients/jedis/Jedis.java
+++ b/src/main/java/redis/clients/jedis/Jedis.java
@@ -142,7 +142,7 @@ public String ping(final String message) {
    * @return Status code reply
    */
   @Override
-  public String set(final String key, String value) {
+  public String set(final String key, final String value) {
     checkIsInMultiOrPipeline();
     client.set(key, value);
     return client.getStatusCodeReply();
@@ -222,7 +222,7 @@ public Long del(final String... keys) {
   }
 
   @Override
-  public Long del(String key) {
+  public Long del(final String key) {
     client.del(key);
     return client.getIntegerReply();
   }
@@ -410,7 +410,7 @@ public Long touch(final String... keys) {
   }
 
   @Override
-  public Long touch(String key) {
+  public Long touch(final String key) {
     checkIsInMultiOrPipeline();
     client.touch(key);
     return client.getIntegerReply();
@@ -1512,7 +1512,7 @@ public Long zadd(final String key, final Map<String, Double> scoreMembers) {
   }
 
   @Override
-  public Long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
+  public Long zadd(final String key, final Map<String, Double> scoreMembers, final ZAddParams params) {
     checkIsInMultiOrPipeline();
     client.zadd(key, scoreMembers, params);
     return client.getIntegerReply();
@@ -1574,7 +1574,7 @@ public Double zincrby(final String key, final double score, final String member)
   }
 
   @Override
-  public Double zincrby(String key, double score, String member, ZIncrByParams params) {
+  public Double zincrby(final String key, final double score, final String member, final ZIncrByParams params) {
     checkIsInMultiOrPipeline();
     client.zincrby(key, score, member, params);
     String newscore = client.getBulkReply();
@@ -1875,7 +1875,7 @@ private String[] getArgsAddTimeout(int timeout, String[] keys) {
   }
 
   @Override
-  public List<String> blpop(String... args) {
+  public List<String> blpop(final String... args) {
     checkIsInMultiOrPipeline();
     client.blpop(args);
     client.setTimeoutInfinite();
@@ -1887,7 +1887,7 @@ public List<String> blpop(String... args) {
   }
 
   @Override
-  public List<String> brpop(String... args) {
+  public List<String> brpop(final String... args) {
     checkIsInMultiOrPipeline();
     client.brpop(args);
     client.setTimeoutInfinite();
@@ -2599,7 +2599,7 @@ public Set<String> zrangeByLex(final String key, final String min, final String
   }
 
   @Override
-  public Set<String> zrevrangeByLex(String key, String max, String min) {
+  public Set<String> zrevrangeByLex(final String key, final String max, final String min) {
     checkIsInMultiOrPipeline();
     client.zrevrangeByLex(key, max, min);
     final List<String> members = client.getMultiBulkReply();
@@ -2610,7 +2610,7 @@ public Set<String> zrevrangeByLex(String key, String max, String min) {
   }
 
   @Override
-  public Set<String> zrevrangeByLex(String key, String max, String min, int offset, int count) {
+  public Set<String> zrevrangeByLex(final String key, final String max, final String min, final int offset, final int count) {
     checkIsInMultiOrPipeline();
     client.zrevrangeByLex(key, max, min, offset, count);
     final List<String> members = client.getMultiBulkReply();
@@ -2680,7 +2680,7 @@ public Long linsert(final String key, final LIST_POSITION where, final String pi
    * @return the element
    */
   @Override
-  public String brpoplpush(String source, String destination, int timeout) {
+  public String brpoplpush(final String source, final String destination, final int timeout) {
     client.brpoplpush(source, destination, timeout);
     client.setTimeoutInfinite();
     try {
@@ -2698,13 +2698,13 @@ public String brpoplpush(String source, String destination, int timeout) {
    * @return
    */
   @Override
-  public Boolean setbit(String key, long offset, boolean value) {
+  public Boolean setbit(final String key, final long offset, final boolean value) {
     client.setbit(key, offset, value);
     return client.getIntegerReply() == 1;
   }
 
   @Override
-  public Boolean setbit(String key, long offset, String value) {
+  public Boolean setbit(final String key, final long offset, final String value) {
     client.setbit(key, offset, value);
     return client.getIntegerReply() == 1;
   }
@@ -2716,19 +2716,19 @@ public Boolean setbit(String key, long offset, String value) {
    * @return
    */
   @Override
-  public Boolean getbit(String key, long offset) {
+  public Boolean getbit(final String key, final long offset) {
     client.getbit(key, offset);
     return client.getIntegerReply() == 1;
   }
 
   @Override
-  public Long setrange(String key, long offset, String value) {
+  public Long setrange(final String key, final long offset, final String value) {
     client.setrange(key, offset, value);
     return client.getIntegerReply();
   }
 
   @Override
-  public String getrange(String key, long startOffset, long endOffset) {
+  public String getrange(final String key, final long startOffset, final long endOffset) {
     client.getrange(key, startOffset, endOffset);
     return client.getBulkReply();
   }
@@ -2820,7 +2820,7 @@ public String configSet(final String parameter, final String value) {
   }
 
   @Override
-  public Object eval(String script, int keyCount, String... params) {
+  public Object eval(final String script, final int keyCount, final String... params) {
     client.setTimeoutInfinite();
     try {
       client.eval(script, keyCount, params);
@@ -2875,17 +2875,17 @@ protected static String[] getParams(List<String> keys, List<String> args) {
   }
 
   @Override
-  public Object eval(String script, List<String> keys, List<String> args) {
+  public Object eval(final String script, final List<String> keys, final List<String> args) {
     return eval(script, keys.size(), getParams(keys, args));
   }
 
   @Override
-  public Object eval(String script) {
+  public Object eval(final String script) {
     return eval(script, 0);
   }
 
   @Override
-  public Object evalsha(String sha1) {
+  public Object evalsha(final String sha1) {
     return evalsha(sha1, 0);
   }
 
@@ -2910,26 +2910,26 @@ private Object evalResult(Object result) {
   }
 
   @Override
-  public Object evalsha(String sha1, List<String> keys, List<String> args) {
+  public Object evalsha(final String sha1, final List<String> keys, final List<String> args) {
     return evalsha(sha1, keys.size(), getParams(keys, args));
   }
 
   @Override
-  public Object evalsha(String sha1, int keyCount, String... params) {
+  public Object evalsha(final String sha1, final int keyCount, final String... params) {
     checkIsInMultiOrPipeline();
     client.evalsha(sha1, keyCount, params);
     return getEvalResult();
   }
 
   @Override
-  public Boolean scriptExists(String sha1) {
+  public Boolean scriptExists(final String sha1) {
     String[] a = new String[1];
     a[0] = sha1;
     return scriptExists(a).get(0);
   }
 
   @Override
-  public List<Boolean> scriptExists(String... sha1) {
+  public List<Boolean> scriptExists(final String... sha1) {
     client.scriptExists(sha1);
     List<Long> result = client.getIntegerMultiBulkReply();
     List<Boolean> exists = new ArrayList<Boolean>();
@@ -2941,7 +2941,7 @@ public List<Boolean> scriptExists(String... sha1) {
   }
 
   @Override
-  public String scriptLoad(String script) {
+  public String scriptLoad(final String script) {
     client.scriptLoad(script);
     return client.getBulkReply();
   }
@@ -2953,25 +2953,25 @@ public List<Slowlog> slowlogGet() {
   }
 
   @Override
-  public List<Slowlog> slowlogGet(long entries) {
+  public List<Slowlog> slowlogGet(final long entries) {
     client.slowlogGet(entries);
     return Slowlog.from(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public Long objectRefcount(String string) {
+  public Long objectRefcount(final String string) {
     client.objectRefcount(string);
     return client.getIntegerReply();
   }
 
   @Override
-  public String objectEncoding(String string) {
+  public String objectEncoding(final String string) {
     client.objectEncoding(string);
     return client.getBulkReply();
   }
 
   @Override
-  public Long objectIdletime(String string) {
+  public Long objectIdletime(final String string) {
     client.objectIdletime(string);
     return client.getIntegerReply();
   }
@@ -2983,13 +2983,13 @@ public Long bitcount(final String key) {
   }
 
   @Override
-  public Long bitcount(final String key, long start, long end) {
+  public Long bitcount(final String key, final long start, final long end) {
     client.bitcount(key, start, end);
     return client.getIntegerReply();
   }
 
   @Override
-  public Long bitop(BitOP op, final String destKey, String... srcKeys) {
+  public Long bitop(final BitOP op, final String destKey, final String... srcKeys) {
     client.bitop(op, destKey, srcKeys);
     return client.getIntegerReply();
   }
@@ -3048,7 +3048,7 @@ public List<Map<String, String>> sentinelMasters() {
    * @return two elements list of strings : host and port.
    */
   @Override
-  public List<String> sentinelGetMasterAddrByName(String masterName) {
+  public List<String> sentinelGetMasterAddrByName(final String masterName) {
     client.sentinel(Protocol.SENTINEL_GET_MASTER_ADDR_BY_NAME, masterName);
     final List<Object> reply = client.getObjectMultiBulkReply();
     return BuilderFactory.STRING_LIST.build(reply);
@@ -3063,7 +3063,7 @@ public List<String> sentinelGetMasterAddrByName(String masterName) {
    * @return
    */
   @Override
-  public Long sentinelReset(String pattern) {
+  public Long sentinelReset(final String pattern) {
     client.sentinel(Protocol.SENTINEL_RESET, pattern);
     return client.getIntegerReply();
   }
@@ -3105,7 +3105,7 @@ public Long sentinelReset(String pattern) {
    */
   @Override
   @SuppressWarnings("rawtypes")
-  public List<Map<String, String>> sentinelSlaves(String masterName) {
+  public List<Map<String, String>> sentinelSlaves(final String masterName) {
     client.sentinel(Protocol.SENTINEL_SLAVES, masterName);
     final List<Object> reply = client.getObjectMultiBulkReply();
 
@@ -3117,26 +3117,26 @@ public List<Map<String, String>> sentinelSlaves(String masterName) {
   }
 
   @Override
-  public String sentinelFailover(String masterName) {
+  public String sentinelFailover(final String masterName) {
     client.sentinel(Protocol.SENTINEL_FAILOVER, masterName);
     return client.getStatusCodeReply();
   }
 
   @Override
-  public String sentinelMonitor(String masterName, String ip, int port, int quorum) {
+  public String sentinelMonitor(final String masterName, final String ip, final int port, final int quorum) {
     client.sentinel(Protocol.SENTINEL_MONITOR, masterName, ip, String.valueOf(port),
       String.valueOf(quorum));
     return client.getStatusCodeReply();
   }
 
   @Override
-  public String sentinelRemove(String masterName) {
+  public String sentinelRemove(final String masterName) {
     client.sentinel(Protocol.SENTINEL_REMOVE, masterName);
     return client.getStatusCodeReply();
   }
 
   @Override
-  public String sentinelSet(String masterName, Map<String, String> parameterMap) {
+  public String sentinelSet(final String masterName, final Map<String, String> parameterMap) {
     int index = 0;
     int paramsLength = parameterMap.size() * 2 + 2;
     String[] params = new String[paramsLength];
@@ -3453,7 +3453,7 @@ public String asking() {
     return client.getStatusCodeReply();
   }
 
-  public List<String> pubsubChannels(String pattern) {
+  public List<String> pubsubChannels(final String pattern) {
     checkIsInMultiOrPipeline();
     client.pubsubChannels(pattern);
     return client.getMultiBulkReply();
@@ -3503,7 +3503,7 @@ public long pfcount(final String key) {
   }
 
   @Override
-  public long pfcount(String... keys) {
+  public long pfcount(final String... keys) {
     checkIsInMultiOrPipeline();
     client.pfcount(keys);
     return client.getIntegerReply();
@@ -3517,31 +3517,31 @@ public String pfmerge(final String destkey, final String... sourcekeys) {
   }
 
   @Override
-  public List<String> blpop(int timeout, String key) {
+  public List<String> blpop(final int timeout, final String key) {
     return blpop(key, String.valueOf(timeout));
   }
 
   @Override
-  public List<String> brpop(int timeout, String key) {
+  public List<String> brpop(final int timeout, final String key) {
     return brpop(key, String.valueOf(timeout));
   }
 
   @Override
-  public Long geoadd(String key, double longitude, double latitude, String member) {
+  public Long geoadd(final String key, final double longitude, final double latitude, final String member) {
     checkIsInMultiOrPipeline();
     client.geoadd(key, longitude, latitude, member);
     return client.getIntegerReply();
   }
 
   @Override
-  public Long geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap) {
+  public Long geoadd(final String key, final Map<String, GeoCoordinate> memberCoordinateMap) {
     checkIsInMultiOrPipeline();
     client.geoadd(key, memberCoordinateMap);
     return client.getIntegerReply();
   }
 
   @Override
-  public Double geodist(String key, String member1, String member2) {
+  public Double geodist(final String key, final String member1, final String member2) {
     checkIsInMultiOrPipeline();
     client.geodist(key, member1, member2);
     String dval = client.getBulkReply();
@@ -3549,7 +3549,7 @@ public Double geodist(String key, String member1, String member2) {
   }
 
   @Override
-  public Double geodist(String key, String member1, String member2, GeoUnit unit) {
+  public Double geodist(final String key, final String member1, final String member2, final GeoUnit unit) {
     checkIsInMultiOrPipeline();
     client.geodist(key, member1, member2, unit);
     String dval = client.getBulkReply();
@@ -3557,59 +3557,59 @@ public Double geodist(String key, String member1, String member2, GeoUnit unit)
   }
 
   @Override
-  public List<String> geohash(String key, String... members) {
+  public List<String> geohash(final String key, String... members) {
     checkIsInMultiOrPipeline();
     client.geohash(key, members);
     return client.getMultiBulkReply();
   }
 
   @Override
-  public List<GeoCoordinate> geopos(String key, String... members) {
+  public List<GeoCoordinate> geopos(final String key, String... members) {
     checkIsInMultiOrPipeline();
     client.geopos(key, members);
     return BuilderFactory.GEO_COORDINATE_LIST.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude,
-      double radius, GeoUnit unit) {
+  public List<GeoRadiusResponse> georadius(final String key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit) {
     checkIsInMultiOrPipeline();
     client.georadius(key, longitude, latitude, radius, unit);
     return BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude,
-      double radius, GeoUnit unit, GeoRadiusParam param) {
+  public List<GeoRadiusResponse> georadius(final String key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
     checkIsInMultiOrPipeline();
     client.georadius(key, longitude, latitude, radius, unit, param);
     return BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius,
-      GeoUnit unit) {
+  public List<GeoRadiusResponse> georadiusByMember(final String key, final String member, final double radius,
+      final GeoUnit unit) {
     checkIsInMultiOrPipeline();
     client.georadiusByMember(key, member, radius, unit);
     return BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius,
-      GeoUnit unit, GeoRadiusParam param) {
+  public List<GeoRadiusResponse> georadiusByMember(final String key, final String member, final double radius,
+      final GeoUnit unit, final GeoRadiusParam param) {
     checkIsInMultiOrPipeline();
     client.georadiusByMember(key, member, radius, unit, param);
     return BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT.build(client.getObjectMultiBulkReply());
   }
 
   @Override
-  public String moduleLoad(String path) {
+  public String moduleLoad(final String path) {
     client.moduleLoad(path);
     return client.getStatusCodeReply();
   }
 
   @Override
-  public String moduleUnload(String name) {
+  public String moduleUnload(final String name) {
     client.moduleUnload(name);
     return client.getStatusCodeReply();
   }
@@ -3621,14 +3621,14 @@ public List<Module> moduleList() {
   }
 
   @Override
-  public List<Long> bitfield(String key, String...arguments) {
+  public List<Long> bitfield(final String key, final String...arguments) {
     checkIsInMultiOrPipeline();
     client.bitfield(key, arguments);
     return client.getIntegerMultiBulkReply();
   }
 
   @Override
-  public Long hstrlen(String key, String field) {
+  public Long hstrlen(final String key, final String field) {
     checkIsInMultiOrPipeline();
     client.hstrlen(key, field);
     return client.getIntegerReply();
diff --git a/src/main/java/redis/clients/jedis/PipelineBase.java b/src/main/java/redis/clients/jedis/PipelineBase.java
index 9ee82874b3..d9bd7ca492 100644
--- a/src/main/java/redis/clients/jedis/PipelineBase.java
+++ b/src/main/java/redis/clients/jedis/PipelineBase.java
@@ -21,19 +21,19 @@ public abstract class PipelineBase extends Queable implements BinaryRedisPipelin
   protected abstract Client getClient(byte[] key);
 
   @Override
-  public Response<Long> append(String key, String value) {
+  public Response<Long> append(final String key, final String value) {
     getClient(key).append(key, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> append(byte[] key, byte[] value) {
+  public Response<Long> append(final byte[] key, final byte[] value) {
     getClient(key).append(key, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<List<String>> blpop(String key) {
+  public Response<List<String>> blpop(final String key) {
     String[] temp = new String[1];
     temp[0] = key;
     getClient(key).blpop(temp);
@@ -41,7 +41,7 @@ public Response<List<String>> blpop(String key) {
   }
 
   @Override
-  public Response<List<String>> brpop(String key) {
+  public Response<List<String>> brpop(final String key) {
     String[] temp = new String[1];
     temp[0] = key;
     getClient(key).brpop(temp);
@@ -49,7 +49,7 @@ public Response<List<String>> brpop(String key) {
   }
 
   @Override
-  public Response<List<byte[]>> blpop(byte[] key) {
+  public Response<List<byte[]>> blpop(final byte[] key) {
     byte[][] temp = new byte[1][];
     temp[0] = key;
     getClient(key).blpop(temp);
@@ -57,7 +57,7 @@ public Response<List<byte[]>> blpop(byte[] key) {
   }
 
   @Override
-  public Response<List<byte[]>> brpop(byte[] key) {
+  public Response<List<byte[]>> brpop(final byte[] key) {
     byte[][] temp = new byte[1][];
     temp[0] = key;
     getClient(key).brpop(temp);
@@ -65,121 +65,121 @@ public Response<List<byte[]>> brpop(byte[] key) {
   }
 
   @Override
-  public Response<Long> decr(String key) {
+  public Response<Long> decr(final String key) {
     getClient(key).decr(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> decr(byte[] key) {
+  public Response<Long> decr(final byte[] key) {
     getClient(key).decr(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> decrBy(String key, long integer) {
+  public Response<Long> decrBy(final String key, final long integer) {
     getClient(key).decrBy(key, integer);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> decrBy(byte[] key, long integer) {
+  public Response<Long> decrBy(final byte[] key, final long integer) {
     getClient(key).decrBy(key, integer);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> del(String key) {
+  public Response<Long> del(final String key) {
     getClient(key).del(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> del(byte[] key) {
+  public Response<Long> del(final byte[] key) {
     getClient(key).del(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> unlink(String key) {
+  public Response<Long> unlink(final String key) {
     getClient(key).unlink(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> unlink(byte[] key) {
+  public Response<Long> unlink(final byte[] key) {
     getClient(key).unlink(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> echo(String string) {
+  public Response<String> echo(final String string) {
     getClient(string).echo(string);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<byte[]> echo(byte[] string) {
+  public Response<byte[]> echo(final byte[] string) {
     getClient(string).echo(string);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<Boolean> exists(String key) {
+  public Response<Boolean> exists(final String key) {
     getClient(key).exists(key);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<Boolean> exists(byte[] key) {
+  public Response<Boolean> exists(final byte[] key) {
     getClient(key).exists(key);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<Long> expire(String key, int seconds) {
+  public Response<Long> expire(final String key, final int seconds) {
     getClient(key).expire(key, seconds);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> expire(byte[] key, int seconds) {
+  public Response<Long> expire(final byte[] key, final int seconds) {
     getClient(key).expire(key, seconds);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> expireAt(String key, long unixTime) {
+  public Response<Long> expireAt(final String key, final long unixTime) {
     getClient(key).expireAt(key, unixTime);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> expireAt(byte[] key, long unixTime) {
+  public Response<Long> expireAt(final byte[] key, final long unixTime) {
     getClient(key).expireAt(key, unixTime);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> get(String key) {
+  public Response<String> get(final String key) {
     getClient(key).get(key);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<byte[]> get(byte[] key) {
+  public Response<byte[]> get(final byte[] key) {
     getClient(key).get(key);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<Boolean> getbit(String key, long offset) {
+  public Response<Boolean> getbit(final String key, final long offset) {
     getClient(key).getbit(key, offset);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<Boolean> getbit(byte[] key, long offset) {
+  public Response<Boolean> getbit(final byte[] key, final long offset) {
     getClient(key).getbit(key, offset);
     return getResponse(BuilderFactory.BOOLEAN);
   }
@@ -203,1070 +203,1070 @@ public Response<Long> bitpos(final byte[] key, final boolean value, final BitPos
   }
 
   @Override
-  public Response<String> getrange(String key, long startOffset, long endOffset) {
+  public Response<String> getrange(final String key, final long startOffset, final long endOffset) {
     getClient(key).getrange(key, startOffset, endOffset);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> getSet(String key, String value) {
+  public Response<String> getSet(final String key, final String value) {
     getClient(key).getSet(key, value);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<byte[]> getSet(byte[] key, byte[] value) {
+  public Response<byte[]> getSet(final byte[] key, final byte[] value) {
     getClient(key).getSet(key, value);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<byte[]> getrange(byte[] key, long startOffset, long endOffset) {
+  public Response<byte[]> getrange(final byte[] key, final long startOffset, final long endOffset) {
     getClient(key).getrange(key, startOffset, endOffset);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<Long> hdel(String key, String... field) {
+  public Response<Long> hdel(final String key, final String... field) {
     getClient(key).hdel(key, field);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> hdel(byte[] key, byte[]... field) {
+  public Response<Long> hdel(final byte[] key, final byte[]... field) {
     getClient(key).hdel(key, field);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Boolean> hexists(String key, String field) {
+  public Response<Boolean> hexists(final String key, final String field) {
     getClient(key).hexists(key, field);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<Boolean> hexists(byte[] key, byte[] field) {
+  public Response<Boolean> hexists(final byte[] key, final byte[] field) {
     getClient(key).hexists(key, field);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<String> hget(String key, String field) {
+  public Response<String> hget(final String key, final String field) {
     getClient(key).hget(key, field);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<byte[]> hget(byte[] key, byte[] field) {
+  public Response<byte[]> hget(final byte[] key, final byte[] field) {
     getClient(key).hget(key, field);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<Map<String, String>> hgetAll(String key) {
+  public Response<Map<String, String>> hgetAll(final String key) {
     getClient(key).hgetAll(key);
     return getResponse(BuilderFactory.STRING_MAP);
   }
 
   @Override
-  public Response<Map<byte[], byte[]>> hgetAll(byte[] key) {
+  public Response<Map<byte[], byte[]>> hgetAll(final byte[] key) {
     getClient(key).hgetAll(key);
     return getResponse(BuilderFactory.BYTE_ARRAY_MAP);
   }
 
   @Override
-  public Response<Long> hincrBy(String key, String field, long value) {
+  public Response<Long> hincrBy(final String key, final String field, final long value) {
     getClient(key).hincrBy(key, field, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
+  public Response<Long> hincrBy(final byte[] key, final byte[] field, final long value) {
     getClient(key).hincrBy(key, field, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Set<String>> hkeys(String key) {
+  public Response<Set<String>> hkeys(final String key) {
     getClient(key).hkeys(key);
     return getResponse(BuilderFactory.STRING_SET);
   }
 
   @Override
-  public Response<Set<byte[]>> hkeys(byte[] key) {
+  public Response<Set<byte[]>> hkeys(final byte[] key) {
     getClient(key).hkeys(key);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Long> hlen(String key) {
+  public Response<Long> hlen(final String key) {
     getClient(key).hlen(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> hlen(byte[] key) {
+  public Response<Long> hlen(final byte[] key) {
     getClient(key).hlen(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<List<String>> hmget(String key, String... fields) {
+  public Response<List<String>> hmget(final String key, final String... fields) {
     getClient(key).hmget(key, fields);
     return getResponse(BuilderFactory.STRING_LIST);
   }
 
   @Override
-  public Response<List<byte[]>> hmget(byte[] key, byte[]... fields) {
+  public Response<List<byte[]>> hmget(final byte[] key, final byte[]... fields) {
     getClient(key).hmget(key, fields);
     return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
   }
 
   @Override
-  public Response<String> hmset(String key, Map<String, String> hash) {
+  public Response<String> hmset(final String key, final Map<String, String> hash) {
     getClient(key).hmset(key, hash);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
+  public Response<String> hmset(final byte[] key, final Map<byte[], byte[]> hash) {
     getClient(key).hmset(key, hash);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<Long> hset(String key, String field, String value) {
+  public Response<Long> hset(final String key, final String field, final String value) {
     getClient(key).hset(key, field, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
+  public Response<Long> hset(final byte[] key, final byte[] field, final byte[] value) {
     getClient(key).hset(key, field, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> hsetnx(String key, String field, String value) {
+  public Response<Long> hsetnx(final String key, final String field, final String value) {
     getClient(key).hsetnx(key, field, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
+  public Response<Long> hsetnx(final byte[] key, final byte[] field, final byte[] value) {
     getClient(key).hsetnx(key, field, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<List<String>> hvals(String key) {
+  public Response<List<String>> hvals(final String key) {
     getClient(key).hvals(key);
     return getResponse(BuilderFactory.STRING_LIST);
   }
 
   @Override
-  public Response<List<byte[]>> hvals(byte[] key) {
+  public Response<List<byte[]>> hvals(final byte[] key) {
     getClient(key).hvals(key);
     return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
   }
 
   @Override
-  public Response<Long> incr(String key) {
+  public Response<Long> incr(final String key) {
     getClient(key).incr(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> incr(byte[] key) {
+  public Response<Long> incr(final byte[] key) {
     getClient(key).incr(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> incrBy(String key, long integer) {
+  public Response<Long> incrBy(final String key, final long integer) {
     getClient(key).incrBy(key, integer);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> incrBy(byte[] key, long integer) {
+  public Response<Long> incrBy(final byte[] key, final long integer) {
     getClient(key).incrBy(key, integer);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> lindex(String key, long index) {
+  public Response<String> lindex(final String key, final long index) {
     getClient(key).lindex(key, index);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<byte[]> lindex(byte[] key, long index) {
+  public Response<byte[]> lindex(final byte[] key, final long index) {
     getClient(key).lindex(key, index);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<Long> linsert(String key, LIST_POSITION where, String pivot, String value) {
+  public Response<Long> linsert(final String key, final LIST_POSITION where, final String pivot, final String value) {
     getClient(key).linsert(key, where, pivot, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value) {
+  public Response<Long> linsert(final byte[] key, final LIST_POSITION where, final byte[] pivot, final byte[] value) {
     getClient(key).linsert(key, where, pivot, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> llen(String key) {
+  public Response<Long> llen(final String key) {
     getClient(key).llen(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> llen(byte[] key) {
+  public Response<Long> llen(final byte[] key) {
     getClient(key).llen(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> lpop(String key) {
+  public Response<String> lpop(final String key) {
     getClient(key).lpop(key);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<byte[]> lpop(byte[] key) {
+  public Response<byte[]> lpop(final byte[] key) {
     getClient(key).lpop(key);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<Long> lpush(String key, String... string) {
+  public Response<Long> lpush(final String key, final String... string) {
     getClient(key).lpush(key, string);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> lpush(byte[] key, byte[]... string) {
+  public Response<Long> lpush(final byte[] key, final byte[]... string) {
     getClient(key).lpush(key, string);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> lpushx(String key, String... string) {
+  public Response<Long> lpushx(final String key, final String... string) {
     getClient(key).lpushx(key, string);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> lpushx(byte[] key, byte[]... bytes) {
+  public Response<Long> lpushx(final byte[] key, final byte[]... bytes) {
     getClient(key).lpushx(key, bytes);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<List<String>> lrange(String key, long start, long end) {
+  public Response<List<String>> lrange(final String key, final long start, final long end) {
     getClient(key).lrange(key, start, end);
     return getResponse(BuilderFactory.STRING_LIST);
   }
 
   @Override
-  public Response<List<byte[]>> lrange(byte[] key, long start, long end) {
+  public Response<List<byte[]>> lrange(final byte[] key, final long start, final long end) {
     getClient(key).lrange(key, start, end);
     return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
   }
 
   @Override
-  public Response<Long> lrem(String key, long count, String value) {
+  public Response<Long> lrem(final String key, final long count, final String value) {
     getClient(key).lrem(key, count, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> lrem(byte[] key, long count, byte[] value) {
+  public Response<Long> lrem(final byte[] key, final long count, final byte[] value) {
     getClient(key).lrem(key, count, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> lset(String key, long index, String value) {
+  public Response<String> lset(final String key, final long index, final String value) {
     getClient(key).lset(key, index, value);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> lset(byte[] key, long index, byte[] value) {
+  public Response<String> lset(final byte[] key, final long index, final byte[] value) {
     getClient(key).lset(key, index, value);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> ltrim(String key, long start, long end) {
+  public Response<String> ltrim(final String key, final long start, final long end) {
     getClient(key).ltrim(key, start, end);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> ltrim(byte[] key, long start, long end) {
+  public Response<String> ltrim(final byte[] key, final long start, final long end) {
     getClient(key).ltrim(key, start, end);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<Long> move(String key, int dbIndex) {
+  public Response<Long> move(final String key, final int dbIndex) {
     getClient(key).move(key, dbIndex);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> move(byte[] key, int dbIndex) {
+  public Response<Long> move(final byte[] key, final int dbIndex) {
     getClient(key).move(key, dbIndex);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> persist(String key) {
+  public Response<Long> persist(final String key) {
     getClient(key).persist(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> persist(byte[] key) {
+  public Response<Long> persist(final byte[] key) {
     getClient(key).persist(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> rpop(String key) {
+  public Response<String> rpop(final String key) {
     getClient(key).rpop(key);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<byte[]> rpop(byte[] key) {
+  public Response<byte[]> rpop(final byte[] key) {
     getClient(key).rpop(key);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<Long> rpush(String key, String... string) {
+  public Response<Long> rpush(final String key, final String... string) {
     getClient(key).rpush(key, string);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> rpush(byte[] key, byte[]... string) {
+  public Response<Long> rpush(final byte[] key, final byte[]... string) {
     getClient(key).rpush(key, string);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> rpushx(String key, String... string) {
+  public Response<Long> rpushx(final String key, final String... string) {
     getClient(key).rpushx(key, string);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> rpushx(byte[] key, byte[]... string) {
+  public Response<Long> rpushx(final byte[] key, final byte[]... string) {
     getClient(key).rpushx(key, string);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> sadd(String key, String... member) {
+  public Response<Long> sadd(final String key, final String... member) {
     getClient(key).sadd(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> sadd(byte[] key, byte[]... member) {
+  public Response<Long> sadd(final byte[] key, final byte[]... member) {
     getClient(key).sadd(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> scard(String key) {
+  public Response<Long> scard(final String key) {
     getClient(key).scard(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> scard(byte[] key) {
+  public Response<Long> scard(final byte[] key) {
     getClient(key).scard(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> set(String key, String value) {
+  public Response<String> set(final String key, final String value) {
     getClient(key).set(key, value);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> set(byte[] key, byte[] value) {
+  public Response<String> set(final byte[] key, final byte[] value) {
     getClient(key).set(key, value);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<String> set(String key, String value, SetParams params) {
+  public Response<String> set(final String key, final String value, SetParams params) {
     getClient(key).set(key, value, params);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<String> set(byte[] key, byte[] value, SetParams params) {
+  public Response<String> set(final byte[] key, final byte[] value, SetParams params) {
     getClient(key).set(key, value, params);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<Boolean> setbit(String key, long offset, boolean value) {
+  public Response<Boolean> setbit(final String key, final long offset, boolean value) {
     getClient(key).setbit(key, offset, value);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<Boolean> setbit(byte[] key, long offset, byte[] value) {
+  public Response<Boolean> setbit(final byte[] key, final long offset, final byte[] value) {
     getClient(key).setbit(key, offset, value);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<String> setex(String key, int seconds, String value) {
+  public Response<String> setex(final String key, final int seconds, final String value) {
     getClient(key).setex(key, seconds, value);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> setex(byte[] key, int seconds, byte[] value) {
+  public Response<String> setex(final byte[] key, final int seconds, final byte[] value) {
     getClient(key).setex(key, seconds, value);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<Long> setnx(String key, String value) {
+  public Response<Long> setnx(final String key, final String value) {
     getClient(key).setnx(key, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> setnx(byte[] key, byte[] value) {
+  public Response<Long> setnx(final byte[] key, final byte[] value) {
     getClient(key).setnx(key, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> setrange(String key, long offset, String value) {
+  public Response<Long> setrange(final String key, final long offset, final String value) {
     getClient(key).setrange(key, offset, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> setrange(byte[] key, long offset, byte[] value) {
+  public Response<Long> setrange(final byte[] key, final long offset, final byte[] value) {
     getClient(key).setrange(key, offset, value);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Boolean> sismember(String key, String member) {
+  public Response<Boolean> sismember(final String key, final String member) {
     getClient(key).sismember(key, member);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<Boolean> sismember(byte[] key, byte[] member) {
+  public Response<Boolean> sismember(final byte[] key, final byte[] member) {
     getClient(key).sismember(key, member);
     return getResponse(BuilderFactory.BOOLEAN);
   }
 
   @Override
-  public Response<Set<String>> smembers(String key) {
+  public Response<Set<String>> smembers(final String key) {
     getClient(key).smembers(key);
     return getResponse(BuilderFactory.STRING_SET);
   }
 
   @Override
-  public Response<Set<byte[]>> smembers(byte[] key) {
+  public Response<Set<byte[]>> smembers(final byte[] key) {
     getClient(key).smembers(key);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<List<String>> sort(String key) {
+  public Response<List<String>> sort(final String key) {
     getClient(key).sort(key);
     return getResponse(BuilderFactory.STRING_LIST);
   }
 
   @Override
-  public Response<List<byte[]>> sort(byte[] key) {
+  public Response<List<byte[]>> sort(final byte[] key) {
     getClient(key).sort(key);
     return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
   }
 
   @Override
-  public Response<List<String>> sort(String key, SortingParams sortingParameters) {
+  public Response<List<String>> sort(final String key, final SortingParams sortingParameters) {
     getClient(key).sort(key, sortingParameters);
     return getResponse(BuilderFactory.STRING_LIST);
   }
 
   @Override
-  public Response<List<byte[]>> sort(byte[] key, SortingParams sortingParameters) {
+  public Response<List<byte[]>> sort(final byte[] key, final SortingParams sortingParameters) {
     getClient(key).sort(key, sortingParameters);
     return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
   }
 
   @Override
-  public Response<String> spop(String key) {
+  public Response<String> spop(final String key) {
     getClient(key).spop(key);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<Set<String>> spop(String key, long count) {
+  public Response<Set<String>> spop(final String key, final long count) {
     getClient(key).spop(key, count);
     return getResponse(BuilderFactory.STRING_SET);
   }
 
   @Override
-  public Response<byte[]> spop(byte[] key) {
+  public Response<byte[]> spop(final byte[] key) {
     getClient(key).spop(key);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
   @Override
-  public Response<Set<byte[]>> spop(byte[] key, long count) {
+  public Response<Set<byte[]>> spop(final byte[] key, final long count) {
     getClient(key).spop(key, count);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<String> srandmember(String key) {
+  public Response<String> srandmember(final String key) {
     getClient(key).srandmember(key);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<List<String>> srandmember(String key, int count) {
+  public Response<List<String>> srandmember(final String key, final int count) {
     getClient(key).srandmember(key, count);
     return getResponse(BuilderFactory.STRING_LIST);
   }
 
   @Override
-  public Response<byte[]> srandmember(byte[] key) {
+  public Response<byte[]> srandmember(final byte[] key) {
     getClient(key).srandmember(key);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
-  public Response<List<byte[]>> srandmember(byte[] key, int count) {
+  public Response<List<byte[]>> srandmember(final byte[] key, final int count) {
     getClient(key).srandmember(key, count);
     return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
   }
 
   @Override
-  public Response<Long> srem(String key, String... member) {
+  public Response<Long> srem(final String key, final String... member) {
     getClient(key).srem(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> srem(byte[] key, byte[]... member) {
+  public Response<Long> srem(final byte[] key, final byte[]... member) {
     getClient(key).srem(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> strlen(String key) {
+  public Response<Long> strlen(final String key) {
     getClient(key).strlen(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> strlen(byte[] key) {
+  public Response<Long> strlen(final byte[] key) {
     getClient(key).strlen(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> substr(String key, int start, int end) {
+  public Response<String> substr(final String key, final int start, final int end) {
     getClient(key).substr(key, start, end);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> substr(byte[] key, int start, int end) {
+  public Response<String> substr(final byte[] key, final int start, final int end) {
     getClient(key).substr(key, start, end);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<Long> touch(String key) {
+  public Response<Long> touch(final String key) {
     getClient(key).touch(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> touch(byte[] key) {
+  public Response<Long> touch(final byte[] key) {
     getClient(key).touch(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> ttl(String key) {
+  public Response<Long> ttl(final String key) {
     getClient(key).ttl(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> ttl(byte[] key) {
+  public Response<Long> ttl(final byte[] key) {
     getClient(key).ttl(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<String> type(String key) {
+  public Response<String> type(final String key) {
     getClient(key).type(key);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<String> type(byte[] key) {
+  public Response<String> type(final byte[] key) {
     getClient(key).type(key);
     return getResponse(BuilderFactory.STRING);
   }
 
   @Override
-  public Response<Long> zadd(String key, double score, String member) {
+  public Response<Long> zadd(final String key, final double score, final String member) {
     getClient(key).zadd(key, score, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zadd(String key, double score, String member, ZAddParams params) {
+  public Response<Long> zadd(final String key, final double score, final String member, final ZAddParams params) {
     getClient(key).zadd(key, score, member, params);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zadd(String key, Map<String, Double> scoreMembers) {
+  public Response<Long> zadd(final String key, final Map<String, Double> scoreMembers) {
     getClient(key).zadd(key, scoreMembers);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
+  public Response<Long> zadd(final String key, final Map<String, Double> scoreMembers, final ZAddParams params) {
     getClient(key).zadd(key, scoreMembers, params);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zadd(byte[] key, double score, byte[] member) {
+  public Response<Long> zadd(final byte[] key, final double score, final byte[] member) {
     getClient(key).zadd(key, score, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zadd(byte[] key, double score, byte[] member, ZAddParams params) {
+  public Response<Long> zadd(final byte[] key, final double score, final byte[] member, final ZAddParams params) {
     getClient(key).zadd(key, score, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zadd(byte[] key, Map<byte[], Double> scoreMembers) {
+  public Response<Long> zadd(final byte[] key, final Map<byte[], Double> scoreMembers) {
     getClient(key).zadd(key, scoreMembers);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
+  public Response<Long> zadd(final byte[] key, final Map<byte[], Double> scoreMembers, final ZAddParams params) {
     getClient(key).zadd(key, scoreMembers, params);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zcard(String key) {
+  public Response<Long> zcard(final String key) {
     getClient(key).zcard(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zcard(byte[] key) {
+  public Response<Long> zcard(final byte[] key) {
     getClient(key).zcard(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zcount(String key, double min, double max) {
+  public Response<Long> zcount(final String key, final double min, final double max) {
     getClient(key).zcount(key, min, max);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<Long> zcount(String key, String min, String max) {
+  public Response<Long> zcount(final String key, final String min, final String max) {
     getClient(key).zcount(key, min, max);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zcount(byte[] key, double min, double max) {
+  public Response<Long> zcount(final byte[] key, final double min, final double max) {
     getClient(key).zcount(key, toByteArray(min), toByteArray(max));
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<Long> zcount(byte[] key, byte[] min, byte[] max) {
+  public Response<Long> zcount(final byte[] key, final byte[] min, final byte[] max) {
     getClient(key).zcount(key, min, max);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Double> zincrby(String key, double score, String member) {
+  public Response<Double> zincrby(final String key, final double score, final String member) {
     getClient(key).zincrby(key, score, member);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Double> zincrby(String key, double score, String member, ZIncrByParams params) {
+  public Response<Double> zincrby(final String key, final double score, final String member, ZIncrByParams params) {
     getClient(key).zincrby(key, score, member, params);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Double> zincrby(byte[] key, double score, byte[] member) {
+  public Response<Double> zincrby(final byte[] key, final double score, final byte[] member) {
     getClient(key).zincrby(key, score, member);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Double> zincrby(byte[] key, double score, byte[] member, ZIncrByParams params) {
+  public Response<Double> zincrby(final byte[] key, final double score, final byte[] member, ZIncrByParams params) {
     getClient(key).zincrby(key, score, member);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Set<String>> zrange(String key, long start, long end) {
+  public Response<Set<String>> zrange(final String key, final long start, final long end) {
     getClient(key).zrange(key, start, end);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrange(byte[] key, long start, long end) {
+  public Response<Set<byte[]>> zrange(final byte[] key, final long start, final long end) {
     getClient(key).zrange(key, start, end);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Set<String>> zrangeByScore(String key, double min, double max) {
+  public Response<Set<String>> zrangeByScore(final String key, final double min, final double max) {
     getClient(key).zrangeByScore(key, min, max);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrangeByScore(byte[] key, double min, double max) {
+  public Response<Set<byte[]>> zrangeByScore(final byte[] key, final double min, final double max) {
     return zrangeByScore(key, toByteArray(min), toByteArray(max));
   }
 
   @Override
-  public Response<Set<String>> zrangeByScore(String key, String min, String max) {
+  public Response<Set<String>> zrangeByScore(final String key, final String min, final String max) {
     getClient(key).zrangeByScore(key, min, max);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, byte[] max) {
+  public Response<Set<byte[]>> zrangeByScore(final byte[] key, final byte[] min, final byte[] max) {
     getClient(key).zrangeByScore(key, min, max);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Set<String>> zrangeByScore(String key, double min, double max, int offset,
-      int count) {
+  public Response<Set<String>> zrangeByScore(final String key, final double min, final double max, final int offset,
+      final int count) {
     getClient(key).zrangeByScore(key, min, max, offset, count);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
-  public Response<Set<String>> zrangeByScore(String key, String min, String max, int offset,
-      int count) {
+  public Response<Set<String>> zrangeByScore(final String key, final String min, final String max, final int offset,
+      final int count) {
     getClient(key).zrangeByScore(key, min, max, offset, count);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrangeByScore(byte[] key, double min, double max, int offset,
-      int count) {
+  public Response<Set<byte[]>> zrangeByScore(final byte[] key, final double min, final double max, final int offset,
+      final int count) {
     return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
   }
 
   @Override
-  public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset,
-      int count) {
+  public Response<Set<byte[]>> zrangeByScore(final byte[] key, final byte[] min, final byte[] max, final int offset,
+      final int count) {
     getClient(key).zrangeByScore(key, min, max, offset, count);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max) {
+  public Response<Set<Tuple>> zrangeByScoreWithScores(final String key, final double min, final double max) {
     getClient(key).zrangeByScoreWithScores(key, min, max);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
-  public Response<Set<Tuple>> zrangeByScoreWithScores(String key, String min, String max) {
+  public Response<Set<Tuple>> zrangeByScoreWithScores(final String key, final String min, final String max) {
     getClient(key).zrangeByScoreWithScores(key, min, max);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, double max) {
+  public Response<Set<Tuple>> zrangeByScoreWithScores(final byte[] key, final double min, final double max) {
     return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
   }
 
   @Override
-  public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
+  public Response<Set<Tuple>> zrangeByScoreWithScores(final byte[] key, final byte[] min, final byte[] max) {
     getClient(key).zrangeByScoreWithScores(key, min, max);
     return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
   }
 
   @Override
-  public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max,
-      int offset, int count) {
+  public Response<Set<Tuple>> zrangeByScoreWithScores(final String key, final double min, final double max,
+      final int offset, final int count) {
     getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
-  public Response<Set<Tuple>> zrangeByScoreWithScores(String key, String min, String max,
-      int offset, int count) {
+  public Response<Set<Tuple>> zrangeByScoreWithScores(final String key, final String min, final String max,
+      final int offset, final int count) {
     getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, double max,
-      int offset, int count) {
+  public Response<Set<Tuple>> zrangeByScoreWithScores(final byte[] key, final double min, final double max,
+      final int offset, final int count) {
     getClient(key).zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
     return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
   }
 
   @Override
-  public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max,
-      int offset, int count) {
+  public Response<Set<Tuple>> zrangeByScoreWithScores(final byte[] key, final byte[] min, final byte[] max,
+      final int offset, final int count) {
     getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
     return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
   }
 
   @Override
-  public Response<Set<String>> zrevrangeByScore(String key, double max, double min) {
+  public Response<Set<String>> zrevrangeByScore(final String key, final double max, final double min) {
     getClient(key).zrevrangeByScore(key, max, min);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, double min) {
+  public Response<Set<byte[]>> zrevrangeByScore(final byte[] key, final double max, final double min) {
     getClient(key).zrevrangeByScore(key, toByteArray(max), toByteArray(min));
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Set<String>> zrevrangeByScore(String key, String max, String min) {
+  public Response<Set<String>> zrevrangeByScore(final String key, final String max, final String min) {
     getClient(key).zrevrangeByScore(key, max, min);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
+  public Response<Set<byte[]>> zrevrangeByScore(final byte[] key, final byte[] max, final byte[] min) {
     getClient(key).zrevrangeByScore(key, max, min);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Set<String>> zrevrangeByScore(String key, double max, double min, int offset,
-      int count) {
+  public Response<Set<String>> zrevrangeByScore(final String key, final double max, final double min, final int offset,
+      final int count) {
     getClient(key).zrevrangeByScore(key, max, min, offset, count);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
-  public Response<Set<String>> zrevrangeByScore(String key, String max, String min, int offset,
-      int count) {
+  public Response<Set<String>> zrevrangeByScore(final String key, final String max, final String min, final int offset,
+      final int count) {
     getClient(key).zrevrangeByScore(key, max, min, offset, count);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, double min, int offset,
-      int count) {
+  public Response<Set<byte[]>> zrevrangeByScore(final byte[] key, final double max, final double min, final int offset,
+      final int count) {
     getClient(key).zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset,
-      int count) {
+  public Response<Set<byte[]>> zrevrangeByScore(final byte[] key, final byte[] max, final byte[] min, final int offset,
+      final int count) {
     getClient(key).zrevrangeByScore(key, max, min, offset, count);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max, double min) {
+  public Response<Set<Tuple>> zrevrangeByScoreWithScores(final String key, final double max, final double min) {
     getClient(key).zrevrangeByScoreWithScores(key, max, min);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
-  public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, String max, String min) {
+  public Response<Set<Tuple>> zrevrangeByScoreWithScores(final String key, final String max, final String min) {
     getClient(key).zrevrangeByScoreWithScores(key, max, min);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
+  public Response<Set<Tuple>> zrevrangeByScoreWithScores(final byte[] key, final double max, final double min) {
     getClient(key).zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
     return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
   }
 
   @Override
-  public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
+  public Response<Set<Tuple>> zrevrangeByScoreWithScores(final byte[] key, final byte[] max, final byte[] min) {
     getClient(key).zrevrangeByScoreWithScores(key, max, min);
     return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
   }
 
   @Override
-  public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max, double min,
-      int offset, int count) {
+  public Response<Set<Tuple>> zrevrangeByScoreWithScores(final String key, final double max, final double min,
+      final int offset, final int count) {
     getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
-  public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, String max, String min,
-      int offset, int count) {
+  public Response<Set<Tuple>> zrevrangeByScoreWithScores(final String key, final String max, final String min,
+      final int offset, final int count) {
     getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max, double min,
-      int offset, int count) {
+  public Response<Set<Tuple>> zrevrangeByScoreWithScores(final byte[] key, final double max, final double min,
+      final int offset, final int count) {
     getClient(key).zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset,
       count);
     return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
   }
 
   @Override
-  public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min,
-      int offset, int count) {
+  public Response<Set<Tuple>> zrevrangeByScoreWithScores(final byte[] key, final byte[] max, final byte[] min,
+      final int offset, final int count) {
     getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
     return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
   }
 
   @Override
-  public Response<Set<Tuple>> zrangeWithScores(String key, long start, long end) {
+  public Response<Set<Tuple>> zrangeWithScores(final String key, final long start, final long end) {
     getClient(key).zrangeWithScores(key, start, end);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrangeWithScores(byte[] key, long start, long end) {
+  public Response<Set<Tuple>> zrangeWithScores(final byte[] key, final long start, final long end) {
     getClient(key).zrangeWithScores(key, start, end);
     return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
   }
 
   @Override
-  public Response<Long> zrank(String key, String member) {
+  public Response<Long> zrank(final String key, final String member) {
     getClient(key).zrank(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zrank(byte[] key, byte[] member) {
+  public Response<Long> zrank(final byte[] key, final byte[] member) {
     getClient(key).zrank(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zrem(String key, String... member) {
+  public Response<Long> zrem(final String key, final String... member) {
     getClient(key).zrem(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zrem(byte[] key, byte[]... member) {
+  public Response<Long> zrem(final byte[] key, final byte[]... member) {
     getClient(key).zrem(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zremrangeByRank(String key, long start, long end) {
+  public Response<Long> zremrangeByRank(final String key, final long start, final long end) {
     getClient(key).zremrangeByRank(key, start, end);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zremrangeByRank(byte[] key, long start, long end) {
+  public Response<Long> zremrangeByRank(final byte[] key, final long start, final long end) {
     getClient(key).zremrangeByRank(key, start, end);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zremrangeByScore(String key, double start, double end) {
+  public Response<Long> zremrangeByScore(final String key, final double start, final double end) {
     getClient(key).zremrangeByScore(key, start, end);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<Long> zremrangeByScore(String key, String start, String end) {
+  public Response<Long> zremrangeByScore(final String key, final String start, final String end) {
     getClient(key).zremrangeByScore(key, start, end);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
+  public Response<Long> zremrangeByScore(final byte[] key, final double start, final double end) {
     getClient(key).zremrangeByScore(key, toByteArray(start), toByteArray(end));
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
+  public Response<Long> zremrangeByScore(final byte[] key, final byte[] start, final byte[] end) {
     getClient(key).zremrangeByScore(key, start, end);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Set<String>> zrevrange(String key, long start, long end) {
+  public Response<Set<String>> zrevrange(final String key, final long start, final long end) {
     getClient(key).zrevrange(key, start, end);
     return getResponse(BuilderFactory.STRING_ZSET);
   }
 
   @Override
-  public Response<Set<byte[]>> zrevrange(byte[] key, long start, long end) {
+  public Response<Set<byte[]>> zrevrange(final byte[] key, final long start, final long end) {
     getClient(key).zrevrange(key, start, end);
     return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrevrangeWithScores(String key, long start, long end) {
+  public Response<Set<Tuple>> zrevrangeWithScores(final String key, final long start, final long end) {
     getClient(key).zrevrangeWithScores(key, start, end);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
   @Override
-  public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, long start, long end) {
+  public Response<Set<Tuple>> zrevrangeWithScores(final byte[] key, final long start, final long end) {
     getClient(key).zrevrangeWithScores(key, start, end);
     return getResponse(BuilderFactory.TUPLE_ZSET);
   }
 
   @Override
-  public Response<Long> zrevrank(String key, String member) {
+  public Response<Long> zrevrank(final String key, final String member) {
     getClient(key).zrevrank(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> zrevrank(byte[] key, byte[] member) {
+  public Response<Long> zrevrank(final byte[] key, final byte[] member) {
     getClient(key).zrevrank(key, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Double> zscore(String key, String member) {
+  public Response<Double> zscore(final String key, final String member) {
     getClient(key).zscore(key, member);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Double> zscore(byte[] key, byte[] member) {
+  public Response<Double> zscore(final byte[] key, final byte[] member) {
     getClient(key).zscore(key, member);
     return getResponse(BuilderFactory.DOUBLE);
   }
@@ -1348,301 +1348,301 @@ public Response<Long> zremrangeByLex(final String key, final String min, final S
   }
 
   @Override
-  public Response<Long> bitcount(String key) {
+  public Response<Long> bitcount(final String key) {
     getClient(key).bitcount(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> bitcount(String key, long start, long end) {
+  public Response<Long> bitcount(final String key, final long start, final long end) {
     getClient(key).bitcount(key, start, end);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> bitcount(byte[] key) {
+  public Response<Long> bitcount(final byte[] key) {
     getClient(key).bitcount(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> bitcount(byte[] key, long start, long end) {
+  public Response<Long> bitcount(final byte[] key, final long start, final long end) {
     getClient(key).bitcount(key, start, end);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<byte[]> dump(String key) {
+  public Response<byte[]> dump(final String key) {
     getClient(key).dump(key);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
-  public Response<byte[]> dump(byte[] key) {
+  public Response<byte[]> dump(final byte[] key) {
     getClient(key).dump(key);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
-  public Response<String> migrate(String host, int port, String key, int destinationDb, int timeout) {
+  public Response<String> migrate(final String host, final int port, final String key, final int destinationDb, final int timeout) {
     getClient(key).migrate(host, port, key, destinationDb, timeout);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<String> migrate(byte[] host, int port, byte[] key, int destinationDb, int timeout) {
+  public Response<String> migrate(final byte[] host, final int port, final byte[] key, final int destinationDb, final int timeout) {
     getClient(key).migrate(host, port, key, destinationDb, timeout);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<Long> objectRefcount(String key) {
+  public Response<Long> objectRefcount(final String key) {
     getClient(key).objectRefcount(key);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<Long> objectRefcount(byte[] key) {
+  public Response<Long> objectRefcount(final byte[] key) {
     getClient(key).objectRefcount(key);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<String> objectEncoding(String key) {
+  public Response<String> objectEncoding(final String key) {
     getClient(key).objectEncoding(key);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<byte[]> objectEncoding(byte[] key) {
+  public Response<byte[]> objectEncoding(final byte[] key) {
     getClient(key).objectEncoding(key);
     return getResponse(BuilderFactory.BYTE_ARRAY);
   }
 
-  public Response<Long> objectIdletime(String key) {
+  public Response<Long> objectIdletime(final String key) {
     getClient(key).objectIdletime(key);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<Long> objectIdletime(byte[] key) {
+  public Response<Long> objectIdletime(final byte[] key) {
     getClient(key).objectIdletime(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> pexpire(String key, long milliseconds) {
+  public Response<Long> pexpire(final String key, final long milliseconds) {
     getClient(key).pexpire(key, milliseconds);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> pexpire(byte[] key, long milliseconds) {
+  public Response<Long> pexpire(final byte[] key, final long milliseconds) {
     getClient(key).pexpire(key, milliseconds);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> pexpireAt(String key, long millisecondsTimestamp) {
+  public Response<Long> pexpireAt(final String key, final long millisecondsTimestamp) {
     getClient(key).pexpireAt(key, millisecondsTimestamp);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> pexpireAt(byte[] key, long millisecondsTimestamp) {
+  public Response<Long> pexpireAt(final byte[] key, final long millisecondsTimestamp) {
     getClient(key).pexpireAt(key, millisecondsTimestamp);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<Long> pttl(String key) {
+  public Response<Long> pttl(final String key) {
     getClient(key).pttl(key);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<Long> pttl(byte[] key) {
+  public Response<Long> pttl(final byte[] key) {
     getClient(key).pttl(key);
     return getResponse(BuilderFactory.LONG);
   }
 
-  public Response<String> restore(String key, int ttl, byte[] serializedValue) {
+  public Response<String> restore(final String key, final int ttl, final byte[] serializedValue) {
     getClient(key).restore(key, ttl, serializedValue);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<String> restore(byte[] key, int ttl, byte[] serializedValue) {
+  public Response<String> restore(final byte[] key, final int ttl, final byte[] serializedValue) {
     getClient(key).restore(key, ttl, serializedValue);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<Double> incrByFloat(String key, double increment) {
+  public Response<Double> incrByFloat(final String key, final double increment) {
     getClient(key).incrByFloat(key, increment);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
-  public Response<Double> incrByFloat(byte[] key, double increment) {
+  public Response<Double> incrByFloat(final byte[] key, final double increment) {
     getClient(key).incrByFloat(key, increment);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
-  public Response<String> psetex(String key, long milliseconds, String value) {
+  public Response<String> psetex(final String key, final long milliseconds, final String value) {
     getClient(key).psetex(key, milliseconds, value);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<String> psetex(byte[] key, long milliseconds, byte[] value) {
+  public Response<String> psetex(final byte[] key, final long milliseconds, final byte[] value) {
     getClient(key).psetex(key, milliseconds, value);
     return getResponse(BuilderFactory.STRING);
   }
 
-  public Response<Double> hincrByFloat(String key, String field, double increment) {
+  public Response<Double> hincrByFloat(final String key, final String field, final double increment) {
     getClient(key).hincrByFloat(key, field, increment);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
-  public Response<Double> hincrByFloat(byte[] key, byte[] field, double increment) {
+  public Response<Double> hincrByFloat(final byte[] key, final byte[] field, final double increment) {
     getClient(key).hincrByFloat(key, field, increment);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Long> pfadd(byte[] key, byte[]... elements) {
+  public Response<Long> pfadd(final byte[] key, final byte[]... elements) {
     getClient(key).pfadd(key, elements);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> pfcount(byte[] key) {
+  public Response<Long> pfcount(final byte[] key) {
     getClient(key).pfcount(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> pfadd(String key, String... elements) {
+  public Response<Long> pfadd(final String key, final String... elements) {
     getClient(key).pfadd(key, elements);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> pfcount(String key) {
+  public Response<Long> pfcount(final String key) {
     getClient(key).pfcount(key);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> geoadd(byte[] key, double longitude, double latitude, byte[] member) {
+  public Response<Long> geoadd(final byte[] key, final double longitude, final double latitude, final byte[] member) {
     getClient(key).geoadd(key, longitude, latitude, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap) {
+  public Response<Long> geoadd(final byte[] key, final Map<byte[], GeoCoordinate> memberCoordinateMap) {
     getClient(key).geoadd(key, memberCoordinateMap);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> geoadd(String key, double longitude, double latitude, String member) {
+  public Response<Long> geoadd(final String key, final double longitude, final double latitude, final String member) {
     getClient(key).geoadd(key, longitude, latitude, member);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Long> geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap) {
+  public Response<Long> geoadd(final String key, final Map<String, GeoCoordinate> memberCoordinateMap) {
     getClient(key).geoadd(key, memberCoordinateMap);
     return getResponse(BuilderFactory.LONG);
   }
 
   @Override
-  public Response<Double> geodist(byte[] key, byte[] member1, byte[] member2) {
+  public Response<Double> geodist(final byte[] key, final byte[] member1, final byte[] member2) {
     getClient(key).geodist(key, member1, member2);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Double> geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
+  public Response<Double> geodist(final byte[] key, final byte[] member1, final byte[] member2, final GeoUnit unit) {
     getClient(key).geodist(key, member1, member2, unit);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Double> geodist(String key, String member1, String member2) {
+  public Response<Double> geodist(final String key, final String member1, final String member2) {
     getClient(key).geodist(key, member1, member2);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<Double> geodist(String key, String member1, String member2, GeoUnit unit) {
+  public Response<Double> geodist(final String key, final String member1, final String member2, final GeoUnit unit) {
     getClient(key).geodist(key, member1, member2);
     return getResponse(BuilderFactory.DOUBLE);
   }
 
   @Override
-  public Response<List<byte[]>> geohash(byte[] key, byte[]... members) {
+  public Response<List<byte[]>> geohash(final byte[] key, final byte[]... members) {
     getClient(key).geohash(key, members);
     return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
   }
 
   @Override
-  public Response<List<String>> geohash(String key, String... members) {
+  public Response<List<String>> geohash(final String key, final String... members) {
     getClient(key).geohash(key, members);
     return getResponse(BuilderFactory.STRING_LIST);
   }
 
   @Override
-  public Response<List<GeoCoordinate>> geopos(byte[] key, byte[]... members) {
+  public Response<List<GeoCoordinate>> geopos(final byte[] key, final byte[]... members) {
     getClient(key).geopos(key, members);
     return getResponse(BuilderFactory.GEO_COORDINATE_LIST);
   }
 
   @Override
-  public Response<List<GeoCoordinate>> geopos(String key, String... members) {
+  public Response<List<GeoCoordinate>> geopos(final String key, final String... members) {
     getClient(key).geopos(key, members);
     return getResponse(BuilderFactory.GEO_COORDINATE_LIST);
   }
 
   @Override
-  public Response<List<GeoRadiusResponse>> georadius(byte[] key, double longitude, double latitude,
-      double radius, GeoUnit unit) {
+  public Response<List<GeoRadiusResponse>> georadius(final byte[] key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit) {
     getClient(key).georadius(key, longitude, latitude, radius, unit);
     return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
   }
 
   @Override
-  public Response<List<GeoRadiusResponse>> georadius(byte[] key, double longitude, double latitude,
-      double radius, GeoUnit unit, GeoRadiusParam param) {
+  public Response<List<GeoRadiusResponse>> georadius(final byte[] key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
     getClient(key).georadius(key, longitude, latitude, radius, unit, param);
     return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
   }
 
   @Override
-  public Response<List<GeoRadiusResponse>> georadius(String key, double longitude, double latitude,
-      double radius, GeoUnit unit) {
+  public Response<List<GeoRadiusResponse>> georadius(final String key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit) {
     getClient(key).georadius(key, longitude, latitude, radius, unit);
     return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
   }
 
   @Override
-  public Response<List<GeoRadiusResponse>> georadius(String key, double longitude, double latitude,
-      double radius, GeoUnit unit, GeoRadiusParam param) {
+  public Response<List<GeoRadiusResponse>> georadius(final String key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
     getClient(key).georadius(key, longitude, latitude, radius, unit, param);
     return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
   }
 
   @Override
-  public Response<List<GeoRadiusResponse>> georadiusByMember(byte[] key, byte[] member,
-      double radius, GeoUnit unit) {
+  public Response<List<GeoRadiusResponse>> georadiusByMember(final byte[] key, final byte[] member,
+      final double radius, final GeoUnit unit) {
     getClient(key).georadiusByMember(key, member, radius, unit);
     return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
   }
 
   @Override
-  public Response<List<GeoRadiusResponse>> georadiusByMember(byte[] key, byte[] member,
-      double radius, GeoUnit unit, GeoRadiusParam param) {
+  public Response<List<GeoRadiusResponse>> georadiusByMember(final byte[] key, final byte[] member,
+      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
     getClient(key).georadiusByMember(key, member, radius, unit, param);
     return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
   }
 
   @Override
-  public Response<List<GeoRadiusResponse>> georadiusByMember(String key, String member,
-      double radius, GeoUnit unit) {
+  public Response<List<GeoRadiusResponse>> georadiusByMember(final String key, final String member,
+      final double radius, final GeoUnit unit) {
     getClient(key).georadiusByMember(key, member, radius, unit);
     return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
   }
 
   @Override
-  public Response<List<GeoRadiusResponse>> georadiusByMember(String key, String member,
-      double radius, GeoUnit unit, GeoRadiusParam param) {
+  public Response<List<GeoRadiusResponse>> georadiusByMember(final String key, final String member,
+      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
     getClient(key).georadiusByMember(key, member, radius, unit, param);
     return getResponse(BuilderFactory.GEORADIUS_WITH_PARAMS_RESULT);
   }
@@ -1671,5 +1671,4 @@ public Response<Long> hstrlen(final byte[] key, final byte[] field) {
     return getResponse(BuilderFactory.LONG);
   }
 
-
 }
diff --git a/src/main/java/redis/clients/jedis/ShardedJedis.java b/src/main/java/redis/clients/jedis/ShardedJedis.java
index dd6328c208..e07ada70c5 100644
--- a/src/main/java/redis/clients/jedis/ShardedJedis.java
+++ b/src/main/java/redis/clients/jedis/ShardedJedis.java
@@ -36,43 +36,43 @@ public ShardedJedis(List<JedisShardInfo> shards, Hashing algo, Pattern keyTagPat
   }
 
   @Override
-  public String set(String key, String value) {
+  public String set(final String key, final String value) {
     Jedis j = getShard(key);
     return j.set(key, value);
   }
 
   @Override
-  public String set(String key, String value, SetParams params) {
+  public String set(final String key, final String value, SetParams params) {
     Jedis j = getShard(key);
     return j.set(key, value, params);
   }
 
   @Override
-  public String get(String key) {
+  public String get(final String key) {
     Jedis j = getShard(key);
     return j.get(key);
   }
 
   @Override
-  public String echo(String string) {
+  public String echo(final String string) {
     Jedis j = getShard(string);
     return j.echo(string);
   }
 
   @Override
-  public Boolean exists(String key) {
+  public Boolean exists(final String key) {
     Jedis j = getShard(key);
     return j.exists(key);
   }
 
   @Override
-  public String type(String key) {
+  public String type(final String key) {
     Jedis j = getShard(key);
     return j.type(key);
   }
 
   @Override
-  public Long expire(String key, int seconds) {
+  public Long expire(final String key, final int seconds) {
     Jedis j = getShard(key);
     return j.expire(key, seconds);
   }
@@ -84,251 +84,251 @@ public Long pexpire(final String key, final long milliseconds) {
   }
 
   @Override
-  public Long expireAt(String key, long unixTime) {
+  public Long expireAt(final String key, final long unixTime) {
     Jedis j = getShard(key);
     return j.expireAt(key, unixTime);
   }
 
   @Override
-  public Long pexpireAt(String key, long millisecondsTimestamp) {
+  public Long pexpireAt(final String key, final long millisecondsTimestamp) {
     Jedis j = getShard(key);
     return j.pexpireAt(key, millisecondsTimestamp);
   }
 
   @Override
-  public Long ttl(String key) {
+  public Long ttl(final String key) {
     Jedis j = getShard(key);
     return j.ttl(key);
   }
 
   @Override
-  public Long pttl(String key) {
+  public Long pttl(final String key) {
     Jedis j = getShard(key);
     return j.pttl(key);
   }
 
   @Override
-  public Boolean setbit(String key, long offset, boolean value) {
+  public Boolean setbit(final String key, final long offset, boolean value) {
     Jedis j = getShard(key);
     return j.setbit(key, offset, value);
   }
 
   @Override
-  public Boolean setbit(String key, long offset, String value) {
+  public Boolean setbit(final String key, final long offset, final String value) {
     Jedis j = getShard(key);
     return j.setbit(key, offset, value);
   }
 
   @Override
-  public Boolean getbit(String key, long offset) {
+  public Boolean getbit(final String key, final long offset) {
     Jedis j = getShard(key);
     return j.getbit(key, offset);
   }
 
   @Override
-  public Long setrange(String key, long offset, String value) {
+  public Long setrange(final String key, final long offset, final String value) {
     Jedis j = getShard(key);
     return j.setrange(key, offset, value);
   }
 
   @Override
-  public String getrange(String key, long startOffset, long endOffset) {
+  public String getrange(final String key, final long startOffset, final long endOffset) {
     Jedis j = getShard(key);
     return j.getrange(key, startOffset, endOffset);
   }
 
   @Override
-  public String getSet(String key, String value) {
+  public String getSet(final String key, final String value) {
     Jedis j = getShard(key);
     return j.getSet(key, value);
   }
 
   @Override
-  public Long setnx(String key, String value) {
+  public Long setnx(final String key, final String value) {
     Jedis j = getShard(key);
     return j.setnx(key, value);
   }
 
   @Override
-  public String setex(String key, int seconds, String value) {
+  public String setex(final String key, final int seconds, final String value) {
     Jedis j = getShard(key);
     return j.setex(key, seconds, value);
   }
 
   @Override
-  public String psetex(String key, long milliseconds, String value) {
+  public String psetex(final String key, final long milliseconds, final String value) {
     Jedis j = getShard(key);
     return j.psetex(key, milliseconds, value);
   }
 
-  public List<String> blpop(String arg) {
+  public List<String> blpop(final String arg) {
     Jedis j = getShard(arg);
     return j.blpop(arg);
   }
 
   @Override
-  public List<String> blpop(int timeout, String key) {
+  public List<String> blpop(final int timeout, final String key) {
     Jedis j = getShard(key);
     return j.blpop(timeout, key);
   }
 
-  public List<String> brpop(String arg) {
+  public List<String> brpop(final String arg) {
     Jedis j = getShard(arg);
     return j.brpop(arg);
   }
 
   @Override
-  public List<String> brpop(int timeout, String key) {
+  public List<String> brpop(final int timeout, final String key) {
     Jedis j = getShard(key);
     return j.brpop(timeout, key);
   }
 
   @Override
-  public Long decrBy(String key, long integer) {
+  public Long decrBy(final String key, final long integer) {
     Jedis j = getShard(key);
     return j.decrBy(key, integer);
   }
 
   @Override
-  public Long decr(String key) {
+  public Long decr(final String key) {
     Jedis j = getShard(key);
     return j.decr(key);
   }
 
   @Override
-  public Long incrBy(String key, long integer) {
+  public Long incrBy(final String key, final long integer) {
     Jedis j = getShard(key);
     return j.incrBy(key, integer);
   }
 
   @Override
-  public Double incrByFloat(String key, double integer) {
+  public Double incrByFloat(final String key, final double integer) {
     Jedis j = getShard(key);
     return j.incrByFloat(key, integer);
   }
 
   @Override
-  public Long incr(String key) {
+  public Long incr(final String key) {
     Jedis j = getShard(key);
     return j.incr(key);
   }
 
   @Override
-  public Long append(String key, String value) {
+  public Long append(final String key, final String value) {
     Jedis j = getShard(key);
     return j.append(key, value);
   }
 
   @Override
-  public String substr(String key, int start, int end) {
+  public String substr(final String key, final int start, final int end) {
     Jedis j = getShard(key);
     return j.substr(key, start, end);
   }
 
   @Override
-  public Long hset(String key, String field, String value) {
+  public Long hset(final String key, final String field, final String value) {
     Jedis j = getShard(key);
     return j.hset(key, field, value);
   }
 
   @Override
-  public String hget(String key, String field) {
+  public String hget(final String key, final String field) {
     Jedis j = getShard(key);
     return j.hget(key, field);
   }
 
   @Override
-  public Long hsetnx(String key, String field, String value) {
+  public Long hsetnx(final String key, final String field, final String value) {
     Jedis j = getShard(key);
     return j.hsetnx(key, field, value);
   }
 
   @Override
-  public String hmset(String key, Map<String, String> hash) {
+  public String hmset(final String key, final Map<String, String> hash) {
     Jedis j = getShard(key);
     return j.hmset(key, hash);
   }
 
   @Override
-  public List<String> hmget(String key, String... fields) {
+  public List<String> hmget(final String key, String... fields) {
     Jedis j = getShard(key);
     return j.hmget(key, fields);
   }
 
   @Override
-  public Long hincrBy(String key, String field, long value) {
+  public Long hincrBy(final String key, final String field, final long value) {
     Jedis j = getShard(key);
     return j.hincrBy(key, field, value);
   }
 
   @Override
-  public Double hincrByFloat(String key, String field, double value) {
+  public Double hincrByFloat(final String key, final String field, final double value) {
     Jedis j = getShard(key);
     return j.hincrByFloat(key, field, value);
   }
 
   @Override
-  public Boolean hexists(String key, String field) {
+  public Boolean hexists(final String key, final String field) {
     Jedis j = getShard(key);
     return j.hexists(key, field);
   }
 
   @Override
-  public Long del(String key) {
+  public Long del(final String key) {
     Jedis j = getShard(key);
     return j.del(key);
   }
 
   @Override
-  public Long unlink(String key) {
+  public Long unlink(final String key) {
     Jedis j = getShard(key);
     return j.unlink(key);
   }
 
   @Override
-  public Long hdel(String key, String... fields) {
+  public Long hdel(final String key, String... fields) {
     Jedis j = getShard(key);
     return j.hdel(key, fields);
   }
 
   @Override
-  public Long hlen(String key) {
+  public Long hlen(final String key) {
     Jedis j = getShard(key);
     return j.hlen(key);
   }
 
   @Override
-  public Set<String> hkeys(String key) {
+  public Set<String> hkeys(final String key) {
     Jedis j = getShard(key);
     return j.hkeys(key);
   }
 
   @Override
-  public List<String> hvals(String key) {
+  public List<String> hvals(final String key) {
     Jedis j = getShard(key);
     return j.hvals(key);
   }
 
   @Override
-  public Map<String, String> hgetAll(String key) {
+  public Map<String, String> hgetAll(final String key) {
     Jedis j = getShard(key);
     return j.hgetAll(key);
   }
 
   @Override
-  public Long rpush(String key, String... strings) {
+  public Long rpush(final String key, String... strings) {
     Jedis j = getShard(key);
     return j.rpush(key, strings);
   }
 
   @Override
-  public Long lpush(String key, String... strings) {
+  public Long lpush(final String key, String... strings) {
     Jedis j = getShard(key);
     return j.lpush(key, strings);
   }
 
   @Override
-  public Long lpushx(String key, String... string) {
+  public Long lpushx(final String key, String... string) {
     Jedis j = getShard(key);
     return j.lpushx(key, string);
   }
@@ -340,13 +340,13 @@ public Long strlen(final String key) {
   }
 
   @Override
-  public Long move(String key, int dbIndex) {
+  public Long move(final String key, final int dbIndex) {
     Jedis j = getShard(key);
     return j.move(key, dbIndex);
   }
 
   @Override
-  public Long rpushx(String key, String... string) {
+  public Long rpushx(final String key, String... string) {
     Jedis j = getShard(key);
     return j.rpushx(key, string);
   }
@@ -358,335 +358,335 @@ public Long persist(final String key) {
   }
 
   @Override
-  public Long llen(String key) {
+  public Long llen(final String key) {
     Jedis j = getShard(key);
     return j.llen(key);
   }
 
   @Override
-  public List<String> lrange(String key, long start, long end) {
+  public List<String> lrange(final String key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.lrange(key, start, end);
   }
 
   @Override
-  public String ltrim(String key, long start, long end) {
+  public String ltrim(final String key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.ltrim(key, start, end);
   }
 
   @Override
-  public String lindex(String key, long index) {
+  public String lindex(final String key, final long index) {
     Jedis j = getShard(key);
     return j.lindex(key, index);
   }
 
   @Override
-  public String lset(String key, long index, String value) {
+  public String lset(final String key, final long index, final String value) {
     Jedis j = getShard(key);
     return j.lset(key, index, value);
   }
 
   @Override
-  public Long lrem(String key, long count, String value) {
+  public Long lrem(final String key, final long count, final String value) {
     Jedis j = getShard(key);
     return j.lrem(key, count, value);
   }
 
   @Override
-  public String lpop(String key) {
+  public String lpop(final String key) {
     Jedis j = getShard(key);
     return j.lpop(key);
   }
 
   @Override
-  public String rpop(String key) {
+  public String rpop(final String key) {
     Jedis j = getShard(key);
     return j.rpop(key);
   }
 
   @Override
-  public Long sadd(String key, String... members) {
+  public Long sadd(final String key, String... members) {
     Jedis j = getShard(key);
     return j.sadd(key, members);
   }
 
   @Override
-  public Set<String> smembers(String key) {
+  public Set<String> smembers(final String key) {
     Jedis j = getShard(key);
     return j.smembers(key);
   }
 
   @Override
-  public Long srem(String key, String... members) {
+  public Long srem(final String key, String... members) {
     Jedis j = getShard(key);
     return j.srem(key, members);
   }
 
   @Override
-  public String spop(String key) {
+  public String spop(final String key) {
     Jedis j = getShard(key);
     return j.spop(key);
   }
 
   @Override
-  public Set<String> spop(String key, long count) {
+  public Set<String> spop(final String key, final long count) {
     Jedis j = getShard(key);
     return j.spop(key, count);
   }
 
   @Override
-  public Long scard(String key) {
+  public Long scard(final String key) {
     Jedis j = getShard(key);
     return j.scard(key);
   }
 
   @Override
-  public Boolean sismember(String key, String member) {
+  public Boolean sismember(final String key, final String member) {
     Jedis j = getShard(key);
     return j.sismember(key, member);
   }
 
   @Override
-  public String srandmember(String key) {
+  public String srandmember(final String key) {
     Jedis j = getShard(key);
     return j.srandmember(key);
   }
 
   @Override
-  public List<String> srandmember(String key, int count) {
+  public List<String> srandmember(final String key, final int count) {
     Jedis j = getShard(key);
     return j.srandmember(key, count);
   }
 
   @Override
-  public Long zadd(String key, double score, String member) {
+  public Long zadd(final String key, final double score, final String member) {
     Jedis j = getShard(key);
     return j.zadd(key, score, member);
   }
 
   @Override
-  public Long zadd(String key, double score, String member, ZAddParams params) {
+  public Long zadd(final String key, final double score, final String member, final ZAddParams params) {
     Jedis j = getShard(key);
     return j.zadd(key, score, member, params);
   }
 
   @Override
-  public Long zadd(String key, Map<String, Double> scoreMembers) {
+  public Long zadd(final String key, final Map<String, Double> scoreMembers) {
     Jedis j = getShard(key);
     return j.zadd(key, scoreMembers);
   }
 
   @Override
-  public Long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
+  public Long zadd(final String key, final Map<String, Double> scoreMembers, final ZAddParams params) {
     Jedis j = getShard(key);
     return j.zadd(key, scoreMembers, params);
   }
 
   @Override
-  public Set<String> zrange(String key, long start, long end) {
+  public Set<String> zrange(final String key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zrange(key, start, end);
   }
 
   @Override
-  public Long zrem(String key, String... members) {
+  public Long zrem(final String key, String... members) {
     Jedis j = getShard(key);
     return j.zrem(key, members);
   }
 
   @Override
-  public Double zincrby(String key, double score, String member) {
+  public Double zincrby(final String key, final double score, final String member) {
     Jedis j = getShard(key);
     return j.zincrby(key, score, member);
   }
 
   @Override
-  public Double zincrby(String key, double score, String member, ZIncrByParams params) {
+  public Double zincrby(final String key, final double score, final String member, ZIncrByParams params) {
     Jedis j = getShard(key);
     return j.zincrby(key, score, member, params);
   }
 
   @Override
-  public Long zrank(String key, String member) {
+  public Long zrank(final String key, final String member) {
     Jedis j = getShard(key);
     return j.zrank(key, member);
   }
 
   @Override
-  public Long zrevrank(String key, String member) {
+  public Long zrevrank(final String key, final String member) {
     Jedis j = getShard(key);
     return j.zrevrank(key, member);
   }
 
   @Override
-  public Set<String> zrevrange(String key, long start, long end) {
+  public Set<String> zrevrange(final String key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zrevrange(key, start, end);
   }
 
   @Override
-  public Set<Tuple> zrangeWithScores(String key, long start, long end) {
+  public Set<Tuple> zrangeWithScores(final String key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zrangeWithScores(key, start, end);
   }
 
   @Override
-  public Set<Tuple> zrevrangeWithScores(String key, long start, long end) {
+  public Set<Tuple> zrevrangeWithScores(final String key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zrevrangeWithScores(key, start, end);
   }
 
   @Override
-  public Long zcard(String key) {
+  public Long zcard(final String key) {
     Jedis j = getShard(key);
     return j.zcard(key);
   }
 
   @Override
-  public Double zscore(String key, String member) {
+  public Double zscore(final String key, final String member) {
     Jedis j = getShard(key);
     return j.zscore(key, member);
   }
 
   @Override
-  public List<String> sort(String key) {
+  public List<String> sort(final String key) {
     Jedis j = getShard(key);
     return j.sort(key);
   }
 
   @Override
-  public List<String> sort(String key, SortingParams sortingParameters) {
+  public List<String> sort(final String key, final SortingParams sortingParameters) {
     Jedis j = getShard(key);
     return j.sort(key, sortingParameters);
   }
 
   @Override
-  public Long zcount(String key, double min, double max) {
+  public Long zcount(final String key, final double min, final double max) {
     Jedis j = getShard(key);
     return j.zcount(key, min, max);
   }
 
   @Override
-  public Long zcount(String key, String min, String max) {
+  public Long zcount(final String key, final String min, final String max) {
     Jedis j = getShard(key);
     return j.zcount(key, min, max);
   }
 
   @Override
-  public Set<String> zrangeByScore(String key, double min, double max) {
+  public Set<String> zrangeByScore(final String key, final double min, final double max) {
     Jedis j = getShard(key);
     return j.zrangeByScore(key, min, max);
   }
 
   @Override
-  public Set<String> zrevrangeByScore(String key, double max, double min) {
+  public Set<String> zrevrangeByScore(final String key, final double max, final double min) {
     Jedis j = getShard(key);
     return j.zrevrangeByScore(key, max, min);
   }
 
   @Override
-  public Set<String> zrangeByScore(String key, double min, double max, int offset, int count) {
+  public Set<String> zrangeByScore(final String key, final double min, final double max, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrangeByScore(key, min, max, offset, count);
   }
 
   @Override
-  public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
+  public Set<String> zrevrangeByScore(final String key, final double max, final double min, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByScore(key, max, min, offset, count);
   }
 
   @Override
-  public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
+  public Set<Tuple> zrangeByScoreWithScores(final String key, final double min, final double max) {
     Jedis j = getShard(key);
     return j.zrangeByScoreWithScores(key, min, max);
   }
 
   @Override
-  public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
+  public Set<Tuple> zrevrangeByScoreWithScores(final String key, final double max, final double min) {
     Jedis j = getShard(key);
     return j.zrevrangeByScoreWithScores(key, max, min);
   }
 
   @Override
-  public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset,
-      int count) {
+  public Set<Tuple> zrangeByScoreWithScores(final String key, final double min, final double max, final int offset,
+      final int count) {
     Jedis j = getShard(key);
     return j.zrangeByScoreWithScores(key, min, max, offset, count);
   }
 
   @Override
-  public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset,
-      int count) {
+  public Set<Tuple> zrevrangeByScoreWithScores(final String key, final double max, final double min, final int offset,
+      final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
   }
 
   @Override
-  public Set<String> zrangeByScore(String key, String min, String max) {
+  public Set<String> zrangeByScore(final String key, final String min, final String max) {
     Jedis j = getShard(key);
     return j.zrangeByScore(key, min, max);
   }
 
   @Override
-  public Set<String> zrevrangeByScore(String key, String max, String min) {
+  public Set<String> zrevrangeByScore(final String key, final String max, final String min) {
     Jedis j = getShard(key);
     return j.zrevrangeByScore(key, max, min);
   }
 
   @Override
-  public Set<String> zrangeByScore(String key, String min, String max, int offset, int count) {
+  public Set<String> zrangeByScore(final String key, final String min, final String max, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrangeByScore(key, min, max, offset, count);
   }
 
   @Override
-  public Set<String> zrevrangeByScore(String key, String max, String min, int offset, int count) {
+  public Set<String> zrevrangeByScore(final String key, final String max, final String min, final int offset, final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByScore(key, max, min, offset, count);
   }
 
   @Override
-  public Set<Tuple> zrangeByScoreWithScores(String key, String min, String max) {
+  public Set<Tuple> zrangeByScoreWithScores(final String key, final String min, final String max) {
     Jedis j = getShard(key);
     return j.zrangeByScoreWithScores(key, min, max);
   }
 
   @Override
-  public Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min) {
+  public Set<Tuple> zrevrangeByScoreWithScores(final String key, final String max, final String min) {
     Jedis j = getShard(key);
     return j.zrevrangeByScoreWithScores(key, max, min);
   }
 
   @Override
-  public Set<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset,
-      int count) {
+  public Set<Tuple> zrangeByScoreWithScores(final String key, final String min, final String max, final int offset,
+      final int count) {
     Jedis j = getShard(key);
     return j.zrangeByScoreWithScores(key, min, max, offset, count);
   }
 
   @Override
-  public Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset,
-      int count) {
+  public Set<Tuple> zrevrangeByScoreWithScores(final String key, final String max, final String min, final int offset,
+      final int count) {
     Jedis j = getShard(key);
     return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
   }
 
   @Override
-  public Long zremrangeByRank(String key, long start, long end) {
+  public Long zremrangeByRank(final String key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.zremrangeByRank(key, start, end);
   }
 
   @Override
-  public Long zremrangeByScore(String key, double start, double end) {
+  public Long zremrangeByScore(final String key, final double start, final double end) {
     Jedis j = getShard(key);
     return j.zremrangeByScore(key, start, end);
   }
 
   @Override
-  public Long zremrangeByScore(String key, String start, String end) {
+  public Long zremrangeByScore(final String key, final String start, final String end) {
     Jedis j = getShard(key);
     return j.zremrangeByScore(key, start, end);
   }
@@ -708,12 +708,12 @@ public Set<String> zrangeByLex(final String key, final String min, final String
   }
 
   @Override
-  public Set<String> zrevrangeByLex(String key, String max, String min) {
+  public Set<String> zrevrangeByLex(final String key, final String max, final String min) {
     return getShard(key).zrevrangeByLex(key, max, min);
   }
 
   @Override
-  public Set<String> zrevrangeByLex(String key, String max, String min, int offset, int count) {
+  public Set<String> zrevrangeByLex(final String key, final String max, final String min, final int offset, final int count) {
     return getShard(key).zrevrangeByLex(key, max, min, offset, count);
   }
 
@@ -723,7 +723,7 @@ public Long zremrangeByLex(final String key, final String min, final String max)
   }
 
   @Override
-  public Long linsert(String key, LIST_POSITION where, String pivot, String value) {
+  public Long linsert(final String key, final LIST_POSITION where, final String pivot, final String value) {
     Jedis j = getShard(key);
     return j.linsert(key, where, pivot, value);
   }
@@ -735,55 +735,55 @@ public Long bitcount(final String key) {
   }
 
   @Override
-  public Long bitcount(final String key, long start, long end) {
+  public Long bitcount(final String key, final long start, final long end) {
     Jedis j = getShard(key);
     return j.bitcount(key, start, end);
   }
 
   @Override
-  public Long bitpos(String key, boolean value) {
+  public Long bitpos(final String key, final boolean value) {
     Jedis j = getShard(key);
     return j.bitpos(key, value);
   }
 
   @Override
-  public Long bitpos(String key, boolean value, BitPosParams params) {
+  public Long bitpos(final String key, boolean value, final BitPosParams params) {
     Jedis j = getShard(key);
     return j.bitpos(key, value, params);
   }
 
   @Override
-  public ScanResult<Entry<String, String>> hscan(String key, final String cursor) {
+  public ScanResult<Entry<String, String>> hscan(final String key, final String cursor) {
     Jedis j = getShard(key);
     return j.hscan(key, cursor);
   }
 
   @Override
-  public ScanResult<Entry<String, String>> hscan(String key, String cursor, ScanParams params) {
+  public ScanResult<Entry<String, String>> hscan(final String key, final String cursor, final ScanParams params) {
     Jedis j = getShard(key);
     return j.hscan(key, cursor, params);
   }
 
   @Override
-  public ScanResult<String> sscan(String key, final String cursor) {
+  public ScanResult<String> sscan(final String key, final String cursor) {
     Jedis j = getShard(key);
     return j.sscan(key, cursor);
   }
 
   @Override
-  public ScanResult<Tuple> zscan(String key, final String cursor) {
+  public ScanResult<Tuple> zscan(final String key, final String cursor) {
     Jedis j = getShard(key);
     return j.zscan(key, cursor);
   }
 
   @Override
-  public ScanResult<Tuple> zscan(String key, String cursor, ScanParams params) {
+  public ScanResult<Tuple> zscan(final String key, final String cursor, final ScanParams params) {
     Jedis j = getShard(key);
     return j.zscan(key, cursor, params);
   }
 
   @Override
-  public ScanResult<String> sscan(String key, String cursor, ScanParams params) {
+  public ScanResult<String> sscan(final String key, final String cursor, final ScanParams params) {
     Jedis j = getShard(key);
     return j.sscan(key, cursor, params);
   }
@@ -822,95 +822,95 @@ public void resetState() {
   }
 
   @Override
-  public Long pfadd(String key, String... elements) {
+  public Long pfadd(final String key, final String... elements) {
     Jedis j = getShard(key);
     return j.pfadd(key, elements);
   }
 
   @Override
-  public long pfcount(String key) {
+  public long pfcount(final String key) {
     Jedis j = getShard(key);
     return j.pfcount(key);
   }
 
   @Override
-  public Long touch(String key) {
+  public Long touch(final String key) {
     Jedis j = getShard(key);
     return j.touch(key);
   }
 
   @Override
-  public Long geoadd(String key, double longitude, double latitude, String member) {
+  public Long geoadd(final String key, final double longitude, final double latitude, final String member) {
     Jedis j = getShard(key);
     return j.geoadd(key, longitude, latitude, member);
   }
 
   @Override
-  public Long geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap) {
+  public Long geoadd(final String key, final Map<String, GeoCoordinate> memberCoordinateMap) {
     Jedis j = getShard(key);
     return j.geoadd(key, memberCoordinateMap);
   }
 
   @Override
-  public Double geodist(String key, String member1, String member2) {
+  public Double geodist(final String key, final String member1, final String member2) {
     Jedis j = getShard(key);
     return j.geodist(key, member1, member2);
   }
 
   @Override
-  public Double geodist(String key, String member1, String member2, GeoUnit unit) {
+  public Double geodist(final String key, final String member1, final String member2, final GeoUnit unit) {
     Jedis j = getShard(key);
     return j.geodist(key, member1, member2, unit);
   }
 
   @Override
-  public List<String> geohash(String key, String... members) {
+  public List<String> geohash(final String key, final String... members) {
     Jedis j = getShard(key);
     return j.geohash(key, members);
   }
 
   @Override
-  public List<GeoCoordinate> geopos(String key, String... members) {
+  public List<GeoCoordinate> geopos(final String key, final String... members) {
     Jedis j = getShard(key);
     return j.geopos(key, members);
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude,
-      double radius, GeoUnit unit) {
+  public List<GeoRadiusResponse> georadius(final String key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit) {
     Jedis j = getShard(key);
     return j.georadius(key, longitude, latitude, radius, unit);
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude,
-      double radius, GeoUnit unit, GeoRadiusParam param) {
+  public List<GeoRadiusResponse> georadius(final String key, final double longitude, final double latitude,
+      final double radius, final GeoUnit unit, final GeoRadiusParam param) {
     Jedis j = getShard(key);
     return j.georadius(key, longitude, latitude, radius, unit, param);
   }
 
   @Override
-  public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius,
-      GeoUnit unit) {
+  public List<GeoRadiusResponse> georadiusByMember(final String key, final String member, final double radius,
+      final GeoUnit unit) {
     Jedis j = getShard(key);
     return j.georadiusByMember(key, member, radius, unit);
   }
 
   @Override
-  public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius,
-      GeoUnit unit, GeoRadiusParam param) {
+  public List<GeoRadiusResponse> georadiusByMember(final String key, final String member, final double radius,
+      final GeoUnit unit, final GeoRadiusParam param) {
     Jedis j = getShard(key);
     return j.georadiusByMember(key, member, radius, unit, param);
   }
 
   @Override
-  public List<Long> bitfield(String key, String... arguments) {
+  public List<Long> bitfield(final String key, final String... arguments) {
     Jedis j = getShard(key);
     return j.bitfield(key, arguments);
   }
 
   @Override
-  public Long hstrlen(String key, String field) {
+  public Long hstrlen(final String key, final String field) {
     Jedis j = getShard(key);
     return j.hstrlen(key, field);
   }