Start work on #1207, add handleWeirdKey() in both DeserializationContext and DeserializationProblemHandler

Author: cowtowncoder

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

@@ -802,20 +802,22 @@ public <T> T readPropertyValue(JsonParser p, BeanProperty prop, JavaType type) t
 
     /*
     /**********************************************************
-    /* Methods for problem handling, reporting
+    /* Methods for problem handling
     /**********************************************************
      */
 
     /**
-     * Method deserializers can call to inform configured {@link DeserializationProblemHandler}s
-     * of an unrecognized property.
+     * Method that deserializers should call if they encounter an unrecognized
+     * property (and once that is not explicitly designed as ignorable), to
+     * inform possibly configured {@link DeserializationProblemHandler}s and
+     * let it handle the problem.
      * 
      * @return True if there was a configured problem handler that was able to handle the
      *   problem
      */
     public boolean handleUnknownProperty(JsonParser p, JsonDeserializer<?> deser,
             Object instanceOrClass, String propName)
-        throws IOException, JsonProcessingException
+        throws IOException
     {
         LinkedNode<DeserializationProblemHandler> h = _config.getProblemHandlers();
         if (h != null) {
@@ -831,7 +833,52 @@ public boolean handleUnknownProperty(JsonParser p, JsonDeserializer<?> deser,
     }
 
     /**
-     * Helper method for reporting a problem with unhandled unknown exception
+     * Method that deserializers should call if they encounter an unrecognized
+     * property (and once that is not explicitly designed as ignorable), to
+     * inform possibly configured {@link DeserializationProblemHandler}s and
+     * let it handle the problem.
+     *
+     * @param keyClass Expected type for key
+     * @param keyValue String value from which to deserialize key
+     * @param msg Error message template caller wants to use if exception is to be thrown
+     * @param msgArgs Optional arguments to use for message, if any
+     *
+     * @return Key value to use
+     *
+     * @throws JsonMappingException
+     * 
+     * @since 2.8
+     */
+    public Object handleWeirdKey(Class<?> keyClass, String keyValue,
+            String msg, Object... msgArgs)
+        throws IOException
+    {
+        // but if not handled, just throw exception
+        if (msgArgs.length > 0) {
+            msg = String.format(msg, msgArgs);
+        }
+        LinkedNode<DeserializationProblemHandler> h = _config.getProblemHandlers();
+        if (h != null) {
+            while (h != null) {
+                // Can bail out if it's handled
+                Object key = h.value().handleWeirdKey(this, keyClass, keyValue, msg);
+                if (key  != DeserializationProblemHandler.NOT_HANDLED) {
+                    return key;
+                }
+                h = h.next();
+            }
+        }
+        throw this.weirdKeyException(keyClass, keyValue, msg);
+    }
+
+    /*
+    /**********************************************************
+    /* Methods for problem reporting
+    /**********************************************************
+     */
+
+    /**
+     * Helper method for reporting a problem with unhandled unknown property.
      * 
      * @param instanceOrClass Either value being populated (if one has been
      *   instantiated), or Class that indicates type that would be (or
@@ -900,19 +947,6 @@ public void reportWeirdNumberException(Number value, Class<?> instClass,
         throw weirdNumberException(value, instClass, msg);
     }
 
-    /**
-     * @since 2.8
-     */
-    public void reportWeirdKeyException(Class<?> keyClass, String keyValue,
-            String msg, Object... msgArgs)
-        throws JsonMappingException
-    {
-        if (msgArgs.length > 0) {
-            msg = String.format(msg, msgArgs);
-        }
-        throw weirdKeyException(keyClass, keyValue, msg);
-    }
-
     /**
      * @since 2.8
      */
@@ -1015,6 +1049,19 @@ public JsonMappingException mappingException(String msgTemplate, Object... args)
         return JsonMappingException.from(getParser(), msgTemplate);
     }
 
+    /**
+     * Helper method for constructing exception to indicate that given JSON
+     * Object field name was not in format to be able to deserialize specified
+     * key type.
+     */
+    public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue,
+            String msg) {
+        return InvalidFormatException.from(_parser,
+                String.format("Can not deserialize Map key of type %s from String %s: %s",
+                        keyClass.getName(), _quotedString(keyValue), msg),
+                keyValue, keyClass);
+    }
+
     /*
     /**********************************************************
     /* Methods for constructing semantic exceptions; mostly
@@ -1082,21 +1129,6 @@ public JsonMappingException weirdNumberException(Number value, Class<?> instClas
                 value, instClass);
     }
 
-    /**
-     * Helper method for constructing exception to indicate that given JSON
-     * Object field name was not in format to be able to deserialize specified
-     * key type.
-     *
-     * @deprecated Since 2.8 use {@link #reportWeirdKeyException} instead
-     */
-    @Deprecated
-    public JsonMappingException weirdKeyException(Class<?> keyClass, String keyValue, String msg) {
-        return InvalidFormatException.from(_parser,
-                String.format("Can not deserialize Map key of type %s from String %s: %s",
-                        keyClass.getName(), _quotedString(keyValue), msg),
-                keyValue, keyClass);
-    }
-
     /**
      * Helper method for indicating that the current token was expected to be another
      * token.

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

@@ -3,7 +3,6 @@
 import java.io.IOException;
 
 import com.fasterxml.jackson.core.JsonParser;
-import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.DeserializationConfig;
 import com.fasterxml.jackson.databind.DeserializationContext;
 import com.fasterxml.jackson.databind.JsonDeserializer;
@@ -31,7 +30,15 @@
 public abstract class DeserializationProblemHandler
 {
     /**
-     * Method called when a JSON Map ("Object") entry with an unrecognized
+     * Marker value returned by some handler methods to indicate that
+     * they could not handle problem and produce replacement value.
+     *
+     * @since 2.7
+     */
+    public final static Object NOT_HANDLED = new Object();
+    
+    /**
+     * Method called when a JSON Object property with an unrecognized
      * name is encountered.
      * Content (supposedly) matching the property are accessible via
      * parser that can be obtained from passed deserialization context.
@@ -42,9 +49,8 @@ public abstract class DeserializationProblemHandler
      *  parser.skipChildren();
      *</pre>
      *<p>
-     * Note: version 1.2 added new deserialization feature
-     * {@link com.fasterxml.jackson.databind.DeserializationFeature#FAIL_ON_UNKNOWN_PROPERTIES}).
-     * It will only have effect <b>after</b> handler is called, and only
+     * Note: {@link com.fasterxml.jackson.databind.DeserializationFeature#FAIL_ON_UNKNOWN_PROPERTIES})
+     * takes effect only <b>after</b> handler is called, and only
      * if handler did <b>not</b> handle the problem.
      *
      * @param beanOrClass Either bean instance being deserialized (if one
@@ -60,8 +66,40 @@ public abstract class DeserializationProblemHandler
      */
     public boolean handleUnknownProperty(DeserializationContext ctxt, JsonParser p,
             JsonDeserializer<?> deserializer, Object beanOrClass, String propertyName)
-        throws IOException, JsonProcessingException
+        throws IOException
     {
         return false;
     }
+
+    /**
+     * Method called when a property name from input can not be converted to a
+     * non-Java-String key type (passed as <code>rawKeyType</code>) due to format
+     * problem. Handler may choose to do one of 3 things:
+     *<ul>
+     * <li>Indicate it does not know what to do by returning {@link #NOT_HANDLED}
+     *  </li>
+     * <li>Throw a {@link IOException} to indicate specific fail message (instead of
+     *    standard exception caller would throw
+     *  </li>
+     * <li>Return actual key value to use as replacement, and continue processing.
+     *  </li>
+     * </ul>
+     *
+     * @since 2.8
+     *
+     * @param failureMsg Message that will be used by caller (by calling
+     *    {@link DeserializationContext#weirdKeyException(Class, String, String)})
+     *    to indicate type of failure unless handler produces key to use
+     *
+     * @return Either {@link #NOT_HANDLED} to indicate that handler does not know
+     *    what to do (and exception may be thrown), or value to use as key (possibly
+     *    <code>null</code>
+     */
+    public Object handleWeirdKey(DeserializationContext ctxt,
+            Class<?> rawKeyType, String keyValue,
+            String failureMsg)
+        throws IOException
+    {
+        return NOT_HANDLED;
+    }
 }

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

@@ -3,6 +3,7 @@
 import java.io.IOException;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
+import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URL;
 import java.util.*;
@@ -110,7 +111,7 @@ public static StdKeyDeserializer forType(Class<?> raw)
         }
         return new StdKeyDeserializer(kind, raw);
     }
-    
+
     @Override
     public Object deserializeKey(String key, DeserializationContext ctxt)
         throws IOException
@@ -124,14 +125,12 @@ public Object deserializeKey(String key, DeserializationContext ctxt)
                 return result;
             }
         } catch (Exception re) {
-            ctxt.reportWeirdKeyException(_keyClass, key, "not a valid representation: %s", re.getMessage());
-            return null;
+            return ctxt.handleWeirdKey(_keyClass, key, "not a valid representation: %s", re.getMessage());
         }
         if (_keyClass.isEnum() && ctxt.getConfig().isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
             return null;
         }
-        ctxt.reportWeirdKeyException(_keyClass, key, "not a valid representation");
-        return null;
+        return ctxt.handleWeirdKey(_keyClass, key, "not a valid representation");
     }
 
     public Class<?> getKeyClass() { return _keyClass; }
@@ -146,23 +145,21 @@ protected Object _parse(String key, DeserializationContext ctxt) throws Exceptio
             if ("false".equals(key)) {
                 return Boolean.FALSE;
             }
-            ctxt.reportWeirdKeyException(_keyClass, key, "value not 'true' or 'false'");
-            break;
+            return ctxt.handleWeirdKey(_keyClass, key, "value not 'true' or 'false'");
         case TYPE_BYTE:
             {
                 int value = _parseInt(key);
-                // as per [JACKSON-804], allow range up to 255, inclusive
+                // allow range up to 255, inclusive (to support "unsigned" byte)
                 if (value < Byte.MIN_VALUE || value > 255) {
-                    ctxt.reportWeirdKeyException(_keyClass, key, "overflow, value can not be represented as 8-bit value");
-                    // fall-through and truncate if need be
+                    return ctxt.handleWeirdKey(_keyClass, key, "overflow, value can not be represented as 8-bit value");
                 }
                 return Byte.valueOf((byte) value);
             }
         case TYPE_SHORT:
             {
                 int value = _parseInt(key);
                 if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
-                    ctxt.reportWeirdKeyException(_keyClass, key, "overflow, value can not be represented as 16-bit value");
+                    return ctxt.handleWeirdKey(_keyClass, key, "overflow, value can not be represented as 16-bit value");
                     // fall-through and truncate if need be
                 }
                 return Short.valueOf((short) value);
@@ -171,8 +168,7 @@ protected Object _parse(String key, DeserializationContext ctxt) throws Exceptio
             if (key.length() == 1) {
                 return Character.valueOf(key.charAt(0));
             }
-            ctxt.reportWeirdKeyException(_keyClass, key, "can only convert 1-character Strings");
-            break;
+            return ctxt.handleWeirdKey(_keyClass, key, "can only convert 1-character Strings");
         case TYPE_INT:
             return _parseInt(key);
 
@@ -188,41 +184,46 @@ protected Object _parse(String key, DeserializationContext ctxt) throws Exceptio
             try {
                 return _deser._deserialize(key, ctxt);
             } catch (IOException e) {
-                ctxt.reportWeirdKeyException(_keyClass, key, "unable to parse key as locale");
+                return ctxt.handleWeirdKey(_keyClass, key, "unable to parse key as locale");
             }
-            break;
         case TYPE_CURRENCY:
             try {
                 return _deser._deserialize(key, ctxt);
             } catch (IOException e) {
-                ctxt.reportWeirdKeyException(_keyClass, key, "unable to parse key as currency");
+                return ctxt.handleWeirdKey(_keyClass, key, "unable to parse key as currency");
             }
-            break;
         case TYPE_DATE:
             return ctxt.parseDate(key);
         case TYPE_CALENDAR:
             java.util.Date date = ctxt.parseDate(key);
             return (date == null)  ? null : ctxt.constructCalendar(date);
         case TYPE_UUID:
-            return UUID.fromString(key);
+            try {
+                return UUID.fromString(key);
+            } catch (Exception e) {
+                return ctxt.handleWeirdKey(_keyClass, key, "problem: %s", e.getMessage());
+            }
         case TYPE_URI:
-            return URI.create(key);
+            try {
+                return URI.create(key);
+            } catch (Exception e) {
+                return ctxt.handleWeirdKey(_keyClass, key, "problem: %s", e.getMessage());
+            }
         case TYPE_URL:
-            return new URL(key);
+            try {
+                return new URL(key);
+            } catch (MalformedURLException e) {
+                return ctxt.handleWeirdKey(_keyClass, key, "problem: %s", e.getMessage());
+            }
         case TYPE_CLASS:
             try {
                 return ctxt.findClass(key);
             } catch (Exception e) {
-                ctxt.reportWeirdKeyException(_keyClass, key, "unable to parse key as Class");
+                return ctxt.handleWeirdKey(_keyClass, key, "unable to parse key as Class");
             }
-            break;
         default:
             throw new IllegalStateException("Internal error: unknown key type "+_keyClass);
         }
-        // 05-May-2016, tatu: In future, we may end up here if `reportWeirdKeyException()`
-        //    collects failure messages and does not immediately throw. Not 100% sure what
-        //    should be done; returning `null` seems least evil for now
-        return null;
     }
 
     /*
@@ -314,13 +315,10 @@ public final Object deserializeKey(String key, DeserializationContext ctxt)
                 if (result != null) {
                     return result;
                 }
-                ctxt.reportWeirdKeyException(_keyClass, key, "not a valid representation");
+                return ctxt.handleWeirdKey(_keyClass, key, "not a valid representation");
             } catch (Exception re) {
-                ctxt.reportWeirdKeyException(_keyClass, key, "not a valid representation: "+re.getMessage());
+                return ctxt.handleWeirdKey(_keyClass, key, "not a valid representation: %s", re.getMessage());
             }
-            // 05-May-2016, tatu: Can't happen now (2.8), but in future exceptions may
-            //    be deferred.
-            return null;
         }
 
         public Class<?> getKeyClass() { return _keyClass; }
@@ -350,7 +348,7 @@ protected EnumKD(EnumResolver er, AnnotatedMethod factory) {
         }
 
         @Override
-        public Object _parse(String key, DeserializationContext ctxt) throws JsonMappingException
+        public Object _parse(String key, DeserializationContext ctxt) throws IOException
         {
             if (_factory != null) {
                 try {
@@ -363,7 +361,7 @@ public Object _parse(String key, DeserializationContext ctxt) throws JsonMapping
                     ? _getToStringResolver(ctxt) : _byNameResolver;
             Enum<?> e = res.findEnum(key);
             if ((e == null) && !ctxt.getConfig().isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
-                ctxt.reportWeirdKeyException(_keyClass, key, "not one of values excepted for Enum class: %s",
+                return ctxt.handleWeirdKey(_keyClass, key, "not one of values excepted for Enum class: %s",
                         res.getEnumIds());
                 // fall-through if problems are collected, not immediately thrown
             }