Fixed - BiHashMap usage removed. #6175

redisson-spring-data/redisson-spring-data-16/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-17/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-18/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-20/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-21/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-22/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-23/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-24/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-25/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-26/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-27/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-30/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-31/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-32/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson-spring-data/redisson-spring-data-33/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -154,3 +149,101 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}

redisson/src/main/java/org/redisson/Redisson.java

@@ -51,10 +51,6 @@ import java.util.concurrent.TimeUnit;
  */
 public final class Redisson implements RedissonClient {
 
-    static {
-        RedissonReference.warmUp();
-    }
-
     private final EvictionScheduler evictionScheduler;
     private final WriteBehindService writeBehindService;
     private final ConnectionManager connectionManager;

redisson/src/main/java/org/redisson/RedissonReference.java

@@ -15,11 +15,12 @@
  */
 package org.redisson;
 
-import org.redisson.api.*;
+import org.redisson.api.RObject;
+import org.redisson.api.RObjectReactive;
+import org.redisson.api.RObjectRx;
 import org.redisson.api.annotation.REntity;
 import org.redisson.client.codec.Codec;
 import org.redisson.liveobject.misc.ClassUtils;
-import org.redisson.misc.BiHashMap;
 
 import java.io.Serializable;
 
@@ -32,47 +33,6 @@ public class RedissonReference implements Serializable {
 
     private static final long serialVersionUID = -2378564460151709127L;
     
-    private static final BiHashMap<String, String> REACTIVE_MAP = new BiHashMap<>();
-    private static final BiHashMap<String, String> RXJAVA_MAP = new BiHashMap<>();
-
-    static {
-        REACTIVE_MAP.put(RAtomicLongReactive.class.getName(),         RAtomicLong.class.getName());
-        REACTIVE_MAP.put(RBitSetReactive.class.getName(),             RBitSet.class.getName());
-        REACTIVE_MAP.put(RBlockingQueueReactive.class.getName(),      RBlockingQueue.class.getName());
-        REACTIVE_MAP.put(RBucketReactive.class.getName(),             RBucket.class.getName());
-        REACTIVE_MAP.put(RDequeReactive.class.getName(),              RDeque.class.getName());
-        REACTIVE_MAP.put(RHyperLogLogReactive.class.getName(),        RHyperLogLog.class.getName());
-        REACTIVE_MAP.put(RLexSortedSetReactive.class.getName(),       RLexSortedSet.class.getName());
-        REACTIVE_MAP.put(RListReactive.class.getName(),               RList.class.getName());
-        REACTIVE_MAP.put(RMapCacheReactive.class.getName(),           RMapCache.class.getName());
-        REACTIVE_MAP.put(RMapReactive.class.getName(),                RMap.class.getName());
-        REACTIVE_MAP.put(RQueueReactive.class.getName(),              RQueue.class.getName());
-        REACTIVE_MAP.put(RScoredSortedSetReactive.class.getName(),    RScoredSortedSet.class.getName());
-        REACTIVE_MAP.put(RSetCacheReactive.class.getName(),           RSetCache.class.getName());
-        REACTIVE_MAP.put(RSetReactive.class.getName(),                RSet.class.getName());
-
-        REACTIVE_MAP.makeImmutable();
-
-        RXJAVA_MAP.put(RAtomicLongRx.class.getName(),         RAtomicLong.class.getName());
-        RXJAVA_MAP.put(RBitSetRx.class.getName(),             RBitSet.class.getName());
-        RXJAVA_MAP.put(RBlockingQueueRx.class.getName(),      RBlockingQueue.class.getName());
-        RXJAVA_MAP.put(RBucketRx.class.getName(),             RBucket.class.getName());
-        RXJAVA_MAP.put(RDequeRx.class.getName(),              RDeque.class.getName());
-        RXJAVA_MAP.put(RHyperLogLogRx.class.getName(),        RHyperLogLog.class.getName());
-        RXJAVA_MAP.put(RLexSortedSetRx.class.getName(),       RLexSortedSet.class.getName());
-        RXJAVA_MAP.put(RListRx.class.getName(),               RList.class.getName());
-        RXJAVA_MAP.put(RMapCacheRx.class.getName(),           RMapCache.class.getName());
-        RXJAVA_MAP.put(RMapRx.class.getName(),                RMap.class.getName());
-        RXJAVA_MAP.put(RQueueRx.class.getName(),              RQueue.class.getName());
-        RXJAVA_MAP.put(RScoredSortedSetRx.class.getName(),    RScoredSortedSet.class.getName());
-        RXJAVA_MAP.put(RSetCacheRx.class.getName(),           RSetCache.class.getName());
-        RXJAVA_MAP.put(RSetRx.class.getName(),                RSet.class.getName());
-
-        RXJAVA_MAP.makeImmutable();
-    }
-
-    public static void warmUp() {}
-
     public enum ReferenceType {RXJAVA, REACTIVE, DEFAULT}
 
     private String type;
@@ -94,15 +54,17 @@ public class RedissonReference implements Serializable {
             throw new IllegalArgumentException("Class reference has to be a type of either RObject/RLiveObject/RObjectReactive/RObjectRx");
         }
         if (RObjectReactive.class.isAssignableFrom(type)) {
-            this.type = REACTIVE_MAP.get(type.getName());
+            String t = type.getName().replaceFirst("Reactive", "");
-            if (this.type == null) {
+            if (!isAvailable(t)) {
-                throw new IllegalArgumentException("There is no Reactive compatible type for " + type);
+                throw new IllegalArgumentException("There is no compatible type for " + type);
             }
+            this.type = t;
         } else if (RObjectRx.class.isAssignableFrom(type)) {
-            this.type = RXJAVA_MAP.get(type.getName());
+            String t = type.getName().replaceFirst("Rx", "");
-            if (this.type == null) {
+            if (!isAvailable(t)) {
-                throw new IllegalArgumentException("There is no RxJava compatible type for " + type);
+                throw new IllegalArgumentException("There is no compatible type for " + type);
             }
+            this.type = t;
         } else {
             this.type = type.getName();
         }
@@ -121,8 +83,9 @@ public class RedissonReference implements Serializable {
     }
 
     public Class<?> getRxJavaType() throws ClassNotFoundException {
-        if (RXJAVA_MAP.containsValue(type)) {
+        String rxName = type + "Rx";
-            return Class.forName(RXJAVA_MAP.reverseGet(type)); //live object is not supported in reactive client
+        if (isAvailable(rxName)) {
+            return Class.forName(rxName); //live object is not supported in reactive client
         }
         throw new ClassNotFoundException("There is no RxJava compatible type for " + type);
     }
@@ -132,8 +95,9 @@ public class RedissonReference implements Serializable {
      * @throws java.lang.ClassNotFoundException - if the class cannot be located
      */
     public Class<?> getReactiveType() throws ClassNotFoundException {
-        if (REACTIVE_MAP.containsValue(type)) {
+        String reactiveName = type + "Reactive";
-            return Class.forName(REACTIVE_MAP.reverseGet(type)); //live object is not supported in reactive client
+        if (isAvailable(reactiveName)) {
+            return Class.forName(reactiveName); //live object is not supported in reactive client
         }
         throw new ClassNotFoundException("There is no Reactive compatible type for " + type);
     }
@@ -173,4 +137,13 @@ public class RedissonReference implements Serializable {
         }
         return null;
     }
+
+    private boolean isAvailable(String type) {
+        try {
+            Class.forName(type);
+            return true;
+        } catch (ClassNotFoundException e) {
+            return false;
+        }
+    }
 }

redisson/src/main/java/org/redisson/misc/BiHashMap.java

@@ -1,127 +0,0 @@
-/**
- * Copyright (c) 2013-2024 Nikita Koksharov
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.redisson.misc;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * This is not a concurrent map.
- * 
- * @author Rui Gu (https://github.com/jackygurui)
- * @param <K> key
- * @param <V> value
- */
-public class BiHashMap<K, V> implements Map<K, V> {
-
-    private Map<K, V> keyValueMap = new HashMap<K, V>();
-    private Map<V, K> valueKeyMap = new HashMap<V, K>();
-    
-    @Override
-    public int size() {
-        return keyValueMap.size();
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return keyValueMap.isEmpty();
-    }
-
-    @Override
-    public boolean containsKey(Object key) {
-        return keyValueMap.containsKey(key);
-    }
-
-    @Override
-    public boolean containsValue(Object value) {
-        return valueKeyMap.containsKey(value);
-    }
-
-    @Override
-    public V get(Object key) {
-        return keyValueMap.get(key);
-    }
-    
-    public K reverseGet(Object key) {
-        return valueKeyMap.get(key);
-    }
-
-    @Override
-    public V put(K key, V value) {
-        if (keyValueMap.containsKey(key)) {
-            valueKeyMap.remove(keyValueMap.get(key));
-        }
-        valueKeyMap.put(value, key);
-        return keyValueMap.put(key, value);
-    }
-
-    @Override
-    public V remove(Object key) {
-        V removed = keyValueMap.remove(key);
-        if (removed != null) {
-            valueKeyMap.remove(removed);
-        }
-        return removed;
-    }
-
-    @Override
-    public void putAll(Map<? extends K, ? extends V> m) {
-        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
-            put(entry.getKey(), entry.getValue());
-        }
-    }
-
-    @Override
-    public void clear() {
-        keyValueMap.clear();
-        valueKeyMap.clear();
-    }
-
-    @Override
-    public Set<K> keySet() {
-        return keyValueMap.keySet();
-    }
-    
-    public Set<V> valueSet() {
-        return valueKeyMap.keySet();
-    }
-
-    @Override
-    public Collection<V> values() {
-        return keyValueMap.values();
-    }
-    
-    public Collection<K> keys() {
-        return valueKeyMap.values();
-    }
-
-    @Override
-    public Set<Entry<K, V>> entrySet() {
-        return keyValueMap.entrySet();
-    }
-    
-    public Set<Entry<V, K>> reverseEntrySet() {
-        return valueKeyMap.entrySet();
-    }
-    
-    public void makeImmutable() {
-        keyValueMap = Collections.unmodifiableMap(keyValueMap);
-        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
-    }
-}

redisson/src/test/java/org/redisson/ClusterRunner.java

@@ -6,13 +6,8 @@ import java.io.IOException;
 import java.io.PrintWriter;
 import java.math.BigInteger;
 import java.security.SecureRandom;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.stream.Collectors;
-import org.redisson.misc.BiHashMap;
 
 /**
  *
@@ -166,3 +161,102 @@ public class ClusterRunner {
         }
     }
 }
+
+class BiHashMap<K, V> implements Map<K, V> {
+
+    private Map<K, V> keyValueMap = new HashMap<K, V>();
+    private Map<V, K> valueKeyMap = new HashMap<V, K>();
+
+    @Override
+    public int size() {
+        return keyValueMap.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return keyValueMap.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return keyValueMap.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return valueKeyMap.containsKey(value);
+    }
+
+    @Override
+    public V get(Object key) {
+        return keyValueMap.get(key);
+    }
+
+    public K reverseGet(Object key) {
+        return valueKeyMap.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        if (keyValueMap.containsKey(key)) {
+            valueKeyMap.remove(keyValueMap.get(key));
+        }
+        valueKeyMap.put(value, key);
+        return keyValueMap.put(key, value);
+    }
+
+    @Override
+    public V remove(Object key) {
+        V removed = keyValueMap.remove(key);
+        if (removed != null) {
+            valueKeyMap.remove(removed);
+        }
+        return removed;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+        for (Entry<? extends K, ? extends V> entry : m.entrySet()) {
+            put(entry.getKey(), entry.getValue());
+        }
+    }
+
+    @Override
+    public void clear() {
+        keyValueMap.clear();
+        valueKeyMap.clear();
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return keyValueMap.keySet();
+    }
+
+    public Set<V> valueSet() {
+        return valueKeyMap.keySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return keyValueMap.values();
+    }
+
+    public Collection<K> keys() {
+        return valueKeyMap.values();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return keyValueMap.entrySet();
+    }
+
+    public Set<Entry<V, K>> reverseEntrySet() {
+        return valueKeyMap.entrySet();
+    }
+
+    public void makeImmutable() {
+        keyValueMap = Collections.unmodifiableMap(keyValueMap);
+        valueKeyMap = Collections.unmodifiableMap(valueKeyMap);
+    }
+}
+