diff --git a/src/main/java/redis/clients/jedis/BinaryClient.java b/src/main/java/redis/clients/jedis/BinaryClient.java
index e52c2ca128..f73fd3cff0 100644
--- a/src/main/java/redis/clients/jedis/BinaryClient.java
+++ b/src/main/java/redis/clients/jedis/BinaryClient.java
@@ -14,7 +14,6 @@
 import static redis.clients.jedis.Protocol.Keyword.WITHSCORES;
 import static redis.clients.jedis.Protocol.Keyword.FREQ;
 import static redis.clients.jedis.Protocol.Keyword.HELP;
-import static redis.clients.jedis.Protocol.Keyword.COUNT;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -390,7 +389,7 @@ public void lpos(final byte[] key, final byte[] element, LPosParams params) {
   }
 
   public void lpos(final byte[] key, final byte[] element, final LPosParams params, final long count){
-    sendCommand(LPOS, joinParameters(key, element, params.getByteParams(Keyword.COUNT.raw, toByteArray(count))));
+    sendCommand(LPOS, joinParameters(key, element, params.getByteParams(Keyword.COUNT.getRaw(), toByteArray(count))));
   }
 
   public void rpop(final byte[] key) {
@@ -528,11 +527,11 @@ public void zrevrange(final byte[] key, final long start, final long stop) {
   }
 
   public void zrangeWithScores(final byte[] key, final long start, final long stop) {
-    sendCommand(ZRANGE, key, toByteArray(start), toByteArray(stop), WITHSCORES.raw);
+    sendCommand(ZRANGE, key, toByteArray(start), toByteArray(stop), WITHSCORES.getRaw());
   }
 
   public void zrevrangeWithScores(final byte[] key, final long start, final long stop) {
-    sendCommand(ZREVRANGE, key, toByteArray(start), toByteArray(stop), WITHSCORES.raw);
+    sendCommand(ZREVRANGE, key, toByteArray(start), toByteArray(stop), WITHSCORES.getRaw());
   }
 
   public void zcard(final byte[] key) {
@@ -617,13 +616,13 @@ public void sort(final byte[] key, final SortingParams sortingParameters, final
     final List<byte[]> args = new ArrayList<>();
     args.add(key);
     args.addAll(sortingParameters.getParams());
-    args.add(STORE.raw);
+    args.add(STORE.getRaw());
     args.add(dstkey);
     sendCommand(SORT, args.toArray(new byte[args.size()][]));
   }
 
   public void sort(final byte[] key, final byte[] dstkey) {
-    sendCommand(SORT, key, STORE.raw, dstkey);
+    sendCommand(SORT, key, STORE.getRaw(), dstkey);
   }
 
   public void brpop(final byte[][] args) {
@@ -707,64 +706,64 @@ public void zrevrangeByScore(final byte[] key, final byte[] max, final byte[] mi
 
   public void zrangeByScore(final byte[] key, final double min, final double max, final int offset,
       final int count) {
-    sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max), LIMIT.raw, toByteArray(offset),
+    sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max), LIMIT.getRaw(), toByteArray(offset),
       toByteArray(count));
   }
 
   public void zrevrangeByScore(final byte[] key, final double max, final double min,
       final int offset, final int count) {
-    sendCommand(ZREVRANGEBYSCORE, key, toByteArray(max), toByteArray(min), LIMIT.raw, toByteArray(offset),
+    sendCommand(ZREVRANGEBYSCORE, key, toByteArray(max), toByteArray(min), LIMIT.getRaw(), toByteArray(offset),
       toByteArray(count));
   }
 
   public void zrangeByScoreWithScores(final byte[] key, final double min, final double max) {
-    sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max), WITHSCORES.raw);
+    sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max), WITHSCORES.getRaw());
   }
 
   public void zrevrangeByScoreWithScores(final byte[] key, final double max, final double min) {
-    sendCommand(ZREVRANGEBYSCORE, key, toByteArray(max), toByteArray(min), WITHSCORES.raw);
+    sendCommand(ZREVRANGEBYSCORE, key, toByteArray(max), toByteArray(min), WITHSCORES.getRaw());
   }
 
   public void zrangeByScoreWithScores(final byte[] key, final double min, final double max,
       final int offset, final int count) {
-    sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max), LIMIT.raw, toByteArray(offset),
-      toByteArray(count), WITHSCORES.raw);
+    sendCommand(ZRANGEBYSCORE, key, toByteArray(min), toByteArray(max), LIMIT.getRaw(), toByteArray(offset),
+      toByteArray(count), WITHSCORES.getRaw());
   }
 
   public void zrevrangeByScoreWithScores(final byte[] key, final double max, final double min,
       final int offset, final int count) {
-    sendCommand(ZREVRANGEBYSCORE, key, toByteArray(max), toByteArray(min), LIMIT.raw, toByteArray(offset),
-      toByteArray(count), WITHSCORES.raw);
+    sendCommand(ZREVRANGEBYSCORE, key, toByteArray(max), toByteArray(min), LIMIT.getRaw(), toByteArray(offset),
+      toByteArray(count), WITHSCORES.getRaw());
   }
 
   public void zrangeByScore(final byte[] key, final byte[] min, final byte[] max, final int offset,
       final int count) {
-    sendCommand(ZRANGEBYSCORE, key, min, max, LIMIT.raw, toByteArray(offset), toByteArray(count));
+    sendCommand(ZRANGEBYSCORE, key, min, max, LIMIT.getRaw(), toByteArray(offset), toByteArray(count));
   }
 
   public void zrevrangeByScore(final byte[] key, final byte[] max, final byte[] min,
       final int offset, final int count) {
-    sendCommand(ZREVRANGEBYSCORE, key, max, min, LIMIT.raw, toByteArray(offset), toByteArray(count));
+    sendCommand(ZREVRANGEBYSCORE, key, max, min, LIMIT.getRaw(), toByteArray(offset), toByteArray(count));
   }
 
   public void zrangeByScoreWithScores(final byte[] key, final byte[] min, final byte[] max) {
-    sendCommand(ZRANGEBYSCORE, key, min, max, WITHSCORES.raw);
+    sendCommand(ZRANGEBYSCORE, key, min, max, WITHSCORES.getRaw());
   }
 
   public void zrevrangeByScoreWithScores(final byte[] key, final byte[] max, final byte[] min) {
-    sendCommand(ZREVRANGEBYSCORE, key, max, min, WITHSCORES.raw);
+    sendCommand(ZREVRANGEBYSCORE, key, max, min, WITHSCORES.getRaw());
   }
 
   public void zrangeByScoreWithScores(final byte[] key, final byte[] min, final byte[] max,
       final int offset, final int count) {
-    sendCommand(ZRANGEBYSCORE, key, min, max, LIMIT.raw, toByteArray(offset), toByteArray(count),
-      WITHSCORES.raw);
+    sendCommand(ZRANGEBYSCORE, key, min, max, LIMIT.getRaw(), toByteArray(offset), toByteArray(count),
+      WITHSCORES.getRaw());
   }
 
   public void zrevrangeByScoreWithScores(final byte[] key, final byte[] max, final byte[] min,
       final int offset, final int count) {
-    sendCommand(ZREVRANGEBYSCORE, key, max, min, LIMIT.raw, toByteArray(offset),
-      toByteArray(count), WITHSCORES.raw);
+    sendCommand(ZREVRANGEBYSCORE, key, max, min, LIMIT.getRaw(), toByteArray(offset),
+      toByteArray(count), WITHSCORES.getRaw());
   }
 
   public void zremrangeByRank(final byte[] key, final long start, final long stop) {
@@ -817,7 +816,7 @@ public void zrangeByLex(final byte[] key, final byte[] min, final byte[] max) {
 
   public void zrangeByLex(final byte[] key, final byte[] min, final byte[] max, final int offset,
       final int count) {
-    sendCommand(ZRANGEBYLEX, key, min, max, LIMIT.raw, toByteArray(offset), toByteArray(count));
+    sendCommand(ZRANGEBYLEX, key, min, max, LIMIT.getRaw(), toByteArray(offset), toByteArray(count));
   }
 
   public void zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min) {
@@ -826,7 +825,7 @@ public void zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min)
 
   public void zrevrangeByLex(final byte[] key, final byte[] max, final byte[] min,
       final int offset, final int count) {
-    sendCommand(ZREVRANGEBYLEX, key, max, min, LIMIT.raw, toByteArray(offset), toByteArray(count));
+    sendCommand(ZREVRANGEBYLEX, key, max, min, LIMIT.getRaw(), toByteArray(offset), toByteArray(count));
   }
 
   public void zremrangeByLex(final byte[] key, final byte[] min, final byte[] max) {
@@ -870,15 +869,15 @@ public void slaveof(final String host, final int port) {
   }
 
   public void slaveofNoOne() {
-    sendCommand(SLAVEOF, NO.raw, ONE.raw);
+    sendCommand(SLAVEOF, NO.getRaw(), ONE.getRaw());
   }
 
   public void configGet(final byte[] pattern) {
-    sendCommand(CONFIG, Keyword.GET.raw, pattern);
+    sendCommand(CONFIG, Keyword.GET.getRaw(), pattern);
   }
 
   public void configSet(final byte[] parameter, final byte[] value) {
-    sendCommand(CONFIG, Keyword.SET.raw, parameter, value);
+    sendCommand(CONFIG, Keyword.SET.getRaw(), parameter, value);
   }
 
   public void strlen(final byte[] key) {
@@ -919,11 +918,11 @@ public void brpoplpush(final byte[] source, final byte[] destination, final int
   }
 
   public void configResetStat() {
-    sendCommand(CONFIG, Keyword.RESETSTAT.raw);
+    sendCommand(CONFIG, Keyword.RESETSTAT.getRaw());
   }
 
   public void configRewrite() {
-    sendCommand(CONFIG, Keyword.REWRITE.raw);
+    sendCommand(CONFIG, Keyword.REWRITE.getRaw());
   }
 
   public void setbit(final byte[] key, final long offset, final byte[] value) {
@@ -994,55 +993,55 @@ public void evalsha(final byte[] sha1, final int keyCount, final byte[]... param
   }
 
   public void scriptFlush() {
-    sendCommand(SCRIPT, Keyword.FLUSH.raw);
+    sendCommand(SCRIPT, Keyword.FLUSH.getRaw());
   }
 
   public void scriptExists(final byte[]... sha1) {
-    sendCommand(SCRIPT, joinParameters(Keyword.EXISTS.raw, sha1));
+    sendCommand(SCRIPT, joinParameters(Keyword.EXISTS.getRaw(), sha1));
   }
 
   public void scriptLoad(final byte[] script) {
-    sendCommand(SCRIPT, Keyword.LOAD.raw, script);
+    sendCommand(SCRIPT, Keyword.LOAD.getRaw(), script);
   }
 
   public void scriptKill() {
-    sendCommand(SCRIPT, Keyword.KILL.raw);
+    sendCommand(SCRIPT, Keyword.KILL.getRaw());
   }
 
   public void slowlogGet() {
-    sendCommand(SLOWLOG, Keyword.GET.raw);
+    sendCommand(SLOWLOG, Keyword.GET.getRaw());
   }
 
   public void slowlogGet(final long entries) {
-    sendCommand(SLOWLOG, Keyword.GET.raw, toByteArray(entries));
+    sendCommand(SLOWLOG, Keyword.GET.getRaw(), toByteArray(entries));
   }
 
   public void slowlogReset() {
-    sendCommand(SLOWLOG, RESET.raw);
+    sendCommand(SLOWLOG, RESET.getRaw());
   }
 
   public void slowlogLen() {
-    sendCommand(SLOWLOG, LEN.raw);
+    sendCommand(SLOWLOG, LEN.getRaw());
   }
 
   public void objectRefcount(final byte[] key) {
-    sendCommand(OBJECT, REFCOUNT.raw, key);
+    sendCommand(OBJECT, REFCOUNT.getRaw(), key);
   }
 
   public void objectIdletime(final byte[] key) {
-    sendCommand(OBJECT, IDLETIME.raw, key);
+    sendCommand(OBJECT, IDLETIME.getRaw(), key);
   }
 
   public void objectEncoding(final byte[] key) {
-    sendCommand(OBJECT, ENCODING.raw, key);
+    sendCommand(OBJECT, ENCODING.getRaw(), key);
   }
 
   public void objectHelp() {
-    sendCommand(OBJECT, HELP.raw);
+    sendCommand(OBJECT, HELP.getRaw());
   }
 
   public void objectFreq(final byte[] key) {
-    sendCommand(OBJECT, FREQ.raw, key);
+    sendCommand(OBJECT, FREQ.getRaw(), key);
   }
 
   public void bitcount(final byte[] key) {
@@ -1070,7 +1069,7 @@ public void restore(final byte[] key, final int ttl, final byte[] serializedValu
   }
 
   public void restoreReplace(final byte[] key, final int ttl, final byte[] serializedValue) {
-    sendCommand(RESTORE, key, toByteArray(ttl), serializedValue, Keyword.REPLACE.raw);
+    sendCommand(RESTORE, key, toByteArray(ttl), serializedValue, Keyword.REPLACE.getRaw());
   }
 
   public void pexpire(final byte[] key, final long milliseconds) {
@@ -1094,19 +1093,19 @@ public void srandmember(final byte[] key, final int count) {
   }
 
   public void memoryDoctor() {
-    sendCommand(MEMORY, Keyword.DOCTOR.raw);
+    sendCommand(MEMORY, Keyword.DOCTOR.getRaw());
   }
   
   public void memoryUsage(final byte[] key) {
-    sendCommand(MEMORY, Keyword.USAGE.raw, key);
+    sendCommand(MEMORY, Keyword.USAGE.getRaw(), key);
   }
   
   public void memoryUsage(final byte[] key, final int samples) {
-    sendCommand(MEMORY, Keyword.USAGE.raw, key, Keyword.SAMPLES.raw, toByteArray(samples));
+    sendCommand(MEMORY, Keyword.USAGE.getRaw(), key, Keyword.SAMPLES.getRaw(), toByteArray(samples));
   }
 
   public void clientKill(final byte[] ipPort) {
-    sendCommand(CLIENT, Keyword.KILL.raw, ipPort);
+    sendCommand(CLIENT, Keyword.KILL.getRaw(), ipPort);
   }
 
   public void clientKill(final String ip, final int port) {
@@ -1114,27 +1113,27 @@ public void clientKill(final String ip, final int port) {
   }
 
   public void clientKill(ClientKillParams params) {
-    sendCommand(CLIENT, joinParameters(Keyword.KILL.raw, params.getByteParams()));
+    sendCommand(CLIENT, joinParameters(Keyword.KILL.getRaw(), params.getByteParams()));
   }
 
   public void clientGetname() {
-    sendCommand(CLIENT, Keyword.GETNAME.raw);
+    sendCommand(CLIENT, Keyword.GETNAME.getRaw());
   }
 
   public void clientList() {
-    sendCommand(CLIENT, Keyword.LIST.raw);
+    sendCommand(CLIENT, Keyword.LIST.getRaw());
   }
 
   public void clientSetname(final byte[] name) {
-    sendCommand(CLIENT, Keyword.SETNAME.raw, name);
+    sendCommand(CLIENT, Keyword.SETNAME.getRaw(), name);
   }
 
   public void clientPause(final long timeout) {
-    sendCommand(CLIENT, Keyword.PAUSE.raw, toByteArray(timeout));
+    sendCommand(CLIENT, Keyword.PAUSE.getRaw(), toByteArray(timeout));
   }
 
   public void clientId() {
-    sendCommand(CLIENT, Keyword.ID.raw);
+    sendCommand(CLIENT, Keyword.ID.getRaw());
   }
 
   public void time() {
@@ -1160,7 +1159,7 @@ public void migrate(final String host, final int port, final int destinationDB,
     args[i++] = toByteArray(timeout);
     System.arraycopy(bparams, 0, args, i, bparams.length);
     i += bparams.length;
-    args[i++] = Keyword.KEYS.raw;
+    args[i++] = Keyword.KEYS.getRaw();
     System.arraycopy(keys, 0, args, i, keys.length);
     sendCommand(MIGRATE, args);
   }
@@ -1316,15 +1315,15 @@ public void georadiusByMemberReadonly(final byte[] key, final byte[] member, fin
   }
 
   public void moduleLoad(final byte[] path) {
-    sendCommand(MODULE, Keyword.LOAD.raw, path);
+    sendCommand(MODULE, Keyword.LOAD.getRaw(), path);
   }
 
   public void moduleList() {
-    sendCommand(MODULE, Keyword.LIST.raw);
+    sendCommand(MODULE, Keyword.LIST.getRaw());
   }
 
   public void moduleUnload(final byte[] name) {
-    sendCommand(MODULE, Keyword.UNLOAD.raw, name);
+    sendCommand(MODULE, Keyword.UNLOAD.getRaw(), name);
   }
 
   private ArrayList<byte[]> convertScoreMembersToByteArrays(final Map<byte[], Double> scoreMembers) {
@@ -1338,46 +1337,46 @@ private ArrayList<byte[]> convertScoreMembersToByteArrays(final Map<byte[], Doub
     return args;
   }
 
-  public void aclWhoAmI() { sendCommand(ACL, Keyword.WHOAMI.raw); }
+  public void aclWhoAmI() { sendCommand(ACL, Keyword.WHOAMI.getRaw()); }
 
-  public void aclGenPass() { sendCommand(ACL, Keyword.GENPASS.raw); }
+  public void aclGenPass() { sendCommand(ACL, Keyword.GENPASS.getRaw()); }
 
-  public void aclList() { sendCommand(ACL, Keyword.LIST.raw); }
+  public void aclList() { sendCommand(ACL, Keyword.LIST.getRaw()); }
 
-  public void aclUsers() { sendCommand(ACL, Keyword.USERS.raw); }
+  public void aclUsers() { sendCommand(ACL, Keyword.USERS.getRaw()); }
 
-  public void aclCat() { sendCommand(ACL, Keyword.CAT.raw); }
+  public void aclCat() { sendCommand(ACL, Keyword.CAT.getRaw()); }
 
   public void aclCat(final byte[] category) {
-    sendCommand(ACL, Keyword.CAT.raw, category);
+    sendCommand(ACL, Keyword.CAT.getRaw(), category);
   }
 
   public void aclLog() {
-    sendCommand(ACL, Keyword.LOG.raw);
+    sendCommand(ACL, Keyword.LOG.getRaw());
   }
 
   public void aclLog(int limit) {
-    sendCommand(ACL, Keyword.LOG.raw, toByteArray(limit));
+    sendCommand(ACL, Keyword.LOG.getRaw(), toByteArray(limit));
   }
 
   public void aclLog(final byte[] option) {
-    sendCommand(ACL, Keyword.LOG.raw, option);
+    sendCommand(ACL, Keyword.LOG.getRaw(), option);
   }
 
   public void aclSetUser(final byte[] name) {
-    sendCommand(ACL, Keyword.SETUSER.raw, name);
+    sendCommand(ACL, Keyword.SETUSER.getRaw(), name);
   }
 
   public void aclGetUser(final byte[] name) {
-    sendCommand(ACL, Keyword.GETUSER.raw, name);
+    sendCommand(ACL, Keyword.GETUSER.getRaw(), name);
   }
 
   public void aclSetUser(final byte[] name, byte[][] parameters) {
-    sendCommand(ACL, joinParameters(Keyword.SETUSER.raw,name, parameters));
+    sendCommand(ACL, joinParameters(Keyword.SETUSER.getRaw(),name, parameters));
   }
 
   public void aclDelUser(final byte[] name) {
-    sendCommand(ACL, Keyword.DELUSER.raw, name);
+    sendCommand(ACL, Keyword.DELUSER.getRaw(), name);
   }
 
   private List<byte[]> convertGeoCoordinateMapToByteArrays(
@@ -1420,7 +1419,7 @@ public void xadd(final byte[] key, final byte[] id, final Map<byte[], byte[]> ha
 	  int index = 0;
 	  params[index++] = key;
 	  if(maxLen < Long.MAX_VALUE) {
-	    params[index++] = Keyword.MAXLEN.raw;
+	    params[index++] = Keyword.MAXLEN.getRaw();
 	    if(approximateLength) {
 	      params[index++] = Protocol.BYTES_TILDE;
 	    }
@@ -1440,25 +1439,25 @@ public void xlen(final byte[] key) {
   }
   
   public void xrange(final byte[] key, final byte[] start, final byte[] end, final long count) { 
-     sendCommand(XRANGE, key, start, end, Keyword.COUNT.raw, toByteArray(count));
+     sendCommand(XRANGE, key, start, end, Keyword.COUNT.getRaw(), toByteArray(count));
   }
   
   public void xrevrange(final byte[] key, final byte[] end, final byte[] start, final int count) {
-    sendCommand(XREVRANGE, key, end, start, Keyword.COUNT.raw, toByteArray(count));
+    sendCommand(XREVRANGE, key, end, start, Keyword.COUNT.getRaw(), toByteArray(count));
   }
 
   public void xread(final int count, final long block, final Map<byte[], byte[]> streams) {
     final byte[][] params = new byte[3 + streams.size() * 2 + (block > 0 ? 2 : 0)][];
 
     int streamsIndex = 0;
-    params[streamsIndex++] = Keyword.COUNT.raw;
+    params[streamsIndex++] = Keyword.COUNT.getRaw();
     params[streamsIndex++] = toByteArray(count);
     if(block > 0) {
-      params[streamsIndex++] = Keyword.BLOCK.raw;
+      params[streamsIndex++] = Keyword.BLOCK.getRaw();
       params[streamsIndex++] = toByteArray(block);
     }
     
-    params[streamsIndex++] = Keyword.STREAMS.raw;
+    params[streamsIndex++] = Keyword.STREAMS.getRaw();
     int idsIndex = streamsIndex + streams.size();
 
     for (final Entry<byte[], byte[]> entry : streams.entrySet()) {
@@ -1482,22 +1481,22 @@ public void xack(final byte[] key, final byte[] group, final byte[]... ids) {
    
   public void xgroupCreate(final byte[] key, final byte[] groupname, final byte[] id, boolean makeStream) {
     if(makeStream) {
-      sendCommand(XGROUP, Keyword.CREATE.raw, key, groupname, id, Keyword.MKSTREAM.raw);  
+      sendCommand(XGROUP, Keyword.CREATE.getRaw(), key, groupname, id, Keyword.MKSTREAM.getRaw());  
     } else {
-      sendCommand(XGROUP, Keyword.CREATE.raw, key, groupname, id);  
+      sendCommand(XGROUP, Keyword.CREATE.getRaw(), key, groupname, id);  
     }
   }
 
   public void xgroupSetID(final byte[] key, final byte[] groupname, final byte[] id) {
-    sendCommand(XGROUP, Keyword.SETID.raw, key, groupname, id);    
+    sendCommand(XGROUP, Keyword.SETID.getRaw(), key, groupname, id);    
   }
 
   public void xgroupDestroy(final byte[] key, final byte[] groupname) {
-    sendCommand(XGROUP, Keyword.DESTROY.raw, key, groupname);    
+    sendCommand(XGROUP, Keyword.DESTROY.getRaw(), key, groupname);    
   }
 
   public void xgroupDelConsumer(final byte[] key, final byte[] groupname, final byte[] consumerName) {
-    sendCommand(XGROUP, Keyword.DELCONSUMER.raw, key, groupname, consumerName);    
+    sendCommand(XGROUP, Keyword.DELCONSUMER.getRaw(), key, groupname, consumerName);    
   }
    
   public void xdel(final byte[] key, final byte[]... ids) {
@@ -1512,9 +1511,9 @@ public void xdel(final byte[] key, final byte[]... ids) {
   
   public void xtrim(byte[] key, long maxLen, boolean approximateLength) {
     if(approximateLength) {
-      sendCommand(XTRIM, key, Keyword.MAXLEN.raw, Protocol.BYTES_TILDE ,toByteArray(maxLen));
+      sendCommand(XTRIM, key, Keyword.MAXLEN.getRaw(), Protocol.BYTES_TILDE ,toByteArray(maxLen));
     } else {
-      sendCommand(XTRIM, key, Keyword.MAXLEN.raw, toByteArray(maxLen));
+      sendCommand(XTRIM, key, Keyword.MAXLEN.getRaw(), toByteArray(maxLen));
     }
   }
   
@@ -1535,21 +1534,21 @@ public void xreadGroup(byte[] groupname, byte[] consumer, int count, long block,
     final byte[][] params = new byte[4 + optional + streams.size() * 2][];
 
     int streamsIndex = 0;
-    params[streamsIndex++] = Keyword.GROUP.raw;
+    params[streamsIndex++] = Keyword.GROUP.getRaw();
     params[streamsIndex++] = groupname;
     params[streamsIndex++] = consumer;
     if(count>0) {
-      params[streamsIndex++] = Keyword.COUNT.raw;
+      params[streamsIndex++] = Keyword.COUNT.getRaw();
       params[streamsIndex++] = toByteArray(count);
     }
     if(block > 0) {
-      params[streamsIndex++] = Keyword.BLOCK.raw;
+      params[streamsIndex++] = Keyword.BLOCK.getRaw();
       params[streamsIndex++] = toByteArray(block);
     }
     if(noAck) {
-      params[streamsIndex++] = Keyword.NOACK.raw;
+      params[streamsIndex++] = Keyword.NOACK.getRaw();
     }
-    params[streamsIndex++] = Keyword.STREAMS.raw;
+    params[streamsIndex++] = Keyword.STREAMS.getRaw();
     
     int idsIndex = streamsIndex + streams.size();
     for (final Entry<byte[], byte[]> entry : streams.entrySet()) {
@@ -1581,34 +1580,34 @@ public void xclaim(byte[] key, byte[] groupname, byte[] consumername, long minId
       Collections.addAll(arguments, ids);
 
       if(newIdleTime > 0) {
-        arguments.add(Keyword.IDLE.raw);
+        arguments.add(Keyword.IDLE.getRaw());
         arguments.add(toByteArray(newIdleTime));
       }
       if(retries > 0) {
-        arguments.add(Keyword.RETRYCOUNT.raw);
+        arguments.add(Keyword.RETRYCOUNT.getRaw());
         arguments.add(toByteArray(retries));        
       }
       if(force) {
-        arguments.add(Keyword.FORCE.raw);        
+        arguments.add(Keyword.FORCE.getRaw());        
       }
       sendCommand(XCLAIM, arguments.toArray(new byte[arguments.size()][]));
   }
 
   public void xinfoStream(byte[] key) {
 
-    sendCommand(XINFO,Keyword.STREAM.raw,key);
+    sendCommand(XINFO,Keyword.STREAM.getRaw(),key);
 
   }
 
   public void xinfoGroup(byte[] key) {
 
-    sendCommand(XINFO,Keyword.GROUPS.raw,key);
+    sendCommand(XINFO,Keyword.GROUPS.getRaw(),key);
 
   }
 
   public void xinfoConsumers (byte[] key, byte[] group) {
 
-    sendCommand(XINFO,Keyword.CONSUMERS.raw,key,group);
+    sendCommand(XINFO,Keyword.CONSUMERS.getRaw(),key,group);
   }
 
 }
diff --git a/src/main/java/redis/clients/jedis/BinaryJedisPubSub.java b/src/main/java/redis/clients/jedis/BinaryJedisPubSub.java
index 85316011a5..d0582a0d54 100644
--- a/src/main/java/redis/clients/jedis/BinaryJedisPubSub.java
+++ b/src/main/java/redis/clients/jedis/BinaryJedisPubSub.java
@@ -104,32 +104,32 @@ private void process(Client client) {
         throw new JedisException("Unknown message type: " + firstObj);
       }
       final byte[] resp = (byte[]) firstObj;
-      if (Arrays.equals(SUBSCRIBE.raw, resp)) {
+      if (Arrays.equals(SUBSCRIBE.getRaw(), resp)) {
         subscribedChannels = ((Long) reply.get(2)).intValue();
         final byte[] bchannel = (byte[]) reply.get(1);
         onSubscribe(bchannel, subscribedChannels);
-      } else if (Arrays.equals(UNSUBSCRIBE.raw, resp)) {
+      } else if (Arrays.equals(UNSUBSCRIBE.getRaw(), resp)) {
         subscribedChannels = ((Long) reply.get(2)).intValue();
         final byte[] bchannel = (byte[]) reply.get(1);
         onUnsubscribe(bchannel, subscribedChannels);
-      } else if (Arrays.equals(MESSAGE.raw, resp)) {
+      } else if (Arrays.equals(MESSAGE.getRaw(), resp)) {
         final byte[] bchannel = (byte[]) reply.get(1);
         final byte[] bmesg = (byte[]) reply.get(2);
         onMessage(bchannel, bmesg);
-      } else if (Arrays.equals(PMESSAGE.raw, resp)) {
+      } else if (Arrays.equals(PMESSAGE.getRaw(), resp)) {
         final byte[] bpattern = (byte[]) reply.get(1);
         final byte[] bchannel = (byte[]) reply.get(2);
         final byte[] bmesg = (byte[]) reply.get(3);
         onPMessage(bpattern, bchannel, bmesg);
-      } else if (Arrays.equals(PSUBSCRIBE.raw, resp)) {
+      } else if (Arrays.equals(PSUBSCRIBE.getRaw(), resp)) {
         subscribedChannels = ((Long) reply.get(2)).intValue();
         final byte[] bpattern = (byte[]) reply.get(1);
         onPSubscribe(bpattern, subscribedChannels);
-      } else if (Arrays.equals(PUNSUBSCRIBE.raw, resp)) {
+      } else if (Arrays.equals(PUNSUBSCRIBE.getRaw(), resp)) {
         subscribedChannels = ((Long) reply.get(2)).intValue();
         final byte[] bpattern = (byte[]) reply.get(1);
         onPUnsubscribe(bpattern, subscribedChannels);
-      } else if (Arrays.equals(PONG.raw, resp)) {
+      } else if (Arrays.equals(PONG.getRaw(), resp)) {
         final byte[] bpattern = (byte[]) reply.get(1);
         onPong(bpattern);
       } else {
diff --git a/src/main/java/redis/clients/jedis/BuilderFactory.java b/src/main/java/redis/clients/jedis/BuilderFactory.java
index 3242b1cbb1..23cc7b8aac 100644
--- a/src/main/java/redis/clients/jedis/BuilderFactory.java
+++ b/src/main/java/redis/clients/jedis/BuilderFactory.java
@@ -629,7 +629,6 @@ public String toString() {
 
   public static final Builder<StreamEntryID> STREAM_ENTRY_ID = new Builder<StreamEntryID>() {
     @Override
-    @SuppressWarnings("unchecked")
     public  StreamEntryID build(Object data) {
       if (null == data) {
         return null;
diff --git a/src/main/java/redis/clients/jedis/Jedis.java b/src/main/java/redis/clients/jedis/Jedis.java
index 14eb19b723..05d8b1c0ec 100644
--- a/src/main/java/redis/clients/jedis/Jedis.java
+++ b/src/main/java/redis/clients/jedis/Jedis.java
@@ -3121,7 +3121,7 @@ public List<Map<String, String>> sentinelMasters() {
 
     final List<Map<String, String>> masters = new ArrayList<>();
     for (Object obj : reply) {
-      masters.add(BuilderFactory.STRING_MAP.build((List) obj));
+      masters.add(BuilderFactory.STRING_MAP.build( obj));
     }
     return masters;
   }
@@ -3192,7 +3192,6 @@ public Long sentinelReset(final String pattern) {
    * @return
    */
   @Override
-  @SuppressWarnings("rawtypes")
   public List<Map<String, String>> sentinelSlaves(final String masterName) {
     client.sentinel(Protocol.SENTINEL_SLAVES, masterName);
     final List<Object> reply = client.getObjectMultiBulkReply();
diff --git a/src/main/java/redis/clients/jedis/JedisPubSub.java b/src/main/java/redis/clients/jedis/JedisPubSub.java
index 37ead9d070..c09563931a 100644
--- a/src/main/java/redis/clients/jedis/JedisPubSub.java
+++ b/src/main/java/redis/clients/jedis/JedisPubSub.java
@@ -134,23 +134,23 @@ private void process(Client client) {
         throw new JedisException("Unknown message type: " + firstObj);
       }
       final byte[] resp = (byte[]) firstObj;
-      if (Arrays.equals(SUBSCRIBE.raw, resp)) {
+      if (Arrays.equals(SUBSCRIBE.getRaw(), resp)) {
         subscribedChannels = ((Long) reply.get(2)).intValue();
         final byte[] bchannel = (byte[]) reply.get(1);
         final String strchannel = (bchannel == null) ? null : SafeEncoder.encode(bchannel);
         onSubscribe(strchannel, subscribedChannels);
-      } else if (Arrays.equals(UNSUBSCRIBE.raw, resp)) {
+      } else if (Arrays.equals(UNSUBSCRIBE.getRaw(), resp)) {
         subscribedChannels = ((Long) reply.get(2)).intValue();
         final byte[] bchannel = (byte[]) reply.get(1);
         final String strchannel = (bchannel == null) ? null : SafeEncoder.encode(bchannel);
         onUnsubscribe(strchannel, subscribedChannels);
-      } else if (Arrays.equals(MESSAGE.raw, resp)) {
+      } else if (Arrays.equals(MESSAGE.getRaw(), resp)) {
         final byte[] bchannel = (byte[]) reply.get(1);
         final byte[] bmesg = (byte[]) reply.get(2);
         final String strchannel = (bchannel == null) ? null : SafeEncoder.encode(bchannel);
         final String strmesg = (bmesg == null) ? null : SafeEncoder.encode(bmesg);
         onMessage(strchannel, strmesg);
-      } else if (Arrays.equals(PMESSAGE.raw, resp)) {
+      } else if (Arrays.equals(PMESSAGE.getRaw(), resp)) {
         final byte[] bpattern = (byte[]) reply.get(1);
         final byte[] bchannel = (byte[]) reply.get(2);
         final byte[] bmesg = (byte[]) reply.get(3);
@@ -158,17 +158,17 @@ private void process(Client client) {
         final String strchannel = (bchannel == null) ? null : SafeEncoder.encode(bchannel);
         final String strmesg = (bmesg == null) ? null : SafeEncoder.encode(bmesg);
         onPMessage(strpattern, strchannel, strmesg);
-      } else if (Arrays.equals(PSUBSCRIBE.raw, resp)) {
+      } else if (Arrays.equals(PSUBSCRIBE.getRaw(), resp)) {
         subscribedChannels = ((Long) reply.get(2)).intValue();
         final byte[] bpattern = (byte[]) reply.get(1);
         final String strpattern = (bpattern == null) ? null : SafeEncoder.encode(bpattern);
         onPSubscribe(strpattern, subscribedChannels);
-      } else if (Arrays.equals(PUNSUBSCRIBE.raw, resp)) {
+      } else if (Arrays.equals(PUNSUBSCRIBE.getRaw(), resp)) {
         subscribedChannels = ((Long) reply.get(2)).intValue();
         final byte[] bpattern = (byte[]) reply.get(1);
         final String strpattern = (bpattern == null) ? null : SafeEncoder.encode(bpattern);
         onPUnsubscribe(strpattern, subscribedChannels);
-      } else if (Arrays.equals(PONG.raw, resp)) {
+      } else if (Arrays.equals(PONG.getRaw(), resp)) {
         final byte[] bpattern = (byte[]) reply.get(1);
         final String strpattern = (bpattern == null) ? null : SafeEncoder.encode(bpattern);
         onPong(strpattern);
diff --git a/src/main/java/redis/clients/jedis/SortingParams.java b/src/main/java/redis/clients/jedis/SortingParams.java
index 4c17c06009..e7760d73a8 100644
--- a/src/main/java/redis/clients/jedis/SortingParams.java
+++ b/src/main/java/redis/clients/jedis/SortingParams.java
@@ -50,7 +50,7 @@ public SortingParams by(final String pattern) {
    * @return the SortingParams Object
    */
   public SortingParams by(final byte[] pattern) {
-    params.add(BY.raw);
+    params.add(BY.getRaw());
     params.add(pattern);
     return this;
   }
@@ -63,8 +63,8 @@ public SortingParams by(final byte[] pattern) {
    * @return the SortingParams Object
    */
   public SortingParams nosort() {
-    params.add(BY.raw);
-    params.add(NOSORT.raw);
+    params.add(BY.getRaw());
+    params.add(NOSORT.getRaw());
     return this;
   }
 
@@ -77,7 +77,7 @@ public Collection<byte[]> getParams() {
    * @return the sortingParams Object
    */
   public SortingParams desc() {
-    params.add(DESC.raw);
+    params.add(DESC.getRaw());
     return this;
   }
 
@@ -86,7 +86,7 @@ public SortingParams desc() {
    * @return the SortingParams Object
    */
   public SortingParams asc() {
-    params.add(ASC.raw);
+    params.add(ASC.getRaw());
     return this;
   }
 
@@ -97,7 +97,7 @@ public SortingParams asc() {
    * @return the SortingParams Object
    */
   public SortingParams limit(final int start, final int count) {
-    params.add(LIMIT.raw);
+    params.add(LIMIT.getRaw());
     params.add(Protocol.toByteArray(start));
     params.add(Protocol.toByteArray(count));
     return this;
@@ -109,7 +109,7 @@ public SortingParams limit(final int start, final int count) {
    * @return the SortingParams Object
    */
   public SortingParams alpha() {
-    params.add(ALPHA.raw);
+    params.add(ALPHA.getRaw());
     return this;
   }
 
@@ -129,7 +129,7 @@ public SortingParams alpha() {
    */
   public SortingParams get(String... patterns) {
     for (final String pattern : patterns) {
-      params.add(GET.raw);
+      params.add(GET.getRaw());
       params.add(SafeEncoder.encode(pattern));
     }
     return this;
@@ -151,7 +151,7 @@ public SortingParams get(String... patterns) {
    */
   public SortingParams get(byte[]... patterns) {
     for (final byte[] pattern : patterns) {
-      params.add(GET.raw);
+      params.add(GET.getRaw());
       params.add(pattern);
     }
     return this;
diff --git a/src/main/java/redis/clients/jedis/StreamConsumersInfo.java b/src/main/java/redis/clients/jedis/StreamConsumersInfo.java
index c97d865492..d195b3a42b 100644
--- a/src/main/java/redis/clients/jedis/StreamConsumersInfo.java
+++ b/src/main/java/redis/clients/jedis/StreamConsumersInfo.java
@@ -11,9 +11,9 @@
  */
 public class StreamConsumersInfo {
 
-  public final static String NAME = "name";
-  public final static String IDLE = "idle";
-  public final static String PENDING = "pending";
+  public static final String NAME = "name";
+  public static final String IDLE = "idle";
+  public static final String PENDING = "pending";
 
   private final String name;
   private final long idle;
diff --git a/src/main/java/redis/clients/jedis/ZParams.java b/src/main/java/redis/clients/jedis/ZParams.java
index 57bca946c8..a784e7ac92 100644
--- a/src/main/java/redis/clients/jedis/ZParams.java
+++ b/src/main/java/redis/clients/jedis/ZParams.java
@@ -14,11 +14,19 @@ public class ZParams {
   public enum Aggregate {
     SUM, MIN, MAX;
 
+    /**
+     * @deprecated This will be private in future. Use {@link #getRaw()}.
+     */
+    @Deprecated
     public final byte[] raw;
 
     Aggregate() {
       raw = SafeEncoder.encode(name());
     }
+    
+    public byte[] getRaw() {
+      return raw;
+    }
   }
 
   private final List<byte[]> params = new ArrayList<>();
@@ -29,7 +37,7 @@ public enum Aggregate {
    * @return 
    */
   public ZParams weights(final double... weights) {
-    params.add(WEIGHTS.raw);
+    params.add(WEIGHTS.getRaw());
     for (final double weight : weights) {
       params.add(Protocol.toByteArray(weight));
     }
@@ -42,7 +50,7 @@ public Collection<byte[]> getParams() {
   }
 
   public ZParams aggregate(final Aggregate aggregate) {
-    params.add(AGGREGATE.raw);
+    params.add(AGGREGATE.getRaw());
     params.add(aggregate.raw);
     return this;
   }
diff --git a/src/main/java/redis/clients/jedis/params/GeoRadiusStoreParam.java b/src/main/java/redis/clients/jedis/params/GeoRadiusStoreParam.java
index 6851a78ac6..5c56df946d 100644
--- a/src/main/java/redis/clients/jedis/params/GeoRadiusStoreParam.java
+++ b/src/main/java/redis/clients/jedis/params/GeoRadiusStoreParam.java
@@ -1,6 +1,7 @@
 package redis.clients.jedis.params;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 
@@ -92,10 +93,8 @@ public byte[][] getByteKeys(byte[] key) {
     }
 
     public byte[][] getByteParams(byte[]... args) {
-        ArrayList<byte[]> byteParams = new ArrayList<byte[]>();
-        for (byte[] arg : args) {
-            byteParams.add(arg);
-        }
+        ArrayList<byte[]> byteParams = new ArrayList<>();
+        Collections.addAll(byteParams, args);
 
         if (contains(STORE)) {
             byteParams.add(SafeEncoder.encode(STORE));
diff --git a/src/test/java/redis/clients/jedis/tests/JedisSentinelPoolTest.java b/src/test/java/redis/clients/jedis/tests/JedisSentinelPoolTest.java
index ca1c72bbfc..3b584bb954 100644
--- a/src/test/java/redis/clients/jedis/tests/JedisSentinelPoolTest.java
+++ b/src/test/java/redis/clients/jedis/tests/JedisSentinelPoolTest.java
@@ -104,31 +104,22 @@ public void returnResourceShouldResetState() {
     GenericObjectPoolConfig config = new GenericObjectPoolConfig();
     config.setMaxTotal(1);
     config.setBlockWhenExhausted(false);
-    JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels, config, 1000,
-        "foobared", 2);
-
-    Jedis jedis = pool.getResource();
-    Jedis jedis2 = null;
-
-    try {
-      jedis.set("hello", "jedis");
-      Transaction t = jedis.multi();
-      t.set("hello", "world");
-      jedis.close();
-
-      jedis2 = pool.getResource();
-
-      assertSame(jedis, jedis2);
-      assertEquals("jedis", jedis2.get("hello"));
-    } catch (JedisConnectionException e) {
-      if (jedis2 != null) {
-        jedis2 = null;
+    try ( JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels, config, 1000,
+        "foobared", 2)){
+      
+      Jedis jedis = null;
+      try(Jedis jedis1 = pool.getResource()){
+        jedis = jedis1;
+        jedis1.set("hello", "jedis");
+        Transaction t = jedis1.multi();
+        t.set("hello", "world");
       }
-    } finally {
-      jedis2.close();
 
-      pool.destroy();
-    }
+      try(Jedis jedis2 = pool.getResource()){
+        assertSame(jedis, jedis2);
+        assertEquals("jedis", jedis2.get("hello"));
+      }     
+    } 
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/tests/JedisSentinelPoolWithCompleteCredentialsTest.java b/src/test/java/redis/clients/jedis/tests/JedisSentinelPoolWithCompleteCredentialsTest.java
index 49f7ea8399..5051ad7c7b 100644
--- a/src/test/java/redis/clients/jedis/tests/JedisSentinelPoolWithCompleteCredentialsTest.java
+++ b/src/test/java/redis/clients/jedis/tests/JedisSentinelPoolWithCompleteCredentialsTest.java
@@ -98,11 +98,11 @@ public void checkCloseableConnections() throws Exception {
 
     JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels, config, 1000,
         "default","foobared", 2);
-    Jedis jedis = pool.getResource();
-    jedis.auth("default", "foobared");
-    jedis.set("foo", "bar");
-    assertEquals("bar", jedis.get("foo"));
-    jedis.close();
+    try(Jedis jedis = pool.getResource()){
+      jedis.auth("default", "foobared");
+      jedis.set("foo", "bar");
+      assertEquals("bar", jedis.get("foo"));
+    }
     pool.close();
     assertTrue(pool.isClosed());
   }
@@ -126,30 +126,22 @@ public void returnResourceShouldResetState() {
     GenericObjectPoolConfig config = new GenericObjectPoolConfig();
     config.setMaxTotal(1);
     config.setBlockWhenExhausted(false);
-    JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels, config, 1000,
-        "default", "foobared", 2);
 
-    Jedis jedis = pool.getResource();
-    Jedis jedis2 = null;
-
-    try {
-      jedis.set("hello", "jedis");
-      Transaction t = jedis.multi();
-      t.set("hello", "world");
-      jedis.close();
+    try (JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels, config, 1000,
+        "default", "foobared", 2)){
+      Jedis jedis;
+      try (Jedis jedis1 = pool.getResource()){
+        jedis = jedis1;
+        jedis1.set("hello", "jedis");
+        Transaction t = jedis1.multi();
+        t.set("hello", "world");
+      }
 
-      jedis2 = pool.getResource();
+      try (Jedis jedis2 = pool.getResource()) {
 
-      assertTrue(jedis == jedis2);
-      assertEquals("jedis", jedis2.get("hello"));
-    } catch (JedisConnectionException e) {
-      if (jedis2 != null) {
-        jedis2 = null;
+        assertSame(jedis, jedis2);
+        assertEquals("jedis", jedis2.get("hello"));
       }
-    } finally {
-      jedis2.close();
-
-      pool.destroy();
     }
   }
 
@@ -158,21 +150,18 @@ public void checkResourceIsCloseable() {
     GenericObjectPoolConfig config = new GenericObjectPoolConfig();
     config.setMaxTotal(1);
     config.setBlockWhenExhausted(false);
-    JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels, config, 1000,
-        "default", "foobared", 2);
+    try(JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels, config, 1000,
+        "default", "foobared", 2)){
 
-    Jedis jedis = pool.getResource();
-    try {
-      jedis.set("hello", "jedis");
-    } finally {
-      jedis.close();
-    }
-
-    Jedis jedis2 = pool.getResource();
-    try {
-      assertEquals(jedis, jedis2);
-    } finally {
-      jedis2.close();
+      Jedis jedis;
+      try (Jedis jedis1 = pool.getResource()){
+        jedis = jedis1;
+        jedis1.set("hello", "jedis");
+      }
+      
+      try (Jedis jedis2 = pool.getResource()){
+        assertEquals(jedis, jedis2);
+      }
     }
   }
 
@@ -184,13 +173,10 @@ public void customClientName() {
     JedisSentinelPool pool = new JedisSentinelPool(MASTER_NAME, sentinels, config, 1000,
         "default", "foobared", 0, "my_shiny_client_name");
 
-    Jedis jedis = pool.getResource();
-
-    try {
+    try (Jedis jedis = pool.getResource()){
       assertEquals("my_shiny_client_name", jedis.clientGetname());
     } finally {
-      jedis.close();
-      pool.destroy();
+      pool.close();
     }
 
     assertTrue(pool.isClosed());
@@ -237,4 +223,4 @@ private void waitForJedisSentinelPoolRecognizeNewMaster(JedisSentinelPool pool,
     }
   }
 
-}
\ No newline at end of file
+}