Merge pull request #309 from jdereg/codex/modify-jsonparser-to-delay-type-resolution

Defer class resolution in parser

Author: jdereg

src/main/java/com/cedarsoftware/io/JsonParser.java

@@ -343,8 +343,8 @@ private JsonObject readJsonObject(Type suggestedType) throws IOException {
             // Process key-value pairing.
             switch (field) {
                 case TYPE:
-                    Class<?> type = loadType(value);
-                    jObj.setType(type);
+                    String typeName = loadType(value);
+                    jObj.setTypeName(typeName);
                     break;
 
                 case ENUM:  // Legacy support (@enum was used to indicate EnumSet in prior versions)
@@ -854,8 +854,12 @@ private void loadEnum(Object value, JsonObject jObj) {
         if (!(value instanceof String)) {
             error("Expected a String for " + ENUM + ", instead got: " + value);
         }
-        Class<?> enumClass = stringToClass((String) value);
-        jObj.setType(enumClass);
+        String enumClassName = (String) value;
+        String substitute = readOptions.getTypeNameAlias(enumClassName);
+        if (substitute != null) {
+            enumClassName = substitute;
+        }
+        jObj.setTypeName(enumClassName);
 
         // Only set empty items if no items were specified in JSON
         if (jObj.getItems() == null) {
@@ -868,7 +872,7 @@ private void loadEnum(Object value, JsonObject jObj) {
      *
      * @param value Object should be a String, if not an exception is thrown.  It is the value associated to the @type field.
      */
-    private Class<?> loadType(Object value) {
+    private String loadType(Object value) {
         if (!(value instanceof String)) {
             error("Expected a String for " + TYPE + ", instead got: " + value);
         }
@@ -878,8 +882,8 @@ private Class<?> loadType(Object value) {
             javaType = substitute;
         }
 
-        // Resolve class during parsing
-        return stringToClass(javaType);
+        // Defer class resolution
+        return javaType;
     }
 
     /**

src/main/java/com/cedarsoftware/io/JsonValue.java

@@ -47,6 +47,8 @@ public abstract class JsonValue {
     protected Long refId = null;
     protected int line;
     protected int col;
+    // Hold the raw @type/@enum string when the class cannot be resolved during parsing
+    String typeName = null;
 
     // Cache for storing whether a Type is fully resolved.
     private static final Map<Type, Boolean> typeResolvedCache = new ConcurrentHashMap<>();
@@ -140,7 +142,15 @@ public String getRawTypeName() {
         if (type != null) {
             return TypeUtilities.getRawClass(type).getName();
         }
-        return null;
+        return typeName;
+    }
+
+    public String getTypeName() {
+        return typeName;
+    }
+
+    public void setTypeName(String typeName) {
+        this.typeName = typeName;
     }
 
     public long getId() {
@@ -162,6 +172,7 @@ public boolean hasId() {
     void clear() {
         id = -1;
         type = null;
+        typeName = null;
         refId = null;
     }
 

src/main/java/com/cedarsoftware/io/MapResolver.java

@@ -203,6 +203,7 @@ else if (element instanceof JsonObject) {
 
                 if (refId == null) {
                     // Convert JsonObject to its destination type if possible
+                    resolvePendingType(jsonObject);
                     Class<?> type = jsonObject.getRawType();
                     if (type != null && converter.isConversionSupportedFor(Map.class, type)) {
                         Object converted = converter.convert(jsonObject, type);
@@ -213,6 +214,7 @@ else if (element instanceof JsonObject) {
                     }
                 } else {    // Connect reference
                     JsonObject refObject = refTracker.getOrThrow(refId);
+                    resolvePendingType(refObject);
                     Class<?> type = refObject.getRawType();
 
                     if (type != null && converter.isConversionSupportedFor(Map.class, type)) {
@@ -281,6 +283,7 @@ protected void traverseCollection(final JsonObject jsonObj) {
                     } else {
                         jObj.setType(Object.class);
                         createInstance(jObj);
+                        resolvePendingType(jObj);
                         boolean isNonRefClass = getReadOptions().isNonReferenceableClass(jObj.getRawType());
                         if (!isNonRefClass) {
                             traverseSpecificType(jObj);

src/main/java/com/cedarsoftware/io/ObjectResolver.java

@@ -134,6 +134,7 @@ public void assignField(final JsonObject jsonObj, final Injector injector, final
             }
 
             final JsonObject jObj = (JsonObject) rhs;
+            resolvePendingType(jObj);
             Type explicitType = jObj.getType();
             if (explicitType != null && !TypeUtilities.hasUnresolvedType(explicitType)) {
                 // If the field has an explicit type, use it.

src/main/java/com/cedarsoftware/io/Resolver.java

@@ -211,6 +211,7 @@ public <T> T toJavaObjects(JsonObject rootObj, Type rootType) {
         if (rootObj.isFinished) {
             return (T) rootObj.getTarget();
         } else {
+            resolvePendingType(rootObj);
             if (rootObj.getType() == null) {
                 // If there is no explicit type hint in the JSON, use the provided root type.
                 rootObj.setType(rootType);
@@ -455,6 +456,8 @@ Object createInstance(JsonObject jsonObj) {
             return target;
         }
 
+        resolvePendingType(jsonObj);
+
         // Use the refined Type (if available) to determine the target type.
         Class<?> targetType = resolveTargetType(jsonObj);
 
@@ -549,6 +552,35 @@ private boolean shouldCreateArray(JsonObject jsonObj, Class<?> targetType) {
         return targetType.isArray() || (items != null && targetType == Object.class && jsonObj.getKeys() == null);
     }
 
+    // Resolve any pending type name on the JsonObject to a concrete Class
+    protected void resolvePendingType(JsonObject jsonObj) {
+        if (jsonObj.getType() == null) {
+            String name = jsonObj.getTypeName();
+            if (name == null) {
+                return;
+            }
+
+            String alias = readOptions.getTypeNameAlias(name);
+            if (alias != null) {
+                name = alias;
+            }
+
+            Class<?> clazz = ClassUtilities.forName(name, readOptions.getClassLoader());
+            if (clazz == null) {
+                if (readOptions.isFailOnUnknownType()) {
+                    throw new JsonIoException("Unknown type (class) '" + name + "' not defined.");
+                }
+                clazz = readOptions.getUnknownTypeClass();
+                if (clazz == null) {
+                    clazz = LinkedHashMap.class;
+                }
+            }
+
+            jsonObj.setType(clazz);
+            jsonObj.setTypeName(null);
+        }
+    }
+
     private Object createArrayInstance(JsonObject jsonObj, Class<?> targetType) {
         Object[] items = jsonObj.getItems();
         int size = (items == null) ? 0 : items.length;

src/test/java/com/cedarsoftware/io/JsonParserTypeStringTest.java

@@ -0,0 +1,27 @@
+package com.cedarsoftware.io;
+
+import java.io.StringReader;
+
+import com.cedarsoftware.io.JsonReader.DefaultReferenceTracker;
+import com.cedarsoftware.util.FastReader;
+import com.cedarsoftware.util.convert.Converter;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/** Test that JsonParser keeps @type values as Strings during parsing. */
+public class JsonParserTypeStringTest {
+    @Test
+    public void testParserKeepsTypeName() throws Exception {
+        String json = "{\"@type\":\"some.missing.Type\",\"value\":1}";
+        ReadOptions options = new ReadOptionsBuilder().returnAsJsonObjects().failOnUnknownType(false).build();
+        Converter converter = new Converter(options.getConverterOptions());
+        MapResolver resolver = new MapResolver(options, new DefaultReferenceTracker(), converter);
+        JsonParser parser = new JsonParser(new FastReader(new StringReader(json)), resolver);
+        Object obj = parser.readValue(Object.class);
+        assertTrue(obj instanceof JsonObject);
+        JsonObject jObj = (JsonObject) obj;
+        assertNull(jObj.getType());
+        assertEquals("some.missing.Type", jObj.getRawTypeName());
+    }
+}