Mapping JSON to Java Classes with Quarkus and Apache Camel

Decoding Complex JSON Structures in Java with Apache Camel and Quarkus

Recently, I embarked on a challenging task while working on a project that involved consuming a microservice using Apache Camel and Quarkus. The microservice returned a rather complex JSON structure, which I needed to parse and manipulate within my Java application. The complexity arose from the nested and variable structure of the JSON, which was not only deeply nested but also contained arrays that could hold different types of data.

The JSON in question looked somewhat like this (simplified for clarity):

{
    "deviceStatusConnectorResponse": {
        "Body": {
            "Result": {
                "resultCode": 0,
                "resultDesc": "SUCCESS0001:Operation is successful",
                "resultData": {
                    "group": [
                        {
                            "imsi": "000000000000",
                            "isdn": "58000000000"
                        },
                        {
                            "group": [
                                {
                                    "vlrNum": "0000000000",
                                    "mscNum": "0000000000",
                                    ...
                                }
                            ],
                            "name": "\"Dynamic Status Information For GSM\""
                        }
                        ...
                    ]
                }
            }
        }
    }
}

Challenge in Parsing Nested & Variable JSON Data

The real challenge was to parse this JSON and map it into Java Objects efficiently, especially considering that different items in the “group” array could contain different fields. Some items could be as simple as containing “imsi” and “isdn” fields, while others could contain nested “group” objects themselves.

I initially tried to tackle this problem by using online tools like a popular JSON to POJO converter. However, the mapping failed mostly because of the variable structure of the “group” array. The POJOs generated did not adequately reflect the polymorphic nature of the JSON structure.

To work around issues of serialization and deserialization in Java when dealing with such complex and variable JSON structures, I found that using the Jackson library provides the flexibility needed. Jackson’s @JsonTypeInfo and @JsonSubTypes annotations allow us to handle polymorphic JSON objects – recognizing and processing different objects differently depending on their properties.

Addressing the Challenge

Here’s how I structured my Java classes to handle the parsing:

1. Defining Base and Derived Types for “Group”: Given that “group” holds different types of objects, I defined a base class called GroupItem and derived classes for each specific type of item that “group” could hold.

public class GroupItem {
    // Common fields
}

public class SimpleGroupItem extends GroupItem {
    private String imsi;
    private String isdn;
    // getters and setters
}

public class ComplexGroupItem extends GroupItem {
    private String vlrNum;
    private String mscNum;
    // Other specific fields
    // getters and setters
}

1. Using Jackson Annotations for Polymorphic JSON:

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = SimpleGroupItem.class, name = "simple"),
    @JsonSubTypes.Type(value = ComplexGroupItem.class, name = "complex")
})
public abstract class GroupItem {
    // Abstract class with common fields
}

In the JSON, I would have a “type” property that tells Jackson which class to instantiate.

1. Implementing Custom Deserializer if Necessary: For cases where standard annotations are insufficient or where the JSON structure is highly unpredictable, implementing a custom deserializer provides the ultimate control over the parsing process.

public class GroupItemDeserializer extends StdDeserializer<GroupItem> {
    public GroupItemDeserializer() {
        super(GroupItem.class);
    }

    @Override
    public GroupItem deserialize(JsonParser jp, DeserializationContext ctxt)
            throws IOException, JsonProcessingException {
        // Custom deserialization logic
    }
}

Implementation in the Application

Within my endpoint in Quarkus, I used Apache Camel to route the JSON response through a processor where I could use the ObjectMapper for deserialization:

String json = exchange.getIn().getBody(String.class);
ObjectMapper mapper = new ObjectMapper();
GroupItem group = mapper.readValue(json, GroupItem.class);

This approach allowed me to cleanly separate concerns, handle various types of JSON data flexibly, and integrate the process into my existing Camel routes. It stands as a testament to the adaptability required in modern software development, especially when integrating with various external systems through APIs. The real take here is understanding the nature of your data and choosing the right tool and strategy to handle its complexities effectively.