Start working on proper fix for #357

cowtowncoder · cowtowncoder · commit c799b427b695 · 2016-12-09T10:55:01.000-08:00
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/MapEntrySerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/MapEntrySerializer.java
@@ -201,16 +201,14 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,
             ser = _valueSerializer;
         }
         // [databind#124]: May have a content converter
-        ser = findConvertingContentSerializer(provider, property, ser);
+        ser = findContextualConvertingSerializer(provider, property, ser);
         if (ser == null) {
             // 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,
             //   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);
             }
-        } else {
-            ser = provider.handleSecondaryContextualization(ser, property);
         }
         if (keySer == null) {
             keySer = _keySerializer;
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/impl/StringArraySerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/impl/StringArraySerializer.java
@@ -107,11 +107,9 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,
             ser = _elementSerializer;
         }
         // May have a content converter
-        ser = findConvertingContentSerializer(provider, property, ser);
+        ser = findContextualConvertingSerializer(provider, property, ser);
         if (ser == null) {
             ser = provider.findValueSerializer(String.class, property);
-        } else {
-            ser = provider.handleSecondaryContextualization(ser, property);
         }
         // Optimization: default serializer just writes String, so we can avoid a call:
         if (isDefaultSerializer(ser)) {
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/AsArraySerializerBase.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/AsArraySerializerBase.java
@@ -191,7 +191,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
             ser = _elementSerializer;
         }
         // 18-Feb-2013, tatu: May have a content converter:
-        ser = findConvertingContentSerializer(serializers, property, ser);
+        ser = findContextualConvertingSerializer(serializers, property, ser);
         if (ser == null) {
             // 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,
             //   we can consider it a static case as well.
@@ -200,8 +200,6 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
                     ser = serializers.findValueSerializer(_elementType, property);
                 }
             }
-        } else {
-            ser = serializers.handleSecondaryContextualization(ser, property);
         }
         if ((ser != _elementSerializer)
                 || (property != _property)
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/MapSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/MapSerializer.java
@@ -415,16 +415,14 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,
             ser = _valueSerializer;
         }
         // [databind#124]: May have a content converter
-        ser = findConvertingContentSerializer(provider, property, ser);
+        ser = findContextualConvertingSerializer(provider, property, ser);
         if (ser == null) {
             // 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,
             //   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);
             }
-        } else {
-            ser = provider.handleSecondaryContextualization(ser, property);
         }
         if (keySer == null) {
             keySer = _keySerializer;
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/ObjectArraySerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/ObjectArraySerializer.java
@@ -150,7 +150,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
             ser = _elementSerializer;
         }
         // [databind#124]: May have a content converter
-        ser = findConvertingContentSerializer(serializers, property, ser);
+        ser = findContextualConvertingSerializer(serializers, property, ser);
         if (ser == null) {
             // 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,
             //   we can consider it a static case as well.
@@ -159,8 +159,6 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
                     ser = serializers.findValueSerializer(_elementType, property);
                 }
             }
-        } else {
-            ser = serializers.handleSecondaryContextualization(ser, property);
         }
         return withResolved(property, vts, ser, unwrapSingle);
     }
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/StaticListSerializerBase.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/StaticListSerializerBase.java
@@ -78,11 +78,9 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
             unwrapSingle = format.getFeature(JsonFormat.Feature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED);
         }
         // [databind#124]: May have a content converter
-        ser = findConvertingContentSerializer(serializers, property, ser);
+        ser = findContextualConvertingSerializer(serializers, property, ser);
         if (ser == null) {
             ser = serializers.findValueSerializer(String.class, property);
-        } else {
-            ser = serializers.handleSecondaryContextualization(ser, property);
         }
         // Optimization: default serializer just writes String, so we can avoid a call:
         if (isDefaultSerializer(ser)) {
@@ -91,8 +89,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,
             }
             return _withResolved(property, unwrapSingle);
         }
-        // otherwise
-
+        // otherwise...
         // note: will never have TypeSerializer, because Strings are "natural" type
         return new CollectionSerializer(serializers.constructType(String.class),
                 true, /*TypeSerializer*/ null, (JsonSerializer<Object>) ser);
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/StdDelegatingSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/StdDelegatingSerializer.java
@@ -160,11 +160,15 @@ public void serialize(Object value, JsonGenerator gen, SerializerProvider provid
             provider.defaultSerializeNull(gen);
             return;
         }
+System.err.println(" delegating.serialize. value: "+value.getClass());
+
         // 02-Apr-2015, tatu: As per [databind#731] may need to do dynamic lookup
         JsonSerializer<Object> ser = _delegateSerializer;
         if (ser == null) {
+System.err.println("DEBUG: dynamic lookup for delegator... ");            
             ser = _findSerializer(delegateValue, provider);
         }
+System.err.println(" delegating.serialize with -> "+ser);
         ser.serialize(delegateValue, gen, provider);
     }
 
diff --git a/src/main/java/com/fasterxml/jackson/databind/ser/std/StdSerializer.java b/src/main/java/com/fasterxml/jackson/databind/ser/std/StdSerializer.java
@@ -3,6 +3,8 @@
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Type;
+import java.util.HashSet;
+import java.util.Set;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonInclude;
@@ -345,8 +347,42 @@ public void wrapAndThrow(SerializerProvider provider,
      * @param existingSerializer (optional) configured content
      *    serializer if one already exists.
      * 
-     * @since 2.2
+     * @since 2.9
      */
+    protected JsonSerializer<?> findContextualConvertingSerializer(SerializerProvider provider,
+            BeanProperty property, JsonSerializer<?> existingSerializer)
+        throws JsonMappingException
+    {
+        // 08-Dec-2016, tatu: to fix [databind#357], need to prevent recursive calls for
+        //     same property
+        /*
+        @SuppressWarnings("unchecked")
+        Set<Object> conversions = (Set<Object>) provider.getAttribute(CONTENT_CONVERTER_LOCK);
+        if (conversions != null) {
+            if (conversions.contains(property)) {
+                return existingSerializer;
+            }
+        } else {
+            conversions = new HashSet<>();
+            provider.setAttribute(CONTENT_CONVERTER_LOCK, provider);
+        }
+        try {
+        } finally {
+        }
+        */
+            JsonSerializer<?> ser = findConvertingContentSerializer(provider, property, existingSerializer);
+            if (ser != null) {
+                return provider.handleSecondaryContextualization(ser, property);
+            }
+        return existingSerializer;
+    }
+
+//    private final static Object CONTENT_CONVERTER_LOCK = new Object();
+
+    /**
+     * @deprecated Since 2.9 use {link {@link #findContextualConvertingSerializer} instead
+     */
+    @Deprecated
     protected JsonSerializer<?> findConvertingContentSerializer(SerializerProvider provider,
             BeanProperty prop, JsonSerializer<?> existingSerializer)
         throws JsonMappingException

Original file line number	Diff line number	Diff line change
`@@ -201,16 +201,14 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,`
`201`	`201`	`ser = _valueSerializer;`
`202`	`202`	`}`
`203`	`203`	`// [databind#124]: May have a content converter`
`204`		`- ser = findConvertingContentSerializer(provider, property, ser);`
	`204`	`+ ser = findContextualConvertingSerializer(provider, property, ser);`
`205`	`205`	`if (ser == null) {`
`206`	`206`	`// 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,`
`207`	`207`	`// we can consider it a static case as well.`
`208`	`208`	`// 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho`
`209`	`209`	`if (_valueTypeIsStatic && !_valueType.isJavaLangObject()) {`
`210`	`210`	`ser = provider.findValueSerializer(_valueType, property);`
`211`	`211`	`}`
`212`		`- } else {`
`213`		`- ser = provider.handleSecondaryContextualization(ser, property);`
`214`	`212`	`}`
`215`	`213`	`if (keySer == null) {`
`216`	`214`	`keySer = _keySerializer;`
Original file line number	Diff line number	Diff line change
`@@ -107,11 +107,9 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,`
`107`	`107`	`ser = _elementSerializer;`
`108`	`108`	`}`
`109`	`109`	`// May have a content converter`
`110`		`- ser = findConvertingContentSerializer(provider, property, ser);`
	`110`	`+ ser = findContextualConvertingSerializer(provider, property, ser);`
`111`	`111`	`if (ser == null) {`
`112`	`112`	`ser = provider.findValueSerializer(String.class, property);`
`113`		`- } else {`
`114`		`- ser = provider.handleSecondaryContextualization(ser, property);`
`115`	`113`	`}`
`116`	`114`	`// Optimization: default serializer just writes String, so we can avoid a call:`
`117`	`115`	`if (isDefaultSerializer(ser)) {`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,`
`191`	`191`	`ser = _elementSerializer;`
`192`	`192`	`}`
`193`	`193`	`// 18-Feb-2013, tatu: May have a content converter:`
`194`		`- ser = findConvertingContentSerializer(serializers, property, ser);`
	`194`	`+ ser = findContextualConvertingSerializer(serializers, property, ser);`
`195`	`195`	`if (ser == null) {`
`196`	`196`	`// 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,`
`197`	`197`	`// we can consider it a static case as well.`
`@@ -200,8 +200,6 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,`
`200`	`200`	`ser = serializers.findValueSerializer(_elementType, property);`
`201`	`201`	`}`
`202`	`202`	`}`
`203`		`- } else {`
`204`		`- ser = serializers.handleSecondaryContextualization(ser, property);`
`205`	`203`	`}`
`206`	`204`	`if ((ser != _elementSerializer)`
`207`	`205`	`\|\| (property != _property)`
Original file line number	Diff line number	Diff line change
`@@ -415,16 +415,14 @@ public JsonSerializer<?> createContextual(SerializerProvider provider,`
`415`	`415`	`ser = _valueSerializer;`
`416`	`416`	`}`
`417`	`417`	`// [databind#124]: May have a content converter`
`418`		`- ser = findConvertingContentSerializer(provider, property, ser);`
	`418`	`+ ser = findContextualConvertingSerializer(provider, property, ser);`
`419`	`419`	`if (ser == null) {`
`420`	`420`	`// 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,`
`421`	`421`	`// we can consider it a static case as well.`
`422`	`422`	`// 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho`
`423`	`423`	`if (_valueTypeIsStatic && !_valueType.isJavaLangObject()) {`
`424`	`424`	`ser = provider.findValueSerializer(_valueType, property);`
`425`	`425`	`}`
`426`		`- } else {`
`427`		`- ser = provider.handleSecondaryContextualization(ser, property);`
`428`	`426`	`}`
`429`	`427`	`if (keySer == null) {`
`430`	`428`	`keySer = _keySerializer;`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,`
`150`	`150`	`ser = _elementSerializer;`
`151`	`151`	`}`
`152`	`152`	`// [databind#124]: May have a content converter`
`153`		`- ser = findConvertingContentSerializer(serializers, property, ser);`
	`153`	`+ ser = findContextualConvertingSerializer(serializers, property, ser);`
`154`	`154`	`if (ser == null) {`
`155`	`155`	`// 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,`
`156`	`156`	`// we can consider it a static case as well.`
`@@ -159,8 +159,6 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,`
`159`	`159`	`ser = serializers.findValueSerializer(_elementType, property);`
`160`	`160`	`}`
`161`	`161`	`}`
`162`		`- } else {`
`163`		`- ser = serializers.handleSecondaryContextualization(ser, property);`
`164`	`162`	`}`
`165`	`163`	`return withResolved(property, vts, ser, unwrapSingle);`
`166`	`164`	`}`
Original file line number	Diff line number	Diff line change
`@@ -78,11 +78,9 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,`
`78`	`78`	`unwrapSingle = format.getFeature(JsonFormat.Feature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED);`
`79`	`79`	`}`
`80`	`80`	`// [databind#124]: May have a content converter`
`81`		`- ser = findConvertingContentSerializer(serializers, property, ser);`
	`81`	`+ ser = findContextualConvertingSerializer(serializers, property, ser);`
`82`	`82`	`if (ser == null) {`
`83`	`83`	`ser = serializers.findValueSerializer(String.class, property);`
`84`		`- } else {`
`85`		`- ser = serializers.handleSecondaryContextualization(ser, property);`
`86`	`84`	`}`
`87`	`85`	`// Optimization: default serializer just writes String, so we can avoid a call:`
`88`	`86`	`if (isDefaultSerializer(ser)) {`
`@@ -91,8 +89,7 @@ public JsonSerializer<?> createContextual(SerializerProvider serializers,`
`91`	`89`	`}`
`92`	`90`	`return _withResolved(property, unwrapSingle);`
`93`	`91`	`}`
`94`		`- // otherwise`
`95`		`-`
	`92`	`+ // otherwise...`
`96`	`93`	`// note: will never have TypeSerializer, because Strings are "natural" type`
`97`	`94`	`return new CollectionSerializer(serializers.constructType(String.class),`
`98`	`95`	`true, /TypeSerializer/ null, (JsonSerializer<Object>) ser);`
Original file line number	Diff line number	Diff line change
`@@ -160,11 +160,15 @@ public void serialize(Object value, JsonGenerator gen, SerializerProvider provid`
`160`	`160`	`provider.defaultSerializeNull(gen);`
`161`	`161`	`return;`
`162`	`162`	`}`
	`163`	`+System.err.println(" delegating.serialize. value: "+value.getClass());`
	`164`	`+`
`163`	`165`	`// 02-Apr-2015, tatu: As per [databind#731] may need to do dynamic lookup`
`164`	`166`	`JsonSerializer<Object> ser = _delegateSerializer;`
`165`	`167`	`if (ser == null) {`
	`168`	`+System.err.println("DEBUG: dynamic lookup for delegator... ");`
`166`	`169`	`ser = _findSerializer(delegateValue, provider);`
`167`	`170`	`}`
	`171`	`+System.err.println(" delegating.serialize with -> "+ser);`
`168`	`172`	`ser.serialize(delegateValue, gen, provider);`
`169`	`173`	`}`
`170`	`174`