Fix : Cannot read Optionals written with StdTypeResolverBuilder, from [jackson-modules-java8#86]

release-notes/VERSION-2.x

@@ -32,11 +32,15 @@ Project: jackson-databind
 #4773: `SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS` should not apply to Maps
   with uncomparable keys
  (requested by @nathanukey)
+#4850: Cannot read reference types written with `StdTypeResolverBuilder`
+  (reported by @isopov)
+  (fix by Joo-Hyuk K)
 
 2.18.3 (not yet released)
 
 #4827: Subclassed Throwable deserialization fails since v2.18.0 - no creator
   index for property 'cause'
+ (reported by @nilswieber)
  (fix by Joo-Hyuk K)
 #4844: Fix wrapped array hanlding wrt `null` by `StdDeserializer`
  (fix by Stanislav S)

src/main/java/com/fasterxml/jackson/databind/deser/std/ReferenceTypeDeserializer.java

@@ -257,6 +257,9 @@ public Object deserializeWithType(JsonParser p, DeserializationContext ctxt,
         if (_valueTypeDeserializer == null) {
             return deserialize(p, ctxt);
         }
-        return referenceValue(_valueTypeDeserializer.deserializeTypedFromAny(p, ctxt));
+        // [modules-java8#86] Since 2.19.0, Cannot read `Optional`s written with `StdTypeResolverBuilder`
+        return typeDeserializer.deserializeTypedFromAny(p, ctxt);
+        // Previously was...
+        // return referenceValue(_valueTypeDeserializer.deserializeTypedFromAny(p, ctxt));
     }
 }

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

@@ -5,6 +5,8 @@
 import com.fasterxml.jackson.annotation.JsonInclude;
 
 import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.core.type.WritableTypeId;
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.fasterxml.jackson.databind.introspect.Annotated;
@@ -408,17 +410,14 @@ public void serializeWithType(T ref,
         //    (which is what non-polymorphic serialization does too), we will need
         //    to simply delegate call, I think, and NOT try to use it here.
 
-        // Otherwise apply type-prefix/suffix, then std serialize:
-        /*
-        typeSer.writeTypePrefixForScalar(ref, g);
-        serialize(ref, g, provider);
-        typeSer.writeTypeSuffixForScalar(ref, g);
-        */
+        // [modules-java8#86] Since 2.19.0, Bringing back the prefix and suffix writing part
+        WritableTypeId typeId = typeSer.writeTypePrefix(g, typeSer.typeId(ref, JsonToken.VALUE_STRING));
         JsonSerializer<Object> ser = _valueSerializer;
         if (ser == null) {
             ser = _findCachedSerializer(provider, value.getClass());
         }
         ser.serializeWithType(value, g, provider, typeSer);
+        typeSer.writeTypeSuffix(g, typeId);
     }
 
     /*

src/test/java/com/fasterxml/jackson/databind/deser/enums/EnumSetPolymorphicDeser4214Test.java

@@ -11,6 +11,7 @@
 import com.fasterxml.jackson.databind.jsontype.BasicPolymorphicTypeValidator;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import static com.fasterxml.jackson.databind.testutil.DatabindTestUtil.jsonMapperBuilder;
 
@@ -48,5 +49,6 @@ public void testPolymorphicDeserialization4214() throws Exception
         String json = mapper.writeValueAsString(enumSetHolder);
         EnumSetHolder result = mapper.readValue(json, EnumSetHolder.class);
         assertEquals(result, enumSetHolder);
+        assertTrue(result.enumSet instanceof EnumSet<?>);
     }
 }

src/test/java/com/fasterxml/jackson/databind/deser/jdk/AtomicReferenceWithStdTypeResolverBuilder4838Test.java

@@ -0,0 +1,109 @@
+package com.fasterxml.jackson.databind.deser.jdk;
+
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.jsontype.impl.StdTypeResolverBuilder;
+import com.fasterxml.jackson.databind.testutil.DatabindTestUtil;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+// Reported via [modules-java8#86] Cannot read `Optional`s written with `StdTypeResolverBuilder`
+public class AtomicReferenceWithStdTypeResolverBuilder4838Test
+        extends DatabindTestUtil
+{
+
+    public static class Foo<T> {
+        public AtomicReference<T> value;
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Foo<?> foo = (Foo<?>) o;
+            return Objects.equals(value.get(), foo.value.get());
+        }
+    }
+
+    public static class Pojo86 {
+        public String name;
+
+        public static Pojo86 valueOf(String name) {
+            Pojo86 pojo = new Pojo86();
+            pojo.name = name;
+            return pojo;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            Pojo86 pojo86 = (Pojo86) o;
+            return Objects.equals(name, pojo86.name);
+        }
+    }
+
+    @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS, include = JsonTypeInfo.As.WRAPPER_OBJECT)
+    public static abstract class Animal {
+        public String name;
+
+        protected Animal(String name) {
+            this.name = name;
+        }
+    }
+
+    public static class Dog extends Animal {
+        @JsonCreator
+        public Dog(@JsonProperty("name") String name) {
+            super(name);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            return (obj instanceof Dog) && name.equals(((Dog) obj).name);
+        }
+    }
+
+    @Test
+    public void testRoundTrip() throws Exception {
+        _test(new AtomicReference<>("MyName"), String.class);
+        _test(new AtomicReference<>(42), Integer.class);
+        _test(new AtomicReference<>(Pojo86.valueOf("PojoName")), Pojo86.class);
+    }
+
+    @Test
+    public void testPolymorphic() throws Exception {
+        _test(new AtomicReference<>(new Dog("Buddy")), Animal.class);
+    }
+
+    private <T> void _test(AtomicReference<T> value, Class<?> type) throws Exception {
+        ObjectMapper mapper = configureObjectMapper();
+
+        // Serialize
+        Foo<T> foo = new Foo<>();
+        foo.value = value;
+        String json = mapper.writeValueAsString(foo);
+
+        // Deserialize
+        Foo<T> bean = mapper.readValue(json, mapper.getTypeFactory().constructParametricType(Foo.class, type));
+
+        // Compare the underlying values of AtomicReference
+        assertEquals(foo.value.get(), bean.value.get());
+    }
+
+    private ObjectMapper configureObjectMapper() {
+        return jsonMapperBuilder()
+                // this is what's causing failure in later versions.....
+                .setDefaultTyping(
+                    new StdTypeResolverBuilder()
+                            .init(JsonTypeInfo.Id.CLASS, null)
+                            .inclusion(JsonTypeInfo.As.WRAPPER_OBJECT)
+                ).build();
+    }
+}