aloo aloo - 4 months ago 11
JSON Question

GSON Serialization very very slow

I'm trying to serialize an array of 7000 POJO using GSON and the serialization time is extremely slow. It's on the order of 3-5 seconds to serialize an array of the following object:

public class Case {
private Long caseId;
private Key<Organization> orgKey;

private Key<Workflow> workflowKey;
private Key<User> creatorKey;

private Date creationTimestamp;
private Date lastUpdatedTimestamp;

private String name;
private String stage;
private String notes;

The key fields are serialized using a custom serializer/deserializer:

public class GsonKeySerializerDeserializer implements JsonSerializer<Key<?>>, JsonDeserializer<Key<?>>{

public JsonElement serialize(Key<?> src, Type typeOfSrc, JsonSerializationContext arg2) {
return new JsonPrimitive(src.getString());

public Key<?> deserialize(JsonElement src, Type typeOfSrc, JsonDeserializationContext arg2) throws JsonParseException {
if (src.isJsonNull() || src.getAsString().isEmpty()) {
return null;

String s = src.getAsString(); k = KeyFactory.stringToKey(s);
return new Key(k);

To test the performance against hand writing a JSON serializer, I tested the following code and it could serialize the same array of Case objects approximately 10x faster than GSON.

List<Case> cases = (List<Case>) retVal;
JSONArray a = new JSONArray();
for (Case c : cases) {
JSONObject o = new JSONObject();
o.put("caseId", c.getCaseId());
o.put("orgKey", c.getOrgKey().getString());
o.put("workflowKey", c.getWorkflowKey().getString());
o.put("creatorKey", c.getCreatorKey().getString());
o.put("creationTimestamp", c.getCreationTimestamp().getTime());
o.put("lastUpdatedTimestamp", c.getLastUpdatedTimestamp().getTime());
o.put("name", c.getName());
o.put("stage", c.getStage());
o.put("notes", c.getNotes());

String json = a.toString();

Any ideas why GSON is performing so badly in this case?


Here's the code that actually starts the serialization:

Object retVal = someFunctionThatReturnsAList();
String json = g.toJson(retVal);


Here's a very simple test case that illustrates the poor performance relative to org.json:

List<Foo> list = new ArrayList<Foo>();
for (int i = 0; i < 7001; i++) {
Foo f = new Foo(); = new Long(i);

Gson gs = new Gson();
long start = System.currentTimeMillis();
String s = gs.toJson(list);
System.out.println("Serialization time using Gson: " + ((double) (System.currentTimeMillis() - start) / 1000));

start = System.currentTimeMillis();
JSONArray a = new JSONArray();
for (Foo f : list) {
JSONObject o = new JSONObject();

String json = a.toString();
System.out.println("Serialization time using org.json: " + ((double) (System.currentTimeMillis() - start) / 1000));


Where Foo is:

public class Foo {
public Long id;

This outputs:

Serialization time using Gson: 0.233
Serialization time using org.json: 0.028

An almost 10x performance difference!


I attempted to reproduce your problem and could not. I created 7000 objects with nontrivial data in them. On my ThinkPad it took Gson ~260ms to serialize ~3MB of Gson, which is a respectable ~10Mbps.

A large fraction of that time was spent converting dates to strings. Converting the two date fields to 'long' saved about 50ms.

I was able to save another ~10ms by migrating from tree adapters (JsonSerializer/JsonDeserializer) to the new streaming adapter class TypeAdaper. The code that sets this up looks like this:

    private static TypeAdapter<Key<String>> keyAdapter = new TypeAdapter<Key<String>>() {
        @Override public void write(JsonWriter out, Key<String> value) throws IOException {

        @Override public Key<String> read(JsonReader in) throws IOException {
            if (in.peek() == JsonToken.NULL) {
                return null;
            return new Key<String>(in.nextString());


    Gson gson = new GsonBuilder()
            .registerTypeAdapter(Key.class, keyAdapter)

The main difference between my scenario and yours is that I'm using my own bogus Key class. But if the Key was the bottleneck that should have come up when you manually serialized each case.

Fixing the problem

Your best next step is to remove fields from Case until serialization improves. It's possible that one of your fields contains something that's taking a long time to serialize: perhaps a very long string that requires excessive escaping? Once you isolate the problem report a bug to the Gson project and we'll happily fix the problem. In addition to including the code that reproduces the problem you should also include representative data.