Feature - LocalCachedMapOptions.cacheSize = -1 should disable data storage #5109

redisson/src/main/java/org/redisson/api/LocalCachedMapOptions.java

@@ -207,9 +207,13 @@ public class LocalCachedMapOptions<K, V> extends MapOptions<K, V> {
     }
 
     /**
-     * Defines local cache size. If size is <code>0</code> then local cache is unbounded.
+     * Defines local cache size.
+     * <p>
+     * If size is <code>0</code> then local cache is unbounded.
+     * <p>
+     * If size is <code>-1</code> then local cache is always empty and doesn't store data.
      * 
-     * @param cacheSize - size of cache
+     * @param cacheSize size of cache
      * @return LocalCachedMapOptions instance
      */
     public LocalCachedMapOptions<K, V> cacheSize(int cacheSize) {

redisson/src/main/java/org/redisson/cache/LocalCacheListener.java

@@ -211,6 +211,9 @@ public abstract class LocalCacheListener {
                             for (byte[] keyHash : invalidateMsg.getKeyHashes()) {
                                 CacheKey key = new CacheKey(keyHash);
                                 CacheValue value = cache.remove(key);
+                                if (value == null) {
+                                    continue;
+                                }
                                 notifyInvalidate(value);
                             }
                         }

redisson/src/main/java/org/redisson/cache/LocalCacheView.java

@@ -15,14 +15,8 @@
  */
 package org.redisson.cache;
 
-import java.util.AbstractCollection;
-import java.util.AbstractMap;
-import java.util.AbstractSet;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
-import java.util.Set;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.TimeUnit;
 
@@ -265,6 +259,10 @@ public class LocalCacheView<K, V> {
     }
 
     public ConcurrentMap<CacheKey, CacheValue> createCache(LocalCachedMapOptions<?, ?> options) {
+        if (options.getCacheSize() == -1) {
+            return new NoOpCacheMap<CacheKey, CacheValue>();
+        }
+
         if (options.getCacheProvider() == LocalCachedMapOptions.CacheProvider.CAFFEINE) {
             Caffeine<Object, Object> caffeineBuilder = Caffeine.newBuilder();
             if (options.getTimeToLiveInMillis() > 0) {

redisson/src/main/java/org/redisson/cache/NoOpCacheMap.java

@@ -0,0 +1,111 @@
+/**
+ * Copyright (c) 2013-2022 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.cache;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ *
+ * @author Nikita Koksharov
+ *
+ * @param <K> key type
+ * @param <V> value type
+ */
+public class NoOpCacheMap<K, V> implements ConcurrentMap<K, V> {
+
+    @Override
+    public int size() {
+        return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return false;
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        return false;
+    }
+
+    @Override
+    public V get(Object key) {
+        return null;
+    }
+
+    @Override
+    public V put(K key, V value) {
+        return null;
+    }
+
+    @Override
+    public V remove(Object key) {
+        return null;
+    }
+
+    @Override
+    public void putAll(Map<? extends K, ? extends V> m) {
+
+    }
+
+    @Override
+    public void clear() {
+
+    }
+
+    @Override
+    public Set<K> keySet() {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public Collection<V> values() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return Collections.emptySet();
+    }
+    @Override
+    public V putIfAbsent(K key, V value) {
+        return null;
+    }
+
+    @Override
+    public boolean remove(Object key, Object value) {
+        return false;
+    }
+
+    @Override
+    public boolean replace(K key, V oldValue, V newValue) {
+        return false;
+    }
+
+    @Override
+    public V replace(K key, V value) {
+        return null;
+    }
+}