Deserialize JSON with Jackson into Polymorphic Types - A Complete Example

Jackson API Versions Note The following code examples were written using Jackson 1.7.x or 1.8.x. They probably work as-is with Jackson 1.9.x, but Jackson 2.0 introduced API changes significant enough that this code does not compile with it. On initial review, it appears that package names changed, and at least one method signature changed or was moved or was renamed or no longer exists. In the near future, I may post updated code examples that use Jackson 2.x. tl;dnr Skip to the fourth, fifth, and sixth examples. Why This Post Exists While recently answering a question on StackOverflow.com about deserialization of JSON into polymorhpic types in Java, I couldn't find a simple and complete example using Jackson. At the time of this writing, the official documentation on the subject describes aspects of how to do this, but it doesn't have a full example. Searching other resources also didn't turn up any complete examples.

Link To This Articlehttp://goo.gl/nVKBZ

Following are deserialization examples with Jackson that build up to a complete example of populating a polymorphic data structure in Java. The first three examples do not involve Polymorphism. Polymorphism is introduced in the fourth example.

Consult the Jackson API documentation for explanations of each component.

Example 1: Simple Object Deserialization and Serialization

// input and output:
//   {"type":"dog","name":"Spike"}

import org.codehaus.jackson.map.ObjectMapper;

public class Foo
{
  static String jsonInput = 
      "{\"type\":\"dog\",\"name\":\"Spike\"}";

  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();
    Animal animal = mapper.readValue(jsonInput, Animal.class);
    System.out.println(mapper.writeValueAsString(animal));
  }
}

class Animal
{
  public String type;
  public String name;
}

Example 2: Simple Collection Deserialization and Serialization

// input and output:
//   [
//     {"type":"dog","name":"Spike"},
//     {"type":"cat","name":"Fluffy"}
//   ]

import java.io.File;
import java.util.Collection;

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.type.TypeFactory;
import org.codehaus.jackson.type.TypeReference;

public class Foo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();
    Collection<Animal> animals =
      mapper.readValue(new File("input_2.json"),
        new TypeReference<Collection<Animal>>() {});
    System.out.println(mapper.writeValueAsString(animals));
    // or
    Collection<Animal> animals2 =
      mapper.readValue(new File("input_2.json"),
        TypeFactory.defaultInstance().constructParametricType(
            Collection.class, Animal.class));
    System.out.println(mapper.writeValueAsString(animals2));
  }
}

class Animal
{
  public String type;
  public String name;
}

Example 3: Simple Deserialization/Serialization To/From Container Object With Collection

// input and output:
//   {
//     "animals":
//     [
//       {"type":"dog","name":"Spike"},
//       {"type":"cat","name":"Fluffy"}
//     ]
//   }

import java.io.File;
import java.util.Collection;

import org.codehaus.jackson.map.ObjectMapper;

public class Foo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();
    Zoo zoo = 
      mapper.readValue(new File("input_3.json"), Zoo.class);
    System.out.println(mapper.writeValueAsString(zoo));
  }
}

class Zoo
{
  public Collection<Animal> animals;
}

class Animal
{
  public String type;
  public String name;
}

Example 4: Simple Deserialization/Serialization To/From Container Object With Polymorphic Collection

// input and output:
//   {
//     "animals":
//     [
//       {"type":"dog","name":"Spike","breed":"mutt",
//           "leash_color":"red"},
//       {"type":"cat","name":"Fluffy",
//           "favorite_toy":"spider ring"}
//     ]
//   }

import java.io.File;
import java.util.Collection;

import org.codehaus.jackson.annotate.JsonSubTypes;
import org.codehaus.jackson.annotate.JsonSubTypes.Type;
import org.codehaus.jackson.annotate.JsonTypeInfo;
import org.codehaus.jackson.map.ObjectMapper;

public class Foo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setPropertyNamingStrategy(
        new CamelCaseNamingStrategy());
    Zoo zoo = 
      mapper.readValue(new File("input_4.json"), Zoo.class);
    System.out.println(mapper.writeValueAsString(zoo));
  }
}

class Zoo
{
  public Collection<Animal> animals;
}

@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.PROPERTY,
    property = "type")
@JsonSubTypes({
    @Type(value = Cat.class, name = "cat"),
    @Type(value = Dog.class, name = "dog") })
abstract class Animal
{
  public String name;
}

class Dog extends Animal
{
  public String breed;
  public String leashColor;
}

class Cat extends Animal
{
  public String favoriteToy;
}

import org.codehaus.jackson.map.MapperConfig;
import org.codehaus.jackson.map.PropertyNamingStrategy;
import org.codehaus.jackson.map.introspect.AnnotatedField;
import org.codehaus.jackson.map.introspect.AnnotatedMethod;

/** 
 * Converts standard CamelCase field and method names to  
 * typical JSON field names having all lower case characters  
 * with an underscore separating different words.  For  
 * example, all of the following are converted to JSON field  
 * name "some_name": 
 *  
 * Java field name "someName"   
 * Java method name "getSomeName" 
 * Java method name "setSomeName" 
 *  
 * Typical Use: 
 * 
 * String jsonString = "{\"foo_name\":\"fubar\"}"; 
 * ObjectMapper mapper = new ObjectMapper(); 
 * mapper.setPropertyNamingStrategy( 
 *     new CamelCaseNamingStrategy()); 
 * Foo foo = mapper.readValue(jsonString, Foo.class); 
 * System.out.println(mapper.writeValueAsString(foo)); 
 * // prints {"foo_name":"fubar"} 
 *  
 * class Foo 
 * { 
 *   private String fooName; 
 *   public String getFooName() {return fooName;} 
 *   public void setFooName(String fooName)  
 *   {this.fooName = fooName;} 
 * } 
 */
public class CamelCaseNamingStrategy
    extends PropertyNamingStrategy
{
  @Override
  public String nameForGetterMethod(MapperConfig<?> config,
      AnnotatedMethod method, String defaultName)
  {
    return translate(defaultName);
  }

  @Override
  public String nameForSetterMethod(MapperConfig<?> config,
      AnnotatedMethod method, String defaultName)
  {
    return translate(defaultName);
  }

  @Override
  public String nameForField(MapperConfig<?> config,
      AnnotatedField field, String defaultName)
  {
    return translate(defaultName);
  }

  private String translate(String defaultName)
  {
    char[] nameChars = defaultName.toCharArray();
    StringBuilder nameTranslated =
        new StringBuilder(nameChars.length * 2);
    for (char c : nameChars)
    {
      if (Character.isUpperCase(c))
      {
        nameTranslated.append("_");
        c = Character.toLowerCase(c);
      }
      nameTranslated.append(c);
    }
    return nameTranslated.toString();
  }
}

Example 5: Simple Deserialization/Serialization With MixIn To/From Container Object With Polymorphic Collection

// input and output:
//   {
//     "animals":
//     [
//       {"type":"dog","name":"Spike","breed":"mutt",
//           "leash_color":"red"},
//       {"type":"cat","name":"Fluffy",
//           "favorite_toy":"spider ring"}
//     ]
//   }

import java.io.File;
import java.util.Collection;

import org.codehaus.jackson.annotate.JsonSubTypes;
import org.codehaus.jackson.annotate.JsonTypeInfo;
import org.codehaus.jackson.annotate.JsonSubTypes.Type;
import org.codehaus.jackson.map.ObjectMapper;

public class Foo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setPropertyNamingStrategy(
        new CamelCaseNamingStrategy());
    mapper.getDeserializationConfig().addMixInAnnotations(
        Animal.class, PolymorphicAnimalMixIn.class);
    mapper.getSerializationConfig().addMixInAnnotations(
        Animal.class, PolymorphicAnimalMixIn.class);
    Zoo zoo = 
      mapper.readValue(new File("input_5.json"), Zoo.class);
    System.out.println(mapper.writeValueAsString(zoo));
  }
}

class Zoo
{
  public Collection<Animal> animals;
}

@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.PROPERTY,
    property = "type")
@JsonSubTypes({
    @Type(value = Cat.class, name = "cat"),
    @Type(value = Dog.class, name = "dog") })
abstract class PolymorphicAnimalMixIn
{
  
}

abstract class Animal
{
  public String name;
}

class Dog extends Animal
{
  public String breed;
  public String leashColor;
}

class Cat extends Animal
{
  public String favoriteToy;
}

Example 6: Simple Deserialization Without Type Element To Container Object With Polymorphic Collection

Some real-world JSON APIs have polymorphic type members, but don't include type elements (unlike the JSON in the previous examples). Deserializing such sources into polymorphic collections is a bit more involved. Following is one relatively simple solution. (This example includes subsequent serialization of the deserialized Java structure back to input JSON, but the serialization is relatively uninteresting.)

// input and output:
//   {
//     "animals":
//     [
//       {"name":"Spike","breed":"mutt","leash_color":"red"},
//       {"name":"Fluffy","favorite_toy":"spider ring"},
//       {"name":"Baldy","wing_span":"6 feet",
//           "preferred_food":"wild salmon"}
//     ]
//   }

import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import org.codehaus.jackson.JsonNode;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.Version;
import org.codehaus.jackson.map.DeserializationContext;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.deser.StdDeserializer;
import org.codehaus.jackson.map.module.SimpleModule;
import org.codehaus.jackson.node.ObjectNode;

import fubar.CamelCaseNamingStrategy;

public class Foo
{
  public static void main(String[] args) throws Exception
  {
    AnimalDeserializer deserializer = 
        new AnimalDeserializer();
    deserializer.registerAnimal("leash_color", Dog.class);
    deserializer.registerAnimal("favorite_toy", Cat.class);
    deserializer.registerAnimal("wing_span", Bird.class);
    SimpleModule module =
      new SimpleModule("PolymorphicAnimalDeserializerModule",
          new Version(1, 0, 0, null));
    module.addDeserializer(Animal.class, deserializer);
    
    ObjectMapper mapper = new ObjectMapper();
    mapper.setPropertyNamingStrategy(
        new CamelCaseNamingStrategy());
    mapper.registerModule(module);

    Zoo zoo = 
        mapper.readValue(new File("input_6.json"), Zoo.class);
    System.out.println(mapper.writeValueAsString(zoo));
  }
}

class AnimalDeserializer extends StdDeserializer<Animal>
{
  private Map<String, Class<? extends Animal>> registry =
      new HashMap<String, Class<? extends Animal>>();

  AnimalDeserializer()
  {
    super(Animal.class);
  }

  void registerAnimal(String uniqueAttribute,
      Class<? extends Animal> animalClass)
  {
    registry.put(uniqueAttribute, animalClass);
  }

  @Override
  public Animal deserialize(
      JsonParser jp, DeserializationContext ctxt) 
      throws IOException, JsonProcessingException
  {
    ObjectMapper mapper = (ObjectMapper) jp.getCodec();
    ObjectNode root = (ObjectNode) mapper.readTree(jp);
    Class<? extends Animal> animalClass = null;
    Iterator<Entry<String, JsonNode>> elementsIterator = 
        root.getFields();
    while (elementsIterator.hasNext())
    {
      Entry<String, JsonNode> element=elementsIterator.next();
      String name = element.getKey();
      if (registry.containsKey(name))
      {
        animalClass = registry.get(name);
        break;
      }
    }
    if (animalClass == null) return null;
    return mapper.readValue(root, animalClass);
  }
}

class Zoo
{
  public Collection<Animal> animals;
}

abstract class Animal
{
  public String name;
}

class Dog extends Animal
{
  public String breed;
  public String leashColor;
}

class Cat extends Animal
{
  public String favoriteToy;
}

class Bird extends Animal
{
  public String wingSpan;
  public String preferredFood;
}

FINI