Implement new SerializationFeature.IGNORE_FAILURE_TO_ORDER_MAP_ENTRIES_BY_INCOMPARABLE_KEYS

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

@@ -434,6 +434,21 @@ public enum SerializationFeature implements ConfigFeature
      */
     ORDER_MAP_ENTRIES_BY_KEYS(false),
 
+    /**
+     * Feature that determines whether to try to ignore failure to order map entries by incomparable keys.
+     * If enabled, will not throw an exception when ordering fails due to keys with incomparable key type
+     * and instead just return the original map.
+     * If disabled, will simply fail by throwing an exception.
+     * <p>
+     * Note that this feature will apply only when configured to order map entries by keys, either
+     * through annotation or enabling {@link #ORDER_MAP_ENTRIES_BY_KEYS}.
+     * <p>
+     * Feature is disabled by default and will default true in Jackson 3 and later.
+     *
+     * @since 2.19
+     */
+    IGNORE_FAILURE_TO_ORDER_MAP_ENTRIES_BY_INCOMPARABLE_KEYS(false),
+
     /*
     /******************************************************
     /* Other

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

@@ -750,7 +750,7 @@ public void serializeWithType(Map<?,?> value, JsonGenerator gen, SerializerProvi
     public void serializeWithoutTypeInfo(Map<?, ?> value, JsonGenerator gen, SerializerProvider provider) throws IOException {
         if (!value.isEmpty()) {
             if (_sortKeys || provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) {
-                value = _orderEntries(value, gen, provider);
+                value = _tryOrderingEntries(value, gen, provider);
             }
             PropertyFilter pf;
             if ((_filterId != null) && (pf = findPropertyFilter(provider, _filterId, value)) != null) {
@@ -1158,6 +1158,28 @@ protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap
         return result.serializer;
     }
 
+    // Since 2.19
+    protected Map<?, ?> _tryOrderingEntries(Map<?,?> input, JsonGenerator gen,
+            SerializerProvider provider)
+        throws IOException
+    {
+        try {
+            return _orderEntries(input, gen, provider);
+        } catch (ClassCastException cce) {
+            // [databind#4773] Since 2.19, `SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS` should not
+            // apply to Maps with incomparable keys.
+            // Due to dynamic nature of Map, we cannot be able to check key type in advance, so
+            // we may catch ClassCastException and handle it gracefully.
+            if (cce.getMessage() != null
+                && cce.getMessage().contains("cannot be cast to class java.lang.Comparable")
+                && provider.isEnabled(SerializationFeature.IGNORE_FAILURE_TO_ORDER_MAP_ENTRIES_BY_INCOMPARABLE_KEYS)
+            ) {
+                return input;
+            }
+            throw cce;
+        }
+    }
+
     protected Map<?,?> _orderEntries(Map<?,?> input, JsonGenerator gen,
             SerializerProvider provider)
         throws IOException

src/test/java/com/fasterxml/jackson/databind/tofix/OrderMapEntriesByKeysSerializationFeature4773Test.java → src/test/java/com/fasterxml/jackson/databind/deser/OrderMapEntriesByKeysSerializationFeature4773Test.java

@@ -1,18 +1,17 @@
-package com.fasterxml.jackson.databind.tofix;
+package com.fasterxml.jackson.databind.deser;
 
 import org.junit.jupiter.api.Test;
 
 import java.util.Currency;
 import java.util.HashMap;
 import java.util.Map;
 
+import com.fasterxml.jackson.databind.JsonMappingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.databind.testutil.DatabindTestUtil;
-import com.fasterxml.jackson.databind.testutil.failure.JacksonTestFailureExpected;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.*;
 
 // [databind#4773] Test to verify `SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS` behavior
 //     when serializing `Map` instances with un-comparable keys.
@@ -32,7 +31,6 @@ public static class ObjectContainer4773 {
             .configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, true)
             .build();
 
-    @JacksonTestFailureExpected
     @Test
     void testSerializationWithIncomparableKeys()
             throws Exception
@@ -44,11 +42,18 @@ void testSerializationWithIncomparableKeys()
 
         // When : Throws exception
         // com.fasterxml.jackson.databind.JsonMappingException: class java.util.Currency cannot be cast to class java.lang.Comparable
-        String jsonResult = objectMapper.writeValueAsString(entity);
+        try {
+            objectMapper.writer()
+                .without(SerializationFeature.IGNORE_FAILURE_TO_ORDER_MAP_ENTRIES_BY_INCOMPARABLE_KEYS)
+                .writeValueAsString(entity);
+            fail("Should not pass");
+        } catch (JsonMappingException e) {
 
-        // Then : Order should not matter, just plain old serialize
-        assertTrue(jsonResult.contains("GBP"));
-        assertTrue(jsonResult.contains("AUD"));
+            // Then
+            assertInstanceOf(ClassCastException.class, e.getCause());
+            assertTrue(e.getMessage()
+                    .contains("class java.util.Currency cannot be cast to class java.lang.Comparable"));
+        }
     }
 
     @Test
@@ -75,4 +80,25 @@ void testSerializationWithGenericObjectKeys()
                 "'5':'N_TEXT'}}"), jsonResult);
     }
 
+    @Test
+    void testSerializationWithBothComparableAndIncomparableKeys()
+            throws Exception
+    {
+        // Given : Mixed keys with incomparable `Currency` and comparable `Integer`
+        ObjectContainer4773 entity = new ObjectContainer4773();
+        entity.exampleMap.put(1, "AUD_TEXT");
+        entity.exampleMap.put(Currency.getInstance("GBP"), "GBP_TEXT");
+        entity.exampleMap.put(2, "KRW_TEXT");
+
+        // When
+        String jsonResult = objectMapper.writer()
+                .with(SerializationFeature.IGNORE_FAILURE_TO_ORDER_MAP_ENTRIES_BY_INCOMPARABLE_KEYS)
+                .writeValueAsString(entity);
+
+        // Then
+        assertTrue(jsonResult.contains("\"1\":\"AUD_TEXT\""));
+        assertTrue(jsonResult.contains("\"2\":\"KRW_TEXT\""));
+        assertTrue(jsonResult.contains("\"GBP\":\"GBP_TEXT\""));
+    }
+
 }