Gson

Gson is a Java library that can be used to convert Java Objects into their JSON representation and vice versa.

Add dependency

dependencies {
    implementation 'com.google.code.gson:gson:2.8.6'
}

Gson is very easy to use.

class OtherCls {
        long field = 23;
        String name = "unknown";
    }

    class Cls {
        long id  = 0L;
        int [] array = {1,2,3};
        List<String> list = new ArrayList();
        OtherCls obj = new OtherCls();
        Map<String, String> map =  new HashMap();
    }
public static void main(String[] args) {
    Cls srcObj = new Cls();
    srcObj.map.put("book", "Harry Potter");

    String srcJson = new StringBuilder()
      .append("{")
      .append("id:").append("1000").append(",\n")
      .append("array:").append("[10,11,12]").append(",\n")
      .append("list:").append("[20,21,22]").append(",\n")
      .append("map:").append("{book1 : 'Tolkin', book2: 'Vinni Puh'}").append(",\n")
      .append("obj:").append("{field: 66, name: \"hello\"}")
      .append("}").toString();
// how to use library
    Gson gson = new Gson();
    String dstJson = gson.toJson(srcObj);
    JsonElement dstTree = gson.toJsonTree(srcObj);
    Cls dstObj = gson.fromJson(srcJson, Cls.class);
    System.out.println(dstJson);
    System.out.println(dstObj.map.get("book2"));}

You can get more information at Gson on GitHub.

annotations

By default, all fields of an object will be serialized/deserialized.

Google Gson provides useful annotations which can customize the serialization/deserialization of object to/from JSON.

class Card {
    @SerializedName("_id")
    long id;

    @Expose
    int field1;
    
    @Expose (serialize = false, deserialize = false)
    Drawable thumb;
    
    String[] tags=[];
}

custom serialization and deserialization

By default Gson converts application classes to JSON using its built-in type adapters. Gson allows to provide a custom adapters for

• JSON serializers - custom serialization for an object
• JSON deserializers - custom deserialization for a type
• instance creators - not needed if no-args constructor is available or a deserializer is registered
• type adapters - if Gson's default JSON conversion isn't appropriate for a type, extend the TypeAdapter class to customize the conversion.

GsonBuilder gson = new GsonBuilder();
gson.registerTypeAdapter(MyType2.class, new MyTypeAdapter());
gson.registerTypeAdapter(MyType.class, new MySerializer());
gson.registerTypeAdapter(MyType.class, new MyDeserializer());
gson.registerTypeAdapter(MyType.class, new MyInstanceCreator());
private class DateTimeSerializer implements JsonSerializer<DateTime> {
  public JsonElement serialize(DateTime src, Type typeOfSrc, JsonSerializationContext context) {
    return new JsonPrimitive(src.toString());
  }
}
private class DateTimeDeserializer implements JsonDeserializer<DateTime> {
  public DateTime deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
      throws JsonParseException {
    return new DateTime(json.getAsJsonPrimitive().getAsString());
  }
}
private class MoneyInstanceCreator implements InstanceCreator<Money> {
  public Money createInstance(Type type) {
    return new Money("1000000", CurrencyCode.USD);
  }
}

class MyList<T> extends ArrayList<T> {
}

class MyListInstanceCreator implements InstanceCreator<MyList<?>> {
    @SuppressWarnings("unchecked")
  public MyList<?> createInstance(Type type) {
    // No need to use a parameterized list since the actual instance will have the raw type anyway.
    return new MyList();
  }
}