使用GSON将集合序列化为JsonObject而不是JsonArray

Question

My goal is to serialize a class implementing the Collection interface as JSON object instead of a JSON array. The following class is a simplyfied example:

public class CollectionImplementation implements Collection<String> {
  private final List<String> _wrappedList = new LinkedList<>();
  private String _otherField = "asdf";

  @Override
  public boolean add(String e) {
    return _wrappedList.add(e);
  }

  @Override
  ...
}

The result of new Gson().toJson(collectionImplementationInstance) is:

["str1","str2",...]

which misses the other field. Instead, I would like to get:

{"_wrappedList":["str1","str2"],"_otherField":"asdf"}

Is there a way without manually adding all fields to the JSON?

Answer 1

Based on this tutorial you can use a JsonSerializer.

Note: in the example below I've renamed your class CollectionImpl.

public class CollectionImpl implements Collection<String> {

    private final List<String> _wrappedList = new LinkedList<>();
    private String _otherField = "asdf";

    // ...

    // Note: I've created the class as subclass of CollectionImpl in order to access the
    // private fields without implementing a getter (as you maybe want to keep 
    // your fields completely private)
    public static class CollectionImplJsonSerializer implements JsonSerializer<CollectionImpl> {
        @Override
        public JsonElement serialize(CollectionImpl src, Type typeOfSrc, JsonSerializationContext context) {
            JsonObject jsonColl = new JsonObject();
            JsonArray array = new JsonArray();

            for (String s: src._wrappedList) {
                array.add(s);
            }

            jsonColl.add("_wrappedList", array);
            jsonColl.addProperty("_otherField", src._otherField);


            return jsonColl;
        }
    }
}

Then you can do:

CollectionImpl ci = new CollectionImpl();

GsonBuilder builder = new GsonBuilder();
CollectionImpl.CollectionImplJsonSerializer serializer = new CollectionImpl.CollectionImplJsonSerializer();
builder.registerTypeAdapter(CollectionImpl.class, serializer);
Gson gson = builder.create();

String json = gson.toJson(ci);

Answer 2

As a workaround, one can use Reflection to get an instance of the ReflectiveTypeAdapterFactory in an own TypeAdapterFactory :

public class CollectionImplementationTypeAdapterFactory implements TypeAdapterFactory {
  @Override
  public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
    if (!type.getRawType().equals(CollectionImplementation.class)) {
      return null;
    }
    try {
      Field factoriesField = Gson.class.getDeclaredField("factories");
      factoriesField.setAccessible(true);
      @SuppressWarnings("unchecked")
      List<TypeAdapterFactory> factories = (List<TypeAdapterFactory>) factoriesField.get(gson);
      TypeAdapterFactory typeAdapterFactory = factories.stream().filter(f -> f instanceof ReflectiveTypeAdapterFactory).findAny().get();
      return typeAdapterFactory.create(gson, type);
    } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException exception) {
      return null;
    }
  }
}

This can be registered with

gsonBuilder.registerTypeAdapterFactory(new CollectionImplementationTypeAdapterFactory());

Does someone know a solution without Reflection?