Make GSON a single entity where it expects arrays

Question

I have a group of classes of models that have a type field List<X>, where X- one of many things (for example String, Integerbut also some of my own type). I use GSON to analyze the JSON representations of these models. My problem is that the server I am facing (which is out of my control) somehow deleted singleton arrays and replaced them with the contained object. For example, instead of returning:

{
  "foo": [ "bar"],
  "bleh": [ { "some": "object" } ]
}

It returns:

{
  "foo": "bar",
  "bleh": { "some": "object" }
}

Now suppose the Java model class looks something like this:

public class Model {
   private List<String> foo;
   private List<SomeObject> bleh;
}

This currently causes the GSON to throw an exception because it finds BEGIN_STRINGor BEGIN_OBJECTwhere it expects BEGIN_ARRAY.

TypeAdapter<List<String>>. , List , TypeAdapter . TypeAdapter<List<?>>, - . , GSON , /? , , "", [ ] , , ?

Answer 1

, , TypeAdapter . TypeAdapter > , - .

, : Gson.

final class AlwaysListTypeAdapterFactory<E>
        implements TypeAdapterFactory {

    // Gson can instantiate it itself
    private AlwaysListTypeAdapterFactory() {
    }

    @Override
    public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
        // If it not a List -- just delegate the job to Gson and let it pick the best type adapter itself
        if ( !List.class.isAssignableFrom(typeToken.getRawType()) ) {
            return null;
        }
        // Resolving the list parameter type
        final Type elementType = resolveTypeArgument(typeToken.getType());
        @SuppressWarnings("unchecked")
        final TypeAdapter<E> elementTypeAdapter = (TypeAdapter<E>) gson.getAdapter(TypeToken.get(elementType));
        // Note that the always-list type adapter is made null-safe, so we don't have to check nulls ourselves
        @SuppressWarnings("unchecked")
        final TypeAdapter<T> alwaysListTypeAdapter = (TypeAdapter<T>) new AlwaysListTypeAdapter<>(elementTypeAdapter).nullSafe();
        return alwaysListTypeAdapter;
    }

    private static Type resolveTypeArgument(final Type type) {
        // The given type is not parameterized?
        if ( !(type instanceof ParameterizedType) ) {
            // No, raw
            return Object.class;
        }
        final ParameterizedType parameterizedType = (ParameterizedType) type;
        return parameterizedType.getActualTypeArguments()[0];
    }

    private static final class AlwaysListTypeAdapter<E>
            extends TypeAdapter<List<E>> {

        private final TypeAdapter<E> elementTypeAdapter;

        private AlwaysListTypeAdapter(final TypeAdapter<E> elementTypeAdapter) {
            this.elementTypeAdapter = elementTypeAdapter;
        }

        @Override
        public void write(final JsonWriter out, final List<E> list) {
            throw new UnsupportedOperationException();
        }

        @Override
        public List<E> read(final JsonReader in)
                throws IOException {
            // This is where we detect the list "type"
            final List<E> list = new ArrayList<>();
            final JsonToken token = in.peek();
            switch ( token ) {
            case BEGIN_ARRAY:
                // If it a regular list, just consume [, <all elements>, and ]
                in.beginArray();
                while ( in.hasNext() ) {
                    list.add(elementTypeAdapter.read(in));
                }
                in.endArray();
                break;
            case BEGIN_OBJECT:
            case STRING:
            case NUMBER:
            case BOOLEAN:
                // An object or a primitive? Just add the current value to the result list
                list.add(elementTypeAdapter.read(in));
                break;
            case NULL:
                throw new AssertionError("Must never happen: check if the type adapter configured with .nullSafe()");
            case NAME:
            case END_ARRAY:
            case END_OBJECT:
            case END_DOCUMENT:
                throw new MalformedJsonException("Unexpected token: " + token);
            default:
                throw new AssertionError("Must never happen: " + token);
            }
            return list;
        }

    }

}

Gson, . , Gson , @JsonAdapter:

final class Model {

    @JsonAdapter(AlwaysListTypeAdapterFactory.class)
    final List<String> foo = null;

    @JsonAdapter(AlwaysListTypeAdapterFactory.class)
    final List<SomeObject> bleh = null;

    @Override
    public String toString() {
        return "Model{" + "foo=" + foo + ", bleh=" + bleh + '}';
    }

}

final class SomeObject {

    final String some = null;

    @Override
    public String toString() {
        return "SomeObject{" + "some='" + some + '\'' + '}';
    }

}

:

single.json

{
    "foo": "bar",
    "bleh": {"some": "object"}
}

list.json

{
    "foo": ["bar"],
    "bleh": [{"some": "object"}]
}

:

private static final Gson gson = new Gson();

public static void main(final String... args)
        throws IOException {
    for ( final String resource : ImmutableList.of("single.json", "list.json") ) {
        try ( final JsonReader jsonReader = getPackageResourceJsonReader(Q43412261.class, resource) ) {
            final Model model = gson.fromJson(jsonReader, Model.class);
            System.out.println(model);
        }
    }
}

:

{foo = [bar], bleh = [SomeObject {some = 'object'}]}
{foo = [bar], bleh = [SomeObject {some = 'object'}]}

Answer 2

JsonDeserializer, , bleh foo JsonObjects JsonArrays.

, JsonElement :

JsonElement element = ...;
if (element.isJsonObject()) {
    //element is a JsonObject
} else if (element.isJsonArray()) {
    //element is a JsonArray
}