Fix #5006: add MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS

Author: cowtowncoder

release-notes/VERSION-2.x

@@ -67,6 +67,8 @@ Project: jackson-databind
 #4963: Serializing `Map.Entry` as Bean with `@JsonFormat.shape = Shape.OBJECT`
   fails on JDK 17+
 #4997: `ObjectNode` put methods should do null check for key
+#5006: Add `MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS` to prevent
+  failure of `java.util.Optional` (de)serialization without Java 8 module
 #5014: Add `java.lang.Runnable` as unsafe base type in `DefaultBaseTypeLimitingValidator`
 #5020: Support new `@JsonProperty.isRequired` for overridable definition of "required-ness"
 

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

@@ -647,7 +647,21 @@ public enum MapperFeature implements ConfigFeature
      *
      * @since 2.13
      */
-    APPLY_DEFAULT_VALUES(true)
+    APPLY_DEFAULT_VALUES(true),
+
+    /**
+     * Feature that determines what happens if Java 8 {@link java.util.Optional} (and
+     * other related optional types) are to be serialized or deserialized, but there
+     * are no registered handlers for them.
+     * If enabled, an exception is thrown (to indicate problem, a solution for which is
+     * to register {@code jackson-datatype-jdk8} module); if disabled, the value is
+     * serialized and/or deserialized using regular POJO ("Bean") (de)serialization.
+     *<p>
+     * Feature is enabled by default.
+     *
+     * @since 2.19
+     */
+    REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS(true)
     ;
 
     private final boolean _defaultState;

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

@@ -208,7 +208,7 @@ protected JsonDeserializer<Object> _findUnsupportedTypeDeserializer(Deserializat
     {
         // 05-May-2020, tatu: Should we check for possible Shape override to "POJO"?
         //   (to let users force 'serialize-as-POJO'? Or not?
-        final String errorMsg = BeanUtil.checkUnsupportedType(type);
+        final String errorMsg = BeanUtil.checkUnsupportedType(ctxt.getConfig(), type);
         if (errorMsg != null) {
             // 30-Sep-2020, tatu: [databind#2867] Avoid checks if there is a mix-in
             //    which likely providers a handler...

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

@@ -913,7 +913,7 @@ protected JsonSerializer<?> _findUnsupportedTypeSerializer(SerializerProvider ct
     {
         // 05-May-2020, tatu: Should we check for possible Shape override to "POJO"?
         //   (to let users force 'serialize-as-POJO'?
-        final String errorMsg = BeanUtil.checkUnsupportedType(type);
+        final String errorMsg = BeanUtil.checkUnsupportedType(ctxt.getConfig(), type);
         if (errorMsg != null) {
             // 30-Sep-2020, tatu: [databind#2867] Avoid checks if there is a mix-in
             //    which likely providers a handler...

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

@@ -7,6 +7,8 @@
 import com.fasterxml.jackson.annotation.JsonInclude;
 
 import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.MapperFeature;
+import com.fasterxml.jackson.databind.cfg.MapperConfig;
 import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
 
 /**
@@ -293,11 +295,12 @@ public static String stdManglePropertyName(final String basename, final int offs
      * "well-known" types for which there would be a datatype module; and if so,
      * return appropriate failure message to give to caller.
      *
-     * @since 2.12
+     * @since 2.19
      */
-    public static String checkUnsupportedType(JavaType type) {
+    public static String checkUnsupportedType(MapperConfig<?> config, JavaType type) {
         final String className = type.getRawClass().getName();
         String typeName, moduleName;
+        MapperFeature failFeature = null;
 
         if (isJava8TimeClass(className)) {
             // [modules-java8#207]: do NOT check/block helper types in sub-packages,
@@ -315,13 +318,32 @@ public static String checkUnsupportedType(JavaType type) {
             typeName =  "Joda date/time";
             moduleName = "com.fasterxml.jackson.datatype:jackson-datatype-joda";
         } else if (isJava8OptionalClass(className)) {
+            failFeature = MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS;
+            final boolean fail = (config == null) || config.isEnabled(failFeature);
+            if (!fail) {
+                 return null;
+            }
             typeName =  "Java 8 optional";
             moduleName = "com.fasterxml.jackson.datatype:jackson-datatype-jdk8";
         } else {
             return null;
         }
-        return String.format("%s type %s not supported by default: add Module \"%s\" to enable handling",
+        String str = String.format("%s type %s not supported by default: add Module \"%s\" to enable handling",
                 typeName, ClassUtil.getTypeDescription(type), moduleName);
+        if (failFeature != null) {
+             str = String.format("%s (or disable `MapperFeature.%s`)",
+                     str, MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS.name());
+        }
+        return str;
+    }
+
+    /**
+     * @since 2.12
+     * @deprecated since 2.19
+     */
+    @Deprecated // since 2.19
+    public static String checkUnsupportedType(JavaType type) {
+        return checkUnsupportedType(null, type);
     }
 
     /**

src/test/java/com/fasterxml/jackson/databind/interop/OptionalJava8Fallbacks4082Test.java

@@ -10,20 +10,28 @@
 import com.fasterxml.jackson.core.*;
 import com.fasterxml.jackson.databind.*;
 import com.fasterxml.jackson.databind.exc.InvalidDefinitionException;
+import com.fasterxml.jackson.databind.json.JsonMapper;
 import com.fasterxml.jackson.databind.testutil.DatabindTestUtil;
 import com.fasterxml.jackson.databind.util.TokenBuffer;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.*;
 
 // [databind#4082]: add fallback handling for Java 8 Optional types, to
 // prevent accidental serialization as POJOs, as well as give more information
 // on deserialization attempts
+// [databind#5006]: add `MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS`
 //
-// @since 2.16
+// @since 2.16 (changed in 2.19)
 public class OptionalJava8Fallbacks4082Test extends DatabindTestUtil
 {
     private final ObjectMapper MAPPER = newJsonMapper();
 
+    ObjectMapper LENIENT_MAPPER = JsonMapper.builder()
+            .disable(MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS)
+            .disable(MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS)
+            .build();
+    
     // Test to prevent serialization as POJO, without Java 8 date/time module:
     @Test
     public void testPreventSerialization() throws Exception {
@@ -42,6 +50,7 @@ private void _testPreventSerialization(Object value) throws Exception
             verifyException(e, "Java 8 optional type `"+value.getClass().getName()
                     +"` not supported by default");
             verifyException(e, "add Module \"com.fasterxml.jackson.datatype:jackson-datatype-jdk8\"");
+            verifyException(e, "(or disable `MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS`");
         }
     }
 
@@ -62,6 +71,7 @@ private void _testBetterDeserializationError(Class<?> target) throws Exception
         } catch (InvalidDefinitionException e) {
             verifyException(e, "Java 8 optional type `"+target.getName()+"` not supported by default");
             verifyException(e, "add Module \"com.fasterxml.jackson.datatype:jackson-datatype-jdk8\"");
+            verifyException(e, "(or disable `MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS`");
         }
     }
 
@@ -93,4 +103,30 @@ public void testAllowAsEmbedded() throws Exception
             }
         }
     }
+
+    // [databind#5006]
+    @Test
+    public void testAllowDeserializationWithFeature() throws Exception
+    {
+        _testAllowDeserializationLenient(Optional.class);
+        _testAllowDeserializationLenient(OptionalInt.class);
+        _testAllowDeserializationLenient(OptionalLong.class);
+        _testAllowDeserializationLenient(OptionalDouble.class);
+    }
+
+    private void _testAllowDeserializationLenient(Class<?> target) throws Exception {
+        JacksonException e = assertThrows(JacksonException.class, () ->
+                LENIENT_MAPPER.readValue("{}", target));
+        assertThat(e).hasMessageContaining("Cannot construct instance of `"+target.getName()+"`");
+    }
+
+    // [databind#5006]
+    @Test
+    public void testAllowSerializationWithFeature() throws Exception
+    {
+        assertThat(LENIENT_MAPPER.writeValueAsString(Optional.empty())).contains("\"empty\":true");
+        assertThat(LENIENT_MAPPER.writeValueAsString(OptionalInt.of(13))).contains("\"asInt\":13");
+        assertThat(LENIENT_MAPPER.writeValueAsString(OptionalLong.of(-1L))).contains("\"asLong\":-1");
+        assertThat(LENIENT_MAPPER.writeValueAsString(OptionalDouble.of(0.5))).contains("\"asDouble\":0.5");
+    }
 }