From 4c502283c27504d2339acb02d1619a854156c25c Mon Sep 17 00:00:00 2001 From: Nikita Koksharov Date: Tue, 17 Sep 2024 10:22:51 +0300 Subject: [PATCH] Fixed - BiHashMap usage removed. #6175 --- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../test/java/org/redisson/ClusterRunner.java | 105 ++++++++++++++- .../src/main/java/org/redisson/Redisson.java | 4 - .../java/org/redisson/RedissonReference.java | 79 ++++------- .../java/org/redisson/misc/BiHashMap.java | 127 ------------------ .../test/java/org/redisson/ClusterRunner.java | 106 ++++++++++++++- 19 files changed, 1611 insertions(+), 280 deletions(-) delete mode 100644 redisson/src/main/java/org/redisson/misc/BiHashMap.java diff --git a/redisson-spring-data/redisson-spring-data-16/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-16/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-16/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-17/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-17/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-17/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-18/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-18/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-18/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-20/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-20/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-20/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-21/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-21/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-21/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-22/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-22/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-22/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-23/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-23/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-23/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-24/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-24/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-24/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-25/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-25/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-25/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-26/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-26/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-26/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-27/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-27/src/test/java/org/redisson/ClusterRunner.java index 69af59386..1ddde1d15 100644 --- a/redisson-spring-data/redisson-spring-data-27/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} \ No newline at end of file diff --git a/redisson-spring-data/redisson-spring-data-30/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-30/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-30/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-31/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-31/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-31/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-32/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-32/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-32/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson-spring-data/redisson-spring-data-33/src/test/java/org/redisson/ClusterRunner.java b/redisson-spring-data/redisson-spring-data-33/src/test/java/org/redisson/ClusterRunner.java index 69af59386..5e34fbd54 100644 --- a/redisson-spring-data/redisson-spring-data-33/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -154,3 +149,101 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} diff --git a/redisson/src/main/java/org/redisson/Redisson.java b/redisson/src/main/java/org/redisson/Redisson.java index 9c8a6c357..f03d23349 100755 --- a/redisson/src/main/java/org/redisson/Redisson.java +++ b/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; diff --git a/redisson/src/main/java/org/redisson/RedissonReference.java b/redisson/src/main/java/org/redisson/RedissonReference.java index 0e5dbce55..8097d782c 100644 --- a/redisson/src/main/java/org/redisson/RedissonReference.java +++ b/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 REACTIVE_MAP = new BiHashMap<>(); - private static final BiHashMap 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()); - if (this.type == null) { - throw new IllegalArgumentException("There is no Reactive compatible type for " + type); + String t = type.getName().replaceFirst("Reactive", ""); + if (!isAvailable(t)) { + 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()); - if (this.type == null) { - throw new IllegalArgumentException("There is no RxJava compatible type for " + type); + String t = type.getName().replaceFirst("Rx", ""); + if (!isAvailable(t)) { + 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)) { - return Class.forName(RXJAVA_MAP.reverseGet(type)); //live object is not supported in reactive client + String rxName = type + "Rx"; + 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)) { - return Class.forName(REACTIVE_MAP.reverseGet(type)); //live object is not supported in reactive client + String reactiveName = type + "Reactive"; + 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; + } + } } diff --git a/redisson/src/main/java/org/redisson/misc/BiHashMap.java b/redisson/src/main/java/org/redisson/misc/BiHashMap.java deleted file mode 100644 index ae83bfa32..000000000 --- a/redisson/src/main/java/org/redisson/misc/BiHashMap.java +++ /dev/null @@ -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 key - * @param value - */ -public class BiHashMap implements Map { - - private Map keyValueMap = new HashMap(); - private Map valueKeyMap = new HashMap(); - - @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 m) { - for (Entry entry : m.entrySet()) { - put(entry.getKey(), entry.getValue()); - } - } - - @Override - public void clear() { - keyValueMap.clear(); - valueKeyMap.clear(); - } - - @Override - public Set keySet() { - return keyValueMap.keySet(); - } - - public Set valueSet() { - return valueKeyMap.keySet(); - } - - @Override - public Collection values() { - return keyValueMap.values(); - } - - public Collection keys() { - return valueKeyMap.values(); - } - - @Override - public Set> entrySet() { - return keyValueMap.entrySet(); - } - - public Set> reverseEntrySet() { - return valueKeyMap.entrySet(); - } - - public void makeImmutable() { - keyValueMap = Collections.unmodifiableMap(keyValueMap); - valueKeyMap = Collections.unmodifiableMap(valueKeyMap); - } -} diff --git a/redisson/src/test/java/org/redisson/ClusterRunner.java b/redisson/src/test/java/org/redisson/ClusterRunner.java index 6ebb63b4c..4fcfdd6a0 100644 --- a/redisson/src/test/java/org/redisson/ClusterRunner.java +++ b/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.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; -import org.redisson.misc.BiHashMap; /** * @@ -166,3 +161,102 @@ public class ClusterRunner { } } } + +class BiHashMap implements Map { + + private Map keyValueMap = new HashMap(); + private Map valueKeyMap = new HashMap(); + + @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 m) { + for (Entry entry : m.entrySet()) { + put(entry.getKey(), entry.getValue()); + } + } + + @Override + public void clear() { + keyValueMap.clear(); + valueKeyMap.clear(); + } + + @Override + public Set keySet() { + return keyValueMap.keySet(); + } + + public Set valueSet() { + return valueKeyMap.keySet(); + } + + @Override + public Collection values() { + return keyValueMap.values(); + } + + public Collection keys() { + return valueKeyMap.values(); + } + + @Override + public Set> entrySet() { + return keyValueMap.entrySet(); + } + + public Set> reverseEntrySet() { + return valueKeyMap.entrySet(); + } + + public void makeImmutable() { + keyValueMap = Collections.unmodifiableMap(keyValueMap); + valueKeyMap = Collections.unmodifiableMap(valueKeyMap); + } +} +