Gson - deserialising different types

Question

I am processing incoming JSON Strings and want to deserialise them into typed POJO objects using GSON. However the server pushing the strings can send different types of object - though the type is defined in the JSON payload.

So looking at the below two JSON strings where I have a tradeEvent and an errorEvent object (have 5 other types like settlementEvent, paymentEvent etc).

How could I deserialise this to the actual POJO in GSON (presumably using generics) since I don't know the type until runtime - as you can see the second level element contains the actual object type (tradeEvent, errorEvent etc).

Should also add - in terms of the POJO, would I represent the second element (ie tradeEvent, errorEvent) as an object, or String?

 {
  "data": {
    "tradeEvent": {
      "tradeId": "2d28d464-a746-4c58-b19f-b586d2f5d015",
      "status": 2,
      "eventDescription": "Trade Settled"
    }
  }
}


{
  "data": {
    "errorEvent": {
      "Uuid": "3a36ae26-ba41-40d5-b11d-d8d842eb2356",
    "failureCode": 2, "tradeId": "2d28d464-a746-4c58-b19f-b586d2f5d015", "errorMessage": "Returned error: Exception while processing transaction: trade not matched"
    }
  }
}

Thanks for any guidance.

Answer 1

Implementing a data wrapper class to extract an event object would probably be the most simple way:

final class WrapperDto {

    @Nullable
    @SerializedName("data")
    @Expose(serialize = false, deserialize = true)
    private final DataDto data;

    @SuppressWarnings("unused")
    private WrapperDto(@Nullable final DataDto data) {
        this.data = data;
    }

    @Nullable
    <E extends Event> E toEvent() {
        if ( data == null ) {
            return null;
        }
        return data.toEvent();
    }

    private static final class DataDto {

        @Nullable
        @SerializedName("tradeEvent")
        @Expose(serialize = false, deserialize = true)
        private final Event.Trade tradeEvent;

        @Nullable
        @SerializedName("errorEvent")
        @Expose(serialize = false, deserialize = true)
        private final Event.Error errorEvent;

        @SuppressWarnings("unused")
        private DataDto(@Nullable final Event.Trade tradeEvent, @Nullable final Event.Error errorEvent) {
            this.tradeEvent = tradeEvent;
            this.errorEvent = errorEvent;
        }

        @Nullable
        private <E extends Event> E toEvent()
                throws IllegalStateException {
            @Nullable
            Event bestEvent = null;
            for ( final Event event : new Event[]{ tradeEvent, errorEvent } ) {
                if ( bestEvent == null ) {
                    bestEvent = event;
                } else if ( event != null ) {
                    throw new IllegalStateException("Ambiguity detected. event=" + event.getClass().getSimpleName() + ", bestEvent=" + bestEvent.getClass().getSimpleName());
                }
            }
            @SuppressWarnings("unchecked")
            final E castBestEvent = (E) bestEvent;
            return castBestEvent;
        }

    }

}

This approach, I believe, is much easier to implement than adapting RuntimeTypeAdapterFactory to your needs. However, implementing a custom type adapter might detect ambiguous fields right on reading therefore not deserializing each field (that costs some more heap).

The approach above would pass the following test:

private static final Gson gson = new GsonBuilder()
        .disableHtmlEscaping()
        .excludeFieldsWithoutExposeAnnotation()
        .create();
...
try ( final JsonReader jsonReader = open("tradeEvent.json") ) {
    Assertions.assertTrue(gson.<WrapperDto>fromJson(jsonReader, WrapperDto.class).toEvent() instanceof Event.Trade);
}
try ( final JsonReader jsonReader = open("errorEvent.json") ) {
    Assertions.assertTrue(gson.<WrapperDto>fromJson(jsonReader, WrapperDto.class).toEvent() instanceof Event.Error);
}
Assertions.assertThrows(IllegalStateException.class, () -> {
    try ( final JsonReader jsonReader = open("tradeAndErrorEvent.json") ) {
        gson.<WrapperDto>fromJson(jsonReader, WrapperDto.class).toEvent();
    }
});