How to use Jackson to deserialise an array of objects

Decoding the JSON array

Direct train to List-ville

If you need to optimize your JSON to list conversion by eliminating extra stops, follow these steps:

// Deserializing JSON into an array of MyClass, efficiency at its best
MyClass[] myObjects = mapper.readValue(json, MyClass[].class);
// Beware! Arrays.asList() next, making the journey lot quicker
List<MyClass> list = Arrays.asList(myObjects);


Have Objects for breakfast

How about a thread-safe and reusable portion of JSON goodness? Use an ObjectReader. Practise safe coding, object-reader style:

// Your healthy ObjectReader breakfast, bon appétit!
ObjectReader reader = mapper.readerForListOf(MyClass.class);
List<MyClass> list = reader.readValue(json);


It's a game changer for web applications dealing with the usual JSON responses.

Catch 'em all: IOExceptions

When you are in the data kitchen cooking with IOException, you need a catch, quite literally:

// Cooking time, let's try to make List objects soup!
try {
    List<MyClass> objects = mapper.readValue(json, new TypeReference<List<MyClass>>() {});
} catch (IOException e) {
    // Oh no, a wild IOException appeared, handle it like pokemon master
    e.printStackTrace(); 
}


Successful error handling is the secret ingredient in a robust application soup.

No wizardry, just Type references

For fine control over the type of list, tap into wizard-like powers with the type factory:

JavaType type = mapper.getTypeFactory().constructCollectionType(List.class, MyClass.class);
List<MyClass> list = mapper.readValue(json, type);


Generic is the new cool

Why not whip up a reusable generic method that will deserialize many different types:

//Meet your new magic wand!
public <T> List<T> fromJsonArray(String json, Class<T> clazz) throws IOException {
    JavaType type = mapper.getTypeFactory().constructCollectionType(List.class, clazz);
    return mapper.readValue(json, type);
}


You can then call fromJsonArray(json, MyClass.class) to produce a List<MyClass> as if by magic!

Polymorphism: Playing many roles

When your JSON array contains a variety of objects, providing additional type information for Jackson is vital. Venture into polymorphic deserialization, and unlock Jackson's secret: @JsonTypeInfo.

Best tactics and advice

• Your target class (MyClass in examples) needs the right annotations like @JsonProperty if field names and JSON keys aren't in sync.
• Configure DeserializationFeatures for better Jackson behavior and control.
• Avoid memory leaks with large JSON arrays. Use streaming JSON and process objects sequentially.