Generics + Gson != Fun

[Scott Selikoff]

I'm trying to create a utility method that calls Gson to deserialize a List of generic objects... Let's say they are "Widget" in a concrete example. Aka, the JSON is of the form: [{...},{...}] where {...} represents a serialized Widget object.

Below are two methods that both compile just fine. I've pulled out of a lot of extra businessy stuff, so apologize in advance if I pulled out so much it doesn't work!

public List<Widget> getUsingFixedType() throws Exception {
	// BUSINESSY CODE REMOVED
	final String data = ...

	// Deserialize result into List<Widget>
	return new Gson().fromJson(data, new TypeToken<List<Widget>>(){}.getType());
}

public <T> List<T> getUsingGeneric(Class<T> type) throws Exception {
	// BUSINESSY CODE REMOVED
	final String data = ...

	// Deserialize result into List<T>
	return new Gson().fromJson(data, new TypeToken<List<T>>(){}.getType());
}

The first method works as expected, and I get back a List of Widgets. Great if I am only working with Widgets, but as it turns out I need to support hundreds of different objects. Hence generics.

The second method appears to compile/run without issue, in fact I can even call toString() on the List and it prints the contents. The problem is that it is actually a List of LinkedTreeMap, not a List of Widgets. As soon as you call a Widget method like... result.get(0).getWidgetName(), it throws a ClassCastException.

While I understand this problem is related to type erasure, I'm wondering if anyone has a solution. I came across numerous posts using 'the Google' where people tried to get around this but had difficulty. I found one example where you can pass Widget[].class instead of Widget.class and then load the elements into an Array, but it feels hacky and I don't want the client to pass Widget[].class, I want them to pass Widget.class!

Any ideas?

[Roel De Nijs]

Scott Selikoff wrote:Any ideas?

I have never used this library, but after some googling I found this SO question which suggests to create a parametrized wrapper class which you can then use in the fromJson call.

So this wrapper class would look like

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

public class ListOf<T> implements ParameterizedType {
    private final Class<T> type;

    public ListOf(Class<T> type) {
        this.type = type;
    }

    @Override
    public Type[] getActualTypeArguments() {
        return new Type[] { type };
    }

    @Override
    public Type getRawType() {
        return List.class;
    }

    @Override
    public Type getOwnerType() {
        return null;
    }
}

And then you should be able to use this getUsingGeneric method

public <T> List<T> getUsingGeneric(Class<T> type) throws Exception {
    // BUSINESSY CODE REMOVED
    final String data = ...
 
    // Deserialize result into List<T>
    return new Gson().fromJson(data, new ListOf<T>(type));
}

I don't have tested it myself, so I don't know if it works. But if it does, it's a very nice and clean solution in my opinion.

Hope it helps!
Kind regards,
Roel

[Scott Selikoff]

Thanks Roel, I'll give it a shot! I tried a few different options although without much luck. Creating a class to perform a deserialization seems like overkill, but it may be the only way!

[Roel De Nijs]

Scott Selikoff wrote:Thanks Roel, I'll give it a shot! I tried a few different options although without much luck. Creating a class to perform a deserialization seems like overkill, but it may be the only way!

Fingers crossed! I have just created a test case myself and it seems to work for me And I would be happy to create this (fairly simple) class to get such a clean and nice solution to deserialize a generic list.

Here is my test case

class Container {
  int a;
  String b;
  boolean c;      
}

class DeserializeGson {
  public <T> List<T> getUsingGeneric(String json, Class<T> type) throws Exception {
    return new Gson().fromJson(json, new ListOf<T>(type));
  }
  
  public static void main(String[] args) throws Exception {
    final String json = "[ " + 
        "  { " + 
        "    \"a\": 100, " + 
        "    \"b\": \"value1\", " + 
        "    \"c\": true " + 
        "  }, " + 
        "  { " + 
        "    \"a\": 200, " + 
        "    \"b\": \"value2\", " + 
        "    \"c\": false " + 
        "  }, " + 
        "  { " + 
        "    \"a\": 300, " + 
        "    \"b\": \"value3\", " + 
        "    \"c\": true " + 
        "  } " + 
        "]";

    for (Container c : new DeserializeGson().getUsingGeneric(json, Container.class)) {
      System.out.printf("%d %s %b%n", c.a, c.b, c.c);
    }
  }
}

Output:
100 value1 true
200 value2 false
300 value3 true

[Scott Selikoff]

Thanks Roel! I tested it out and it does indeed work. I was hoping for a solution that didn't require a class but its the only way to get over the loss of information during type erasure, so glad it works. I set it up as an inner class so the client isn't even aware it's being used. Thanks again!

[Roel De Nijs]

Scott Selikoff wrote:I tested it out and it does indeed work. I was hoping for a solution that didn't require a class but its the only way to get over the loss of information during type erasure, so glad it works. I set it up as an inner class so the client isn't even aware it's being used.

Glad to hear it's working flawlessly! And I think an inner class is indeed the best option for this kind of "helper" class

As a side note: I don't agree with the title of this topic. I had fun writing this class (and its test case)