Why does Jackson polymorphic serialization not work in lists?

Question

Jackson is doing something truly bizarre and I cannot find any explanation for it. I'm doing polymorphic serialization and it works perfectly when an object is on its own. But if you put the same object into a list and serialize the list instead, it erases the type information.

The fact that it's losing type info would lead one to suspect type erasure. But this is happening during serialization of the contents of the list; all Jackson has to do is inspect the current object it's serializing to determine its type.

I've created an example using Jackson 2.5.1:

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonSubTypes.Type;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.JsonTypeName;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.ArrayList;
import java.util.List;

public class Test {

  @JsonIgnoreProperties(ignoreUnknown = true)
  @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY)
  @JsonSubTypes({
    @Type(value = Dog.class, name = "dog"),
    @Type(value = Cat.class, name = "cat")})
  public interface Animal {}

  @JsonTypeName("dog")
  public static class Dog implements Animal {
    private String name;

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }
  }

  @JsonTypeName("cat")
  public static class Cat implements Animal {
    private String name;

    public String getName() {
      return name;
    }

    public void setName(String name) {
      this.name = name;
    }
  }

  public static void main(String[] args) throws JsonProcessingException {
    List<Cat> list = new ArrayList<>();
    list.add(new Cat());
    System.out.println(new ObjectMapper().writeValueAsString(list));
    System.out.println(new ObjectMapper().writeValueAsString(list.get(0)));
  }
}

Here's the output:

[{"name":null}]
{"@type":"cat","name":null}

As you can see, Jackson is not adding the type information when the object is in a list. Does anyone know why this is happening?

Answer 1

The various reasons for why this happens are discussed here and here. I don't necessarily agree with the reasons, but Jackson, because of type erasure, doesn't off the bat know the type of elements the List (or Collection or Map) contains. It chooses to use a simple serializer that doesn't interpret your annotations.

You have two options suggested in those links:

First, you can create a class that implements List<Cat>, instantiate it appropriately and serialize the instance.

class CatList implements List<Cat> {...}

The generic type argument Cat is not lost. Jackson has access to it and uses it.

Second, you can instantiate and use an ObjectWriter for the type List<Cat>. For example

System.out.println(new ObjectMapper().writerFor(new TypeReference<List<Cat>>() {}).writeValueAsString(list));

will print

[{"@type":"cat","name":"heyo"}]

Answer 2

The answer Sotirios Delimanolis gave is the correct one. However, I thought it'd be nice to post this workaround as a separate answer. if you are in an environment in which you cannot change the ObjectMapper for each type of thing you need to return (like a Jersey/SpringMVC webapp), there is an alternative.

You can simply include a private final field on the class that contains the type. The field won't be visible to anything outside the class, but if you annotate it with @JsonProperty("@type") (or "@class" or whatever your type field is named) Jackson will serialize it regardless of where the object is located.

@JsonTypeName("dog")
public static class Dog implements Animal {
  @JsonProperty("@type")
  private final String type = "dog";
  private String name;

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }
}

Answer 3

I faced this problem as well and this is the workaround that I prefer (I'm using Kotlin but with Java it's pretty much the same)

The parent class configures @JsonTypeInfo to use an existing property as the marker to break the ambiguity of the sub types

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXISTING_PROPERTY)
@JsonSubTypes(
        JsonSubTypes.Type(value = Bob::class, name = "bob"),
        JsonSubTypes.Type(value = Alice::class, name = "alice")
)
abstract class Person {

    abstract val jacksonMarker: String
        @JsonProperty("@type")
        get

    // ... rest of the class
}

The subclasses:

class Bob: Person {

    override val jacksonMarker: String
        get() = "bob"

    // ... rest of the class

}


class Alice: Person {

    override val jacksonMarker: String
        get() = "alice"

    // ... rest of the class

}

And you're set.

Answer 4

Similar but a little simpler than @monitorjbl above.

@JsonIgnoreProperties(ignoreUnknown = true)
@JsonTypeInfo(use = NAME, include = PROPERTY, property = "type")
@JsonSubTypes({
  @Type(value = Dog.class, name = "dog"),
  @Type(value = Cat.class, name = "cat")})
public interface Animal {}

public static class Dog implements Animal {
  private final String type = "dog";
}

public static class Cat implements Animal {
  private final String type = "cat";
}

Answer 5

Sotirios Delimanolis answer is correct. If you are using Kotlin you can simply create a new type like this:

class CatList: List<Cat> by listOf()

Answer 6

As arrays do not use type erasure you can solve it overriding the ObjectMapper.writeValueAsString to transform the Collection into an Array.

public class CustomObjectMapper extends ObjectMapper {    
    @Override
        public String writeValueAsString(Object value) throws JsonProcessingException {
                //Transform Collection to Array to include type info
                if(value instanceof Collection){
                    return super.writeValueAsString(((Collection)value).toArray());
                }
                else 
                    return super.writeValueAsString(value);
            }
}

Use it into your Test.main:

System.out.println(new CustomObjectMapper().writeValueAsString(list));

Output (cats and dogs list):

[{"@type":"cat","name":"Gardfield"},{"@type":"dog","name":"Snoopy"}]