Generic method and JSON

Question

I wrote generic method which returns list of some objects, for example Orders. My question is why in second, non-generic method it returns correct list of Orders and the first method (generic) returns list of linkedHashMaps instead of Orders?

Generic:

 private <T> List<T> mapObjectsToList(String objectsListInJson) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    TypeReference<List<T>> mapType = new TypeReference<List<T>>() {
    };
    return objectMapper.readValue(objectsListInJson, mapType);
}

Non-generic:

private List<Order> mapObjectsToList(String objectsListInJson) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    TypeReference<List<Order>> mapType = new TypeReference<List<Order>>() {
    };
    return objectMapper.readValue(objectsListInJson, mapType);
}

Generic method returns that: LinkedHashMap

Answer 1

Because in the non generic method you have explicitly said that you are adding Order.

And in the generic one you are sending back objects, which are essentialy of type Order.

In any case both of it will return List.

Answer 2

The problem is that you can't pass a type parameter by simply declaring it.

Type parameters are erased so within your generic function <T> just not exist so even the type reference can't convey such info.

You should build the type reference with the actual reference of the class and pass a type reference to the method like this:

List<Composite> out = mapObjectsToList(in, new TypeReference<List<Composite>>() {});

or ...

Knowing in advance that you are deserializing exactly List of T you can play with TypeFactory

private static <T> List<T> mapObjectsToList(Reader objectsListInJson, Class<T> clazz) throws IOException {
    ObjectMapper objectMapper = new ObjectMapper();
    CollectionLikeType typeref = TypeFactory.defaultInstance().constructCollectionType(ArrayList.class, clazz);
    return objectMapper.readValue(objectsListInJson, typeref);
}

And call it like this:

List<Composite> out = mapObjectsToList(in, Composite.class);

Answer 3

The problem is that the generic type variable T is not bound to any concrete type, so the compiler sees it as Object. So:

TypeReference<List<T>> mapType = new TypeReference<List<T>>() {};

is actually:

TypeReference<List<Object>> mapType = new TypeReference<List<Object>>() {};

And when the ObjectMapper can't gather info about the concrete type of the object to deserialize, it defaults to LinkedHashMap.

If you want to be able to deserialize to a generic type at runtime, you should pass the TypeReference type token as an argument to your mapObjectsToList method:

// Make this a singleton, i.e. don't create a new instance on every call!
ObjectMapper objectMapper = new ObjectMapper();

private <T> List<T> mapObjectsToList(
        String objectsListInJson, 
        TypeReference<List<T>> mapType) throws IOException {

    return objectMapper.readValue(objectsListInJson, mapType);
}

And then use the above method as follows:

List<Order> orders = mapObjectsToList(
    stringWithTheJSON, 
    new TypeReference<List<Order>> {});

On a side note, I've moved the ObjectMapper objectMapper = new ObjectMapper() statement outside the method. There should be only one ObjectMapper instance in the whole application, unless you require different configuration for serializing/deserializing.