Merge branch 'master' of github.com:FasterXML/jackson-databind

Author: cowtowncoder

src/main/java/com/fasterxml/jackson/databind/deser/DeserializerCache.java

@@ -11,6 +11,7 @@
 import com.fasterxml.jackson.databind.type.*;
 import com.fasterxml.jackson.databind.util.ClassUtil;
 import com.fasterxml.jackson.databind.util.Converter;
+import com.fasterxml.jackson.databind.util.LookupCache;
 import com.fasterxml.jackson.databind.util.SimpleLookupCache;
 
 /**
@@ -41,7 +42,7 @@ public final class DeserializerCache
      * This currently (3.0) means POJO, Enum and Container (collection,
      * map) deserializers.
      */
-    private final SimpleLookupCache<JavaType, JsonDeserializer<Object>> _cachedDeserializers;
+    private final LookupCache<JavaType, JsonDeserializer<Object>> _cachedDeserializers;
 
     /**
      * During deserializer construction process we may need to keep track of partially

src/main/java/com/fasterxml/jackson/databind/introspect/BasicClassIntrospector.java

@@ -11,6 +11,7 @@
 import com.fasterxml.jackson.databind.cfg.MapperConfig;
 import com.fasterxml.jackson.databind.type.SimpleType;
 import com.fasterxml.jackson.databind.util.ClassUtil;
+import com.fasterxml.jackson.databind.util.LookupCache;
 import com.fasterxml.jackson.databind.util.SimpleLookupCache;
 
 public class BasicClassIntrospector
@@ -60,13 +61,13 @@ public class BasicClassIntrospector
      * because {@link #forMapper(Object)} initializes it properly, when mapper get
      * constructed.
      */
-    protected final transient SimpleLookupCache<JavaType,BasicBeanDescription> _cachedFCA;
+    protected final transient LookupCache<JavaType,BasicBeanDescription> _cachedFCA;
 
     public BasicClassIntrospector() {
         this(null);
     }
 
-    protected BasicClassIntrospector(SimpleLookupCache<JavaType,BasicBeanDescription> cache) {
+    protected BasicClassIntrospector(LookupCache<JavaType,BasicBeanDescription> cache) {
         _cachedFCA = cache;
     }
 

src/main/java/com/fasterxml/jackson/databind/introspect/JacksonAnnotationIntrospector.java

@@ -78,7 +78,7 @@ public class JacksonAnnotationIntrospector
      *<p>
      * Non-final only because it needs to be re-created after deserialization.
      */
-    protected transient SimpleLookupCache<Class<?>,Boolean> _annotationsInside = new SimpleLookupCache<Class<?>,Boolean>(48, 96);
+    protected transient LookupCache<Class<?>,Boolean> _annotationsInside = new SimpleLookupCache<Class<?>,Boolean>(48, 96);
 
     /*
     /**********************************************************************

src/main/java/com/fasterxml/jackson/databind/ser/SerializerCache.java

@@ -60,7 +60,7 @@ public SerializerCache(int maxCached) {
         _readOnlyMap = new AtomicReference<ReadOnlyClassToSerializerMap>();
     }
 
-    private SerializerCache(SimpleLookupCache<TypeKey, JsonSerializer<Object>> shared) {
+    protected SerializerCache(SimpleLookupCache<TypeKey, JsonSerializer<Object>> shared) {
         _sharedMap = shared;
         _readOnlyMap = new AtomicReference<ReadOnlyClassToSerializerMap>();
     }

src/main/java/com/fasterxml/jackson/databind/type/TypeFactory.java

@@ -10,6 +10,7 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.util.ArrayBuilders;
 import com.fasterxml.jackson.databind.util.ClassUtil;
+import com.fasterxml.jackson.databind.util.LookupCache;
 import com.fasterxml.jackson.databind.util.SimpleLookupCache;
 
 /**
@@ -121,7 +122,7 @@ public final class TypeFactory
      * actual generic types), we will use small cache to avoid repetitive
      * resolution of core types
      */
-    protected final SimpleLookupCache<Object,JavaType> _typeCache;
+    protected final LookupCache<Object,JavaType> _typeCache;
 
     /*
     /**********************************************************************
@@ -150,7 +151,7 @@ private TypeFactory() {
         this(null);
     }
 
-    protected TypeFactory(SimpleLookupCache<Object,JavaType> typeCache) {
+    protected TypeFactory(LookupCache<Object,JavaType> typeCache) {
         if (typeCache == null) {
             typeCache = new SimpleLookupCache<Object,JavaType>(16, 200);
         }
@@ -159,7 +160,7 @@ protected TypeFactory(SimpleLookupCache<Object,JavaType> typeCache) {
         _classLoader = null;
     }
 
-    protected TypeFactory(SimpleLookupCache<Object,JavaType> typeCache,
+    protected TypeFactory(LookupCache<Object,JavaType> typeCache,
             TypeModifier[] mods, ClassLoader classLoader)
     {
         if (typeCache == null) {
@@ -190,7 +191,7 @@ public TypeFactory snapshot() {
      */
     public TypeFactory withModifier(TypeModifier mod) 
     {
-        SimpleLookupCache<Object,JavaType> typeCache = _typeCache;
+        LookupCache<Object,JavaType> typeCache = _typeCache;
         TypeModifier[] mods;
         if (mod == null) { // mostly for unit tests
             mods = null;
@@ -222,7 +223,7 @@ public TypeFactory withClassLoader(ClassLoader classLoader) {
      * identical settings except for different cache; most likely one with
      * bigger maximum size.
      */
-    public TypeFactory withCache(SimpleLookupCache<Object,JavaType> cache)  {
+    public TypeFactory withCache(LookupCache<Object,JavaType> cache)  {
         return new TypeFactory(cache, _modifiers, _classLoader);
     }
 

src/main/java/com/fasterxml/jackson/databind/util/LookupCache.java

@@ -0,0 +1,45 @@
+package com.fasterxml.jackson.databind.util;
+
+import com.fasterxml.jackson.core.util.Snapshottable;
+
+/**
+ * An interface describing the required API for the Jackson-Databind Type cache.
+ *<p>
+ * Note that while interface itself does not specify synchronization requirements for
+ * implementations, specific use cases do. Typically implementations are
+ * expected to be thread-safe, that is, to handle synchronization.
+ *
+ * @see com.fasterxml.jackson.databind.type.TypeFactory#withCache(LookupCache<java.lang.Object,com.fasterxml.jackson.databind.JavaType>)
+ * @see SimpleLookupCache
+ */
+public interface LookupCache <K,V>
+    extends Snapshottable<LookupCache<K,V>>
+{
+    // 17-Sep-2019, tatu: There is one usage, by `ReadOnlyClassToSerializerMap`, so
+    //    for now NOT exposed, but can reconsider if it proves generally useful
+    
+//    void contents(BiConsumer<K,V> consumer);
+
+    /**
+     * @return Number of entries currently in cache: may be approximate, only
+     *    to be used for diagnostics, metrics reporting
+     */
+    int size();
+
+    /**
+     * NOTE: key is of type Object only to retain binary backwards-compatibility
+     *
+     * @param key
+     * @return value associated with key (can return null)
+     */
+    V get(Object key);
+
+    V put(K key, V value);
+
+    V putIfAbsent(K key, V value);
+
+    /**
+     * Method for removing all contents this cache has.
+     */
+    void clear();
+}

src/main/java/com/fasterxml/jackson/databind/util/RootNameLookup.java

@@ -16,7 +16,7 @@ public class RootNameLookup implements java.io.Serializable
      * For efficient operation, let's try to minimize number of times we
      * need to introspect root element name to use.
      */
-    protected transient SimpleLookupCache<ClassKey,PropertyName> _rootNames;
+    protected transient LookupCache<ClassKey,PropertyName> _rootNames;
 
     public RootNameLookup() {
         _rootNames = new SimpleLookupCache<ClassKey,PropertyName>(20, 200);

src/main/java/com/fasterxml/jackson/databind/util/SimpleLookupCache.java

@@ -4,8 +4,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiConsumer;
 
-import com.fasterxml.jackson.core.util.Snapshottable;
-
 /**
  * Synchronized cache with bounded size: used for reusing lookup values
  * and lazily instantiated reusable items.
@@ -26,8 +24,7 @@
  * a shaded variant may be used one day.
  */
 public class SimpleLookupCache<K,V>
-    implements Snapshottable<SimpleLookupCache<K,V>>,
-        java.io.Serializable
+    implements LookupCache<K,V>, java.io.Serializable
 {
     private static final long serialVersionUID = 3L;
 
@@ -55,22 +52,17 @@ protected Object readResolve() {
     }
 
     @Override
-    public SimpleLookupCache<K, V> snapshot() {
+    public SimpleLookupCache<K,V> snapshot() {
         return new SimpleLookupCache<K,V>(_initialEntries, _maxEntries);
     }
 
-    public void contents(BiConsumer<K,V> consumer) {
-        for (Map.Entry<K,V> entry : _map.entrySet()) {
-            consumer.accept(entry.getKey(), entry.getValue());
-        }
-    }
-
     /*
     /**********************************************************************
-    /* Public API
+    /* Public API, basic lookup/additions
     /**********************************************************************
      */
 
+    @Override
     public V put(K key, V value) {
         if (_map.size() >= _maxEntries) {
             // double-locking, yes, but safe here; trying to avoid "clear storms"
@@ -83,6 +75,7 @@ public V put(K key, V value) {
         return _map.put(key, value);
     }
 
+    @Override
     public V putIfAbsent(K key, V value) {
         // not 100% optimal semantically, but better from correctness (never exceeds
         // defined maximum) and close enough all in all:
@@ -96,9 +89,24 @@ public V putIfAbsent(K key, V value) {
         return _map.putIfAbsent(key, value);
     }
 
-    // NOTE: key is of type Object only to retain binary backwards-compatibility
+    @Override
     public V get(Object key) {  return _map.get(key); }
 
+    @Override
     public void clear() { _map.clear(); }
+
+    @Override
     public int size() { return _map.size(); }
+
+    /*
+    /**********************************************************************
+    /* Extended API
+    /**********************************************************************
+     */
+    
+    public void contents(BiConsumer<K,V> consumer) {
+        for (Map.Entry<K,V> entry : _map.entrySet()) {
+            consumer.accept(entry.getKey(), entry.getValue());
+        }
+    }
 }

src/test/java/com/fasterxml/jackson/databind/util/UnlimitedLookupCache.java

@@ -0,0 +1,60 @@
+package com.fasterxml.jackson.databind.util;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A LookupCache implementation that has no synchronization (like SimpleLookupCache does)
+ * but that has the downside of not limiting the size of the cache.
+ */
+public class UnlimitedLookupCache<K,V> implements LookupCache<K,V> {
+
+    private final int _initialEntries, _maxEntries;
+    private final transient ConcurrentHashMap<K,V> _map;
+
+    public UnlimitedLookupCache(int initialEntries, int maxEntries)
+    {
+        _initialEntries = initialEntries;
+        _maxEntries = maxEntries;
+        // We'll use concurrency level of 4, seems reasonable
+        _map = new ConcurrentHashMap<K,V>(initialEntries, 0.8f, 4);
+    }
+
+    @Override
+    public LookupCache<K, V> snapshot() {
+        return new UnlimitedLookupCache<K,V>(_initialEntries, _maxEntries);
+    }
+
+    /*
+    @Override
+    public void contents(BiConsumer<K, V> consumer) {
+        for (Map.Entry<K,V> entry : _map.entrySet()) {
+            consumer.accept(entry.getKey(), entry.getValue());
+        }
+    }
+    */
+
+    @Override
+    public int size() {
+        return _map.size();
+    }
+
+    @Override
+    public V get(Object key) {
+        return _map.get(key);
+    }
+
+    @Override
+    public V put(K key, V value) {
+        return _map.put(key, value);
+    }
+
+    @Override
+    public V putIfAbsent(K key, V value) {
+        return _map.putIfAbsent(key, value);
+    }
+
+    @Override
+    public void clear() {
+        _map.clear();
+    }
+}

src/test/java/com/fasterxml/jackson/databind/util/UnlimitedLookupCacheTest.java

@@ -0,0 +1,39 @@
+package com.fasterxml.jackson.databind.util;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.type.TypeFactory;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+public class UnlimitedLookupCacheTest {
+    @Test
+    public void testCache() {
+        UnlimitedLookupCache<Long, String> cache = new UnlimitedLookupCache<>(4, 10);
+        assertNull(cache.get(1000L));
+        assertNull(cache.put(1000L, "Thousand"));
+        assertEquals("Thousand", cache.get(1000L));
+        assertEquals("Thousand", cache.putIfAbsent(1000L, "Míle"));
+        assertEquals("Thousand", cache.get(1000L));
+        assertEquals("Thousand", cache.put(1000L, "Míle"));
+        assertEquals("Míle", cache.get(1000L));
+        cache.clear();
+        assertNull(cache.put(1000L, "Thousand"));
+    }
+
+    @Test
+    public void testCompatibility() throws JsonProcessingException {
+        UnlimitedLookupCache<Object, JavaType> cache = new UnlimitedLookupCache<>(4, 10);
+        TypeFactory tf = TypeFactory.defaultInstance().withCache(cache);
+        assertNotNull(tf); // just to get rid of warning
+        
+        //TODO find way to inject the `tf` instance into an ObjectMapper (via MapperBuilder?)
+
+        //ObjectMapper mapper = new ObjectMapper();
+        //mapper.setTypeFactory(tf);
+        //assertEquals("1000", mapper.writeValueAsString(1000));
+    }
+}