Fix #4533, add MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_TIMES (#5105)

Author: JooHyukKim

release-notes/CREDITS-2.x

@@ -321,6 +321,9 @@ Michal Letynski (mletynski@github)
 Jeff Schnitzer (stickfigure@github)
   * Suggested #504: Add `DeserializationFeature.USE_LONG_FOR_INTS`
    (2.6.0)
+  * Requested #4533: Add `MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_TIMES` to disable
+    the "Java 8 date/time XYZ not supported by default" error
+   (2.19.0)
 
 Jerry Yang (islanderman@github)
   * Contributed #820: Add new method for `ObjectReader`, to bind from JSON Pointer position

release-notes/VERSION-2.x

@@ -22,6 +22,10 @@ Project: jackson-databind
  (requested by @alzimmermsft)
 #4388: Allow using `@JsonPropertyOrder` with "any" (`@JsonAnyGetter`)  properties
  (fix by Joo-Hyuk K)
+#4533: Add `MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_TIMES` to disable the
+  "Java 8 date/time XYZ not supported by default" error
+ (requested by Jeff S)
+ (fix by Joo-Hyuk K)
 #4650: `PrimitiveArrayDeserializers` should deal with single String value if
   `DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY` enabled
  (reported, fix suggested by @eeren-bm)

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

@@ -661,7 +661,21 @@ public enum MapperFeature implements ConfigFeature
      *
      * @since 2.19
      */
-    REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS(true)
+    REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS(true),
+
+    /**
+     * Feature that determines what happens if Java 8 {@link java.time} (and
+     * other related Java 8 date/time 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-jsr310} 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_TIMES(true),
     ;
 
     private final boolean _defaultState;

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

@@ -295,6 +295,8 @@ 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.
      *
+     * @return error message to use, or null if failure is not needed.
+     *
      * @since 2.19
      */
     public static String checkUnsupportedType(MapperConfig<?> config, JavaType type) {
@@ -312,6 +314,11 @@ public static String checkUnsupportedType(MapperConfig<?> config, JavaType type)
             if (type.isTypeOrSubTypeOf(Throwable.class)) {
                 return null;
             }
+            failFeature = MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_TIMES;
+            final boolean fail = (config == null) || config.isEnabled(failFeature);
+            if (!fail) {
+                return null;
+            }
             typeName =  "Java 8 date/time";
             moduleName = "com.fasterxml.jackson.datatype:jackson-datatype-jsr310";
         } else if (isJodaTimeClass(className)) {
@@ -332,7 +339,7 @@ public static String checkUnsupportedType(MapperConfig<?> config, JavaType type)
                 typeName, ClassUtil.getTypeDescription(type), moduleName);
         if (failFeature != null) {
              str = String.format("%s (or disable `MapperFeature.%s`)",
-                     str, MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_OPTIONALS.name());
+                     str, failFeature.name());
         }
         return str;
     }

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

@@ -0,0 +1,119 @@
+package com.fasterxml.jackson.databind.interop;
+
+import java.time.LocalDate;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.core.JacksonException;
+import com.fasterxml.jackson.databind.*;
+import com.fasterxml.jackson.databind.json.JsonMapper;
+import com.fasterxml.jackson.databind.testutil.DatabindTestUtil;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
+
+public class Java8Datetime4533Test
+        extends DatabindTestUtil
+{
+    private final ObjectMapper MAPPER = newJsonMapper();
+
+    private final ObjectMapper LENIENT_MAPPER = JsonMapper.builder()
+            .disable(MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_TIMES)
+            .disable(MapperFeature.CAN_OVERRIDE_ACCESS_MODIFIERS)
+            .build();
+
+    @Test
+    public void testPreventSerialization() throws Exception
+    {
+        // [databind#4533]: prevent accidental serialization of Java 8 date/time types
+        // as POJOs, without Java 8 date/time module:
+        _testPreventSerialization(java.time.LocalDateTime.now());
+        _testPreventSerialization(java.time.LocalDate.now());
+        _testPreventSerialization(java.time.LocalTime.now());
+        _testPreventSerialization(java.time.OffsetDateTime.now());
+        _testPreventSerialization(java.time.ZonedDateTime.now());
+    }
+
+    private void _testPreventSerialization(Object value) throws Exception
+    {
+        try {
+            String json = MAPPER.writeValueAsString(value);
+            fail("Should not pass, wrote out as\n: "+json);
+        } catch (com.fasterxml.jackson.databind.exc.InvalidDefinitionException e) {
+            verifyException(e, "Java 8 date/time type `"+value.getClass().getName()
+                    +"` not supported by default");
+            verifyException(e, "add Module \"com.fasterxml.jackson.datatype:jackson-datatype-jsr310\"");
+            verifyException(e, "(or disable `MapperFeature.%s`)",
+                    MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_TIMES.name());
+        }
+    }
+
+    @Test
+    public void testPreventDeserialization() throws Exception
+    {
+        // [databind#4533]: prevent accidental deserialization of Java 8 date/time types
+        // as POJOs, without Java 8 date/time module:
+        _testPreventDeserialization(java.time.LocalDateTime.class);
+        _testPreventDeserialization(java.time.LocalDate.class);
+        _testPreventDeserialization(java.time.LocalTime.class);
+        _testPreventDeserialization(java.time.OffsetDateTime.class);
+        _testPreventDeserialization(java.time.ZonedDateTime.class);
+    }
+
+    private void _testPreventDeserialization(Class<?> value) throws Exception
+    {
+        try {
+            Object result = MAPPER.readValue(" 0 ", value);
+            fail("Not expecting to pass, resulted in: "+result);
+        } catch (com.fasterxml.jackson.databind.exc.InvalidDefinitionException e) {
+            verifyException(e, "Java 8 date/time type `"+value.getName()
+                    +"` not supported by default");
+            verifyException(e, "add Module \"com.fasterxml.jackson.datatype:jackson-datatype-jsr310\"");
+            verifyException(e, "(or disable `MapperFeature.%s`)",
+                    MapperFeature.REQUIRE_HANDLERS_FOR_JAVA8_TIMES.name());
+        }
+    }
+
+    @Test
+    public void testLenientSerailization() throws Exception
+    {
+        _testLenientSerialization(java.time.LocalDateTime.now());
+        _testLenientSerialization(java.time.LocalDate.now());
+        _testLenientSerialization(java.time.LocalTime.now());
+        _testLenientSerialization(java.time.OffsetDateTime.now());
+
+        // Except ZonedDateTime serialization fails with ...
+        try {
+            _testLenientSerialization(java.time.ZonedDateTime.now());
+            fail("Should not pass, wrote out as\n: "+java.time.ZonedDateTime.now());
+        } catch (JsonMappingException e) {
+            verifyException(e, "Class com.fasterxml.jackson.databind.ser.BeanPropertyWriter");
+            verifyException(e, "with modifiers \"public\"");
+        }
+    }
+
+    private void _testLenientSerialization(Object value) throws Exception
+    {
+        String json = LENIENT_MAPPER.writeValueAsString(value);
+        assertThat(json).isNotNull();
+    }
+
+    @Test
+    public void testAllowDeserializationWithFeature() throws Exception
+    {
+        _testAllowDeserializationLenient(java.time.LocalDateTime.class);
+        _testAllowDeserializationLenient(java.time.LocalDate.class);
+        _testAllowDeserializationLenient(java.time.LocalTime.class);
+        _testAllowDeserializationLenient(java.time.OffsetDateTime.class);
+        _testAllowDeserializationLenient(java.time.ZonedDateTime.class);
+    }
+
+    private void _testAllowDeserializationLenient(Class<?> target) throws Exception {
+        JacksonException e = assertThrows(JacksonException.class, () ->
+                LENIENT_MAPPER.readValue("{}", target));
+        Assertions.assertThat(e).hasMessageContaining("Cannot construct instance of `"+target.getName()+"`");
+    }
+
+}