Add SerializerProvider.findContentValueSerializer() methods, change serializers to use where applicable

Author: cowtowncoder

release-notes/VERSION-2.x

@@ -11,6 +11,7 @@ Project: jackson-databind
 #2503: Support `@JsonSerialize(keyUsing)` and `@JsonDeserialize(keyUsing)` on Key class
 #2511: Add `SerializationFeature.WRITE_SELF_REFERENCES_AS_NULL`
  (contributed by Joongsoo P)
+- Add `SerializerProvider.findContentValueSerializer()` methods
 
 2.10.1 (not yet released)
 

src/main/java/com/fasterxml/jackson/databind/SerializerProvider.java

@@ -624,6 +624,7 @@ public JsonSerializer<Object> findValueSerializer(JavaType valueType)
      * and method(s) called: this method should only be called when caller is
      * certain that this is the primary property value serializer.
      * 
+     * @param valueType Type of values to serialize
      * @param property Property that is being handled; will never be null, and its
      *    type has to match <code>valueType</code> parameter.
      * 
@@ -652,6 +653,8 @@ public JsonSerializer<Object> findPrimaryPropertySerializer(JavaType valueType,
     }
 
     /**
+     * See {@link #findPrimaryPropertySerializer(JavaType, BeanProperty)}
+     *
      * @since 2.3
      */
     @SuppressWarnings("unchecked")
@@ -678,7 +681,79 @@ public JsonSerializer<Object> findPrimaryPropertySerializer(Class<?> valueType,
         }
         return (JsonSerializer<Object>) handlePrimaryContextualization(ser, property);
     }
-    
+
+    /**
+     * Alternative to {@link #findPrimaryPropertySerializer(JavaType, BeanProperty)} called not
+     * for primary value, but "content" of such primary serializer: element of an array or
+     * {@link java.util.Collection}, value of {@link java.util.Map} entry and so on.
+     * This means that {@code property} passed (if any) does NOT represent value for which
+     * serializer is requested but its secondary type (or secondary type of that type,
+     * recursively).
+     *<p>
+     * Serializer returned SHOULD NOT handle type information; caller will (have to) add
+     * suitable wrapping if necessary.
+     *<p>
+     * Note: this call will also contextualize serializer (call {@code createContextual()}
+     * before returning it, if applicable (implements {@code ContextualSerializer})
+     *
+     * @param valueType Type of values to serialize
+     * @param property Property that indirectly refers to value being serialized (optional,
+     *    may be {@code null} for root level serializers)
+     *
+     * @since 2.11
+     */
+    @SuppressWarnings("unchecked")
+    public JsonSerializer<Object> findContentValueSerializer(JavaType valueType, BeanProperty property)
+            throws JsonMappingException
+    {
+        JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(valueType);
+        if (ser == null) {
+            ser = _serializerCache.untypedValueSerializer(valueType);
+            if (ser == null) {
+                ser = _createAndCacheUntypedSerializer(valueType);
+                if (ser == null) {
+                    ser = getUnknownTypeSerializer(valueType.getRawClass());
+                    // Should this be added to lookups?
+                    if (CACHE_UNKNOWN_MAPPINGS) {
+                        _serializerCache.addAndResolveNonTypedSerializer(valueType, ser, this);
+                    }
+                    return ser;
+                }
+            }
+        }
+        return (JsonSerializer<Object>) handleSecondaryContextualization(ser, property);
+    }
+
+    /**
+     * See {@link #findContentValueSerializer(JavaType, BeanProperty)}.
+     *
+     * @since 2.11
+     */
+    @SuppressWarnings("unchecked")
+    public JsonSerializer<Object> findContentValueSerializer(Class<?> valueType,
+            BeanProperty property)
+        throws JsonMappingException
+    {
+        JsonSerializer<Object> ser = _knownSerializers.untypedValueSerializer(valueType);
+        if (ser == null) {
+            ser = _serializerCache.untypedValueSerializer(valueType);
+            if (ser == null) {
+                ser = _serializerCache.untypedValueSerializer(_config.constructType(valueType));
+                if (ser == null) {
+                    ser = _createAndCacheUntypedSerializer(valueType);
+                    if (ser == null) {
+                        ser = getUnknownTypeSerializer(valueType);
+                        if (CACHE_UNKNOWN_MAPPINGS) {
+                            _serializerCache.addAndResolveNonTypedSerializer(valueType, ser, this);
+                        }
+                        return ser;
+                    }
+                }
+            }
+        }
+        return (JsonSerializer<Object>) handleSecondaryContextualization(ser, property);
+    }
+
     /**
      * Method called to locate regular serializer, matching type serializer,
      * and if both found, wrap them in a serializer that calls both in correct
@@ -1383,10 +1458,10 @@ protected JsonSerializer<Object> _createUntypedSerializer(JavaType type)
         //    versions, likely due to concurrency fixes for `AnnotatedClass` introspection.
         //    This sync block could probably be removed; but to minimize any risk of
         //    regression sync block will only be removed from 3.0.
-        synchronized (_serializerCache) {
-            // 17-Feb-2013, tatu: Used to call deprecated method (that passed property)
+        // 23-Oct-2019, tatu: Due to continuation of 2.x line, removed from 2.11
+//        synchronized (_serializerCache) {
             return (JsonSerializer<Object>)_serializerFactory.createSerializer(this, type);
-        }
+//        }
     }
 
     /**

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

@@ -80,7 +80,7 @@ public ContainerSerializer<?> withValueTypeSerializer(TypeSerializer vts) {
      * known statically.
      * Note that for dynamic types this may return null; if so,
      * caller has to instead use {@link #getContentType()} and
-     * {@link com.fasterxml.jackson.databind.SerializerProvider#findValueSerializer}.
+     * {@link com.fasterxml.jackson.databind.SerializerProvider#findContentValueSerializer}.
      */
     public abstract JsonSerializer<?> getContentSerializer();
 

src/main/java/com/fasterxml/jackson/databind/ser/impl/MapEntrySerializer.java

@@ -209,7 +209,7 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,
             //   we can consider it a static case as well.
             // 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho
             if (_valueTypeIsStatic && !_valueType.isJavaLangObject()) {
-                ser = provider.findValueSerializer(_valueType, property);
+                ser = provider.findContentValueSerializer(_valueType, property);
             }
         }
         if (keySer == null) {

src/main/java/com/fasterxml/jackson/databind/ser/impl/PropertySerializerMap.java

@@ -87,15 +87,15 @@ public final SerializerAndMapResult findAndAddSecondarySerializer(Class<?> type,
             SerializerProvider provider, BeanProperty property)
         throws JsonMappingException
     {
-        JsonSerializer<Object> serializer = provider.findValueSerializer(type, property);
+        JsonSerializer<Object> serializer = provider.findContentValueSerializer(type, property);
         return new SerializerAndMapResult(serializer, newWith(type, serializer));
     }
 
     public final SerializerAndMapResult findAndAddSecondarySerializer(JavaType type,
             SerializerProvider provider, BeanProperty property)
         throws JsonMappingException
     {
-        JsonSerializer<Object> serializer = provider.findValueSerializer(type, property);
+        JsonSerializer<Object> serializer = provider.findContentValueSerializer(type, property);
         return new SerializerAndMapResult(serializer, newWith(type.getRawClass(), serializer));
     }
 

src/main/java/com/fasterxml/jackson/databind/ser/impl/StringArraySerializer.java

@@ -109,7 +109,7 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,
         // May have a content converter
         ser = findContextualConvertingSerializer(provider, property, ser);
         if (ser == null) {
-            ser = provider.findValueSerializer(String.class, property);
+            ser = provider.findContentValueSerializer(String.class, property);
         }
         // Optimization: default serializer just writes String, so we can avoid a call:
         if (isDefaultSerializer(ser)) {

src/main/java/com/fasterxml/jackson/databind/ser/std/AsArraySerializerBase.java

@@ -198,7 +198,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
             //   we can consider it a static case as well.
             if (_elementType != null) {
                 if (_staticTyping && !_elementType.isJavaLangObject()) {
-                    ser = serializers.findValueSerializer(_elementType, property);
+                    ser = serializers.findContentValueSerializer(_elementType, property);
                 }
             }
         }
@@ -292,7 +292,7 @@ public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType t
             // 19-Oct-2016, tatu: Apparently we get null for untyped/raw `EnumSet`s... not 100%
             //   sure what'd be the clean way but let's try this for now:
             if (_elementType != null) {
-                valueSer = visitor.getProvider().findValueSerializer(_elementType, _property);
+                valueSer = visitor.getProvider().findContentValueSerializer(_elementType, _property);
             }
         }
         visitArrayFormat(visitor, typeHint, valueSer, _elementType);

src/main/java/com/fasterxml/jackson/databind/ser/std/EnumSetSerializer.java

@@ -79,7 +79,7 @@ public void serializeContents(EnumSet<? extends Enum<?>> value, JsonGenerator ge
             if (enumSer == null) {
                 // 12-Jan-2010, tatu: Since enums cannot be polymorphic, let's
                 //   not bother with typed serializer variant here
-                enumSer = provider.findValueSerializer(en.getDeclaringClass(), _property);
+                enumSer = provider.findContentValueSerializer(en.getDeclaringClass(), _property);
             }
             enumSer.serialize(en, gen, provider);
         }

src/main/java/com/fasterxml/jackson/databind/ser/std/MapSerializer.java

@@ -421,7 +421,7 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,
             //   we can consider it a static case as well.
             // 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho
             if (_valueTypeIsStatic && !_valueType.isJavaLangObject()) {
-                ser = provider.findValueSerializer(_valueType, property);
+                ser = provider.findContentValueSerializer(_valueType, property);
             }
         }
         if (keySer == null) {

src/main/java/com/fasterxml/jackson/databind/ser/std/ObjectArraySerializer.java

@@ -158,7 +158,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
             //   we can consider it a static case as well.
             if (_elementType != null) {
                 if (_staticTyping && !_elementType.isJavaLangObject()) {
-                    ser = serializers.findValueSerializer(_elementType, property);
+                    ser = serializers.findContentValueSerializer(_elementType, property);
                 }
             }
         }
@@ -327,7 +327,7 @@ public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType t
 */
             JsonSerializer<?> valueSer = _elementSerializer;
             if (valueSer == null) {
-                valueSer = visitor.getProvider().findValueSerializer(contentType, _property);
+                valueSer = visitor.getProvider().findContentValueSerializer(contentType, _property);
             }
             arrayVisitor.itemsFormat(valueSer, contentType);
         }

src/main/java/com/fasterxml/jackson/databind/ser/std/ReferenceTypeSerializer.java

@@ -454,9 +454,9 @@ private final JsonSerializer<Object> _findCachedSerializer(SerializerProvider pr
                 // [databind#1673] Must ensure we will resolve all available type information
                 //  so as not to miss generic declaration of, say, `List<GenericPojo>`...
                 JavaType fullType = provider.constructSpecializedType(_referredType, rawType);
-                ser = provider.findValueSerializer(fullType, _property);
+                ser = provider.findContentValueSerializer(fullType, _property);
             } else {
-                ser = provider.findValueSerializer(rawType, _property);
+                ser = provider.findContentValueSerializer(rawType, _property);
             }
             if (_unwrapper != null) {
                 ser = ser.unwrappingSerializer(_unwrapper);
@@ -474,6 +474,6 @@ private final JsonSerializer<Object> _findSerializer(SerializerProvider provider
         // 15-Jan-2017, tatu: ... possibly because we need to access "secondary" serializer,
         //   not primary (primary being one for Reference type itself, not value)
 //        return provider.findTypedValueSerializer(type, true, prop);
-        return provider.findValueSerializer(type, prop);
+        return provider.findContentValueSerializer(type, prop);
     }
 }

src/main/java/com/fasterxml/jackson/databind/ser/std/StaticListSerializerBase.java

@@ -83,7 +83,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
         // [databind#124]: May have a content converter
         ser = findContextualConvertingSerializer(serializers, property, ser);
         if (ser == null) {
-            ser = serializers.findValueSerializer(String.class, property);
+            ser = serializers.findContentValueSerializer(String.class, property);
         }
         // Optimization: default serializer just writes String, so we can avoid a call:
         if (isDefaultSerializer(ser)) {