Using Jackson to deserialize JSON mixed type array to base class list

This article details how to use the Jackson library to process JSON arrays containing multiple different object types and deserialize them into a list of base classes in Java. By introducing @JsonTypeInfo and @JsonSubTypes annotations, combined with the Id.DEDUCTION strategy, Jackson can intelligently identify and instantiate base class and subclass objects contained in JSON data, effectively solve UnrecognizedPropertyException, and achieve flexible polymorphic data mapping.

introduction

In modern web service interactions, we often encounter situations where the JSON data structure contains multiple different types of objects. For example, an array contains both base class objects and subclass objects. When trying to deserialize such a JSON array to a base class list in Java, Jackson's default behavior may not handle subclass-specific fields correctly, thus throwing an UnrecognizedPropertyException. This article will delve into how to leverage the power of Jackson to elegantly solve this polymorphic deserialization challenge.

Problem Analysis and Challenges

Suppose we have a Car base class and a Truck subclass (inherited from Car). The Truck class additionally contains fields such as maxLoad and clearance. When the JSON array contains data of both Car and Truck types, and we try to deserialize it into List, Jackson will encounter fields such as maxLoad when processing the Truck object, but these fields are not defined in the Car class. By default, Jackson will consider these to be unrecognized properties and throw com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException. Although changing the list type to List can avoid exceptions, this will cause non-Truck type objects to be deserialized correctly, and cannot meet the need to store all objects uniformly in a base class list.

Solution: Jackson polymorphic deserialization annotations

Jackson provides a powerful annotation mechanism to handle polymorphism. In order to deserialize a mixed-type JSON array into a base class list, we need to use the @JsonTypeInfo and @JsonSubTypes annotations on the base class.

1. @JsonTypeInfo : This annotation is used to specify how polymorphic type information is handled.

   • use = JsonTypeInfo.Id.DEDUCTION: This is the key to solving this problem. The DEDUCTION strategy instructs Jackson to try to infer the concrete type of a JSON object based on its fields. It checks all registered subtypes to see which subtype exactly matches the field in the JSON.
   • defaultImpl = Car.class: When Jackson cannot infer a matching subtype based on a field (i.e. the JSON object does not contain any subclass-specific fields), it will fall back to using this specified default implementation class for deserialization. In this example, if a JSON object contains only Car's fields, it will be deserialized into a Car instance.

2. @JsonSubTypes : This annotation is used to list all known subtypes of the base class.

   • @JsonSubTypes.Type(value = Truck.class): declares that Truck.class is a subtype of Car. Jackson will use this information to perform type inference under the DEDUCTION strategy.

Sample code

First, define the Java class structure and add Jackson annotations:

 import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;

@JsonTypeInfo(use = JsonTypeInfo.Id.DEDUCTION, defaultImpl = Car.class)
@JsonSubTypes(@JsonSubTypes.Type(value = Truck.class))
public class Car {
    private String make;
    private String model;
    private short year;
    private String bodyStyle;
    private String engineType;
    private int horsepower;

    //Constructor public Car() {}

    public Car(String make, String model, short year, String bodyStyle, String engineType, int horsepower) {
        this.make = make;
        this.model = model;
        this.year = year;
        this.bodyStyle = bodyStyle;
        this.engineType = engineType;
        this.horsepower = horsepower;
    }

    // Getters and Setters
    public String getMake() { return make; }
    public void setMake(String make) { this.make = make; }
    public String getModel() { return model; }
    public void setModel(String model) { this.model = model; }
    public short getYear() { return year; }
    public void setYear(short year) { this.year = year; }
    public String getBodyStyle() { return bodyStyle; }
    public void setBodyStyle(String bodyStyle) { this.bodyStyle = bodyStyle; }
    public String getEngineType() { return engineType; }
    public void setEngineType(String engineType) { this.engineType = engineType; }
    public int getHorsepower() { return horsepower; }
    public void setHorsepower(int horsepower) { this.horsepower = horsepower; }

    @Override
    public String toString() {
        return "Car{"  
               "make='" make '\''  
               ", model='" model '\''  
               ", year=" year  
               ", bodyStyle='" bodyStyle '\''  
               ", engineType='" engineType '\''  
               ", horsepower=" horsepower  
               '}';
    }
}

public class Truck extends Car {
    private double maxLoad;
    private double clearance;

    // Constructor public Truck() {}

    public Truck(String make, String model, short year, String bodyStyle, String engineType, int horsepower, double maxLoad, double clearance) {
        super(make, model, year, bodyStyle, engineType, horsepower);
        this.maxLoad = maxLoad;
        this.clearance = clearance;
    }

    // Getters and Setters
    public double getMaxLoad() { return maxLoad; }
    public void setMaxLoad(double maxLoad) { this.maxLoad = maxLoad; }
    public double getClearance() { return clearance; }
    public void setClearance(double clearance) { this.clearance = clearance; }

    @Override
    public String toString() {
        return "Truck{"  
               "make='" getMake() '\''  
               ", model='" getModel() '\''  
               ", year=" getYear()  
               ", bodyStyle='" getBodyStyle() '\''  
               ", engineType='" getEngineType() '\''  
               ", horsepower=" getHorsepower()  
               ", maxLoad=" maxLoad  
               ", clearance=" clearance  
               '}';
    }
}

Next is the JSON data file for testing (cars.json):

 [
  {
      "make": "Ford",
      "model": "Focus",
      "year": 2018,
      "engineType": "T4",
      "bodyStyle": "hatchback",
      "horsepower": 225
  },
  {
      "make": "Toyota",
      "model": "Prius",
      "year": 2021,
      "engineType": "T4",
      "bodyStyle": "hatchback",
      "horsepower": 121
  },
  {
      "make": "Toyota",
      "model": "RAV4",
      "year": 2020,
      "engineType": "V6",
      "bodyStyle": "SUV",
      "horsepower": 230
  },
  {
      "make": "Toyota",
      "model": "Tacoma",
      "year": 2021,
      "engineType": "V6",
      "bodyStyle": "pickup",
      "horsepower": 278,
      "maxLoad": 1050,
      "clearance": 9.4
  },
  {
      "make": "Ford",
      "model": "T150",
      "year": 2017,
      "horsepower": 450,
      "bodyStyle": "pickup",
      "maxLoad": 2320,
      "clearance": 8.4
  }
]

Finally, the deserialization and validation code:

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.core.type.TypeReference;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestDeserialization {
    private static final ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) {
        InputStream src = TestDeserialization

The above is the detailed content of Using Jackson to deserialize JSON mixed type array to base class list. For more information, please follow other related articles on the PHP Chinese website!