Remove openhft hashing from source dependency

pom.xml

@@ -93,7 +93,7 @@
 			<groupId>net.openhft</groupId>
 			<artifactId>zero-allocation-hashing</artifactId>
 			<version>0.16</version>
-			<optional>true</optional>
+			<scope>test</scope>
 		</dependency>
 
 		<!-- UNIX socket connection support -->

src/main/java/redis/clients/jedis/csc/CaffeineClientSideCache.java

@@ -5,18 +5,22 @@
 import java.util.concurrent.TimeUnit;
 
 import redis.clients.jedis.csc.hash.CommandLongHasher;
-import redis.clients.jedis.csc.hash.OpenHftCommandHasher;
+import redis.clients.jedis.csc.hash.SimpleCommandHasher;
 
 public class CaffeineClientSideCache extends ClientSideCache {
 
   private final Cache<Long, Object> cache;
 
   public CaffeineClientSideCache(Cache<Long, Object> caffeineCache) {
-    this(caffeineCache, DefaultClientSideCacheable.INSTANCE);
+    this(caffeineCache, SimpleCommandHasher.INSTANCE);
+  }
+
+  public CaffeineClientSideCache(Cache<Long, Object> caffeineCache, CommandLongHasher commandHasher) {
+    this(caffeineCache, commandHasher, DefaultClientSideCacheable.INSTANCE);
   }
 
   public CaffeineClientSideCache(Cache<Long, Object> caffeineCache, ClientSideCacheable cacheable) {
-    this(caffeineCache, new OpenHftCommandHasher(OpenHftCommandHasher.DEFAULT_HASH_FUNCTION), cacheable);
+    this(caffeineCache, SimpleCommandHasher.INSTANCE, cacheable);
   }
 
   public CaffeineClientSideCache(Cache<Long, Object> caffeineCache, CommandLongHasher commandHasher, ClientSideCacheable cacheable) {
@@ -55,7 +59,7 @@
     private final TimeUnit expireTimeUnit = TimeUnit.SECONDS;
 
     // not using a default value to avoid an object creation like 'new OpenHftHashing(hashFunction)'
-    private CommandLongHasher commandHasher = null;
+    private CommandLongHasher commandHasher = SimpleCommandHasher.INSTANCE;
 
     private ClientSideCacheable cacheable = DefaultClientSideCacheable.INSTANCE;
 
@@ -88,8 +92,7 @@
 
       cb.expireAfterWrite(expireTime, expireTimeUnit);
 
-      return commandHasher != null ? new CaffeineClientSideCache(cb.build(), commandHasher, cacheable)
-          : new CaffeineClientSideCache(cb.build(), cacheable);
+      return new CaffeineClientSideCache(cb.build(), commandHasher, cacheable);
     }
   }
 }

src/main/java/redis/clients/jedis/csc/hash/PrimitiveArrayCommandHasher.java → src/main/java/redis/clients/jedis/csc/hash/AbstractSimpleCommandHasher.java

@@ -4,11 +4,11 @@
 import redis.clients.jedis.args.Rawable;
 
 /**
- * It is possible to extend {@link PrimitiveArrayCommandHasher this abstract class} in order to implement
- * {@link CommandLongHasher} as {@link PrimitiveArrayCommandHasher#hashLongs(long[])} and
- * {@link PrimitiveArrayCommandHasher#hashBytes(byte[])} can be supported by almost all Java hashing libraries.
+ * It is possible to extend {@link AbstractSimpleCommandHasher this abstract class} in order to implement
+ * {@link CommandLongHasher} as {@link AbstractSimpleCommandHasher#hashLongs(long[])} and
+ * {@link AbstractSimpleCommandHasher#hashBytes(byte[])} are supported by almost all Java hashing libraries.
  */
-public abstract class PrimitiveArrayCommandHasher extends AbstractCommandHasher {
+public abstract class AbstractSimpleCommandHasher extends AbstractCommandHasher {
 
   @Override
   protected final long hashRawable(Rawable raw) {

src/main/java/redis/clients/jedis/csc/hash/GuavaCommandHasher.java

@@ -4,12 +4,19 @@
 import com.google.common.hash.Hasher;
 import redis.clients.jedis.CommandObject;
 
-public class GuavaCommandHasher implements CommandLongHasher {
+/**
+ * An implementation of {@link CommandLongHasher} based on {@link HashFunction} from Google Guava library.
+ */
+public final class GuavaCommandHasher implements CommandLongHasher {
 
   public static final HashFunction DEFAULT_HASH_FUNCTION = com.google.common.hash.Hashing.fingerprint2011();
 
   private final HashFunction function;
 
+  /**
+   * It is advised to use a {@link HashFunction} capable of producing 64-bit hash.
+   * @param function an implementation of hash function
+   */
   public GuavaCommandHasher(HashFunction function) {
     this.function = function;
   }

src/main/java/redis/clients/jedis/csc/hash/SimpleCommandHasher.java

@@ -0,0 +1,25 @@
+package redis.clients.jedis.csc.hash;
+
+import java.util.Arrays;
+
+/**
+ * This {@link CommandLongHasher} implementation is simply based on {@link Arrays#hashCode(long[])}
+ * and {@link Arrays#hashCode(byte[])}. These methods actually produce 32-bit hash codes. It is
+ * advised to use proper 64-bit hash codes in production.
+ */
+public final class SimpleCommandHasher extends AbstractSimpleCommandHasher {
+
+  public static final SimpleCommandHasher INSTANCE = new SimpleCommandHasher();
+
+  public SimpleCommandHasher() { }
+
+  @Override
+  protected long hashLongs(long[] longs) {
+    return Arrays.hashCode(longs);
+  }
+
+  @Override
+  protected long hashBytes(byte[] bytes) {
+    return Arrays.hashCode(bytes);
+  }
+}

src/test/java/redis/clients/jedis/csc/ClientSideCacheLibsTest.java

@@ -7,8 +7,6 @@
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.google.common.cache.CacheBuilder;
 import java.util.function.Supplier;
-import net.openhft.hashing.LongHashFunction;
-
 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
 import org.hamcrest.Matchers;
 import org.junit.After;
@@ -23,7 +21,6 @@
 import redis.clients.jedis.Jedis;
 import redis.clients.jedis.JedisClientConfig;
 import redis.clients.jedis.JedisPooled;
-import redis.clients.jedis.csc.hash.OpenHftCommandHasher;
 
 public class ClientSideCacheLibsTest {
 
@@ -92,8 +89,7 @@ public void guavaMore() {
 
   @Test
   public void caffeineSimple() {
-    CaffeineClientSideCache caffeine = CaffeineClientSideCache.builder().maximumSize(10).ttl(10)
-        .commandHasher(new OpenHftCommandHasher(LongHashFunction.xx())).build();
+    CaffeineClientSideCache caffeine = CaffeineClientSideCache.builder().maximumSize(10).ttl(10).build();
     try (JedisPooled jedis = new JedisPooled(hnp, clientConfig.get(), caffeine)) {
       control.set("foo", "bar");
       assertEquals("bar", jedis.get("foo"));
@@ -107,7 +103,8 @@ public void caffeineMore() {
 
     com.github.benmanes.caffeine.cache.Cache caffeine = Caffeine.newBuilder().recordStats().build();
 
-    try (JedisPooled jedis = new JedisPooled(hnp, clientConfig.get(), new CaffeineClientSideCache(caffeine),
+    try (JedisPooled jedis = new JedisPooled(hnp, clientConfig.get(),
+        new CaffeineClientSideCache(caffeine, new OpenHftCommandHasher()),
         singleConnectionPoolConfig.get())) {
       control.set("foo", "bar");
       assertEquals(0, caffeine.estimatedSize());

src/test/java/redis/clients/jedis/csc/MapClientSideCache.java

@@ -1,39 +1,25 @@
 package redis.clients.jedis.csc;
 
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 
-import redis.clients.jedis.csc.hash.PrimitiveArrayCommandHasher;
+import redis.clients.jedis.csc.hash.SimpleCommandHasher;
 
 public class MapClientSideCache extends ClientSideCache {
 
-  private static final PrimitiveArrayCommandHasher HASHING = new PrimitiveArrayCommandHasher() {
-
-    @Override
-    protected long hashLongs(long[] longs) {
-      return Arrays.hashCode(longs);
-    }
-
-    @Override
-    protected long hashBytes(byte[] bytes) {
-      return Arrays.hashCode(bytes);
-    }
-  };
-
   private final Map<Long, Object> cache;
 
   public MapClientSideCache() {
     this(new HashMap<>());
   }
 
   public MapClientSideCache(Map<Long, Object> map) {
-    super(HASHING);
+    super(SimpleCommandHasher.INSTANCE);
     this.cache = map;
   }
 
   public MapClientSideCache(Map<Long, Object> cache, ClientSideCacheable cacheable) {
-    super(HASHING, cacheable);
+    super(SimpleCommandHasher.INSTANCE, cacheable);
     this.cache = cache;
   }
 

src/main/java/redis/clients/jedis/csc/hash/OpenHftCommandHasher.java → src/test/java/redis/clients/jedis/csc/OpenHftCommandHasher.java

@@ -1,13 +1,18 @@
-package redis.clients.jedis.csc.hash;
+package redis.clients.jedis.csc;
 
 import net.openhft.hashing.LongHashFunction;
+import redis.clients.jedis.csc.hash.AbstractSimpleCommandHasher;
 
-public class OpenHftCommandHasher extends PrimitiveArrayCommandHasher implements CommandLongHasher {
+public class OpenHftCommandHasher extends AbstractSimpleCommandHasher {
 
   public static final LongHashFunction DEFAULT_HASH_FUNCTION = LongHashFunction.xx3();
 
   private final LongHashFunction function;
 
+  OpenHftCommandHasher() {
+    this(DEFAULT_HASH_FUNCTION);
+  }
+
   public OpenHftCommandHasher(LongHashFunction function) {
     this.function = function;
   }