12

我正在尝试使用 GSON 序列化 7000 POJO 的数组，并且序列化时间非常慢。序列化以下对象的数组大约需要 3-5 秒：

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;
}

关键字段使用自定义序列化器/反序列化器进行序列化：

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

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

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

    String s = src.getAsString();
    com.google.appengine.api.datastore.Key k = KeyFactory.stringToKey(s);
    return new Key(k);
}
}

为了测试手写 JSON 序列化程序的性能，我测试了以下代码，它可以比 GSON 快大约 10 倍地序列化相同的 Case 对象数组。

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());
    a.put(o);

}
String json = a.toString();

任何想法为什么 GSON 在这种情况下表现如此糟糕？

更新

这是实际启动序列化的代码：

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

更新2

这是一个非常简单的测试用例，说明了相对于 org.json 的较差性能：

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

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();
    o.put("id", f.id);
    a.put(o);

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

System.out.println(json.equals(s));

Foo 在哪里：

public class Foo {
public Long id;
}

这输出：

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

几乎 10 倍的性能差异！

4

2 回答 2

6

我试图重现您的问题，但无法重现。我创建了 7000 个包含重要数据的对象。在我的 ThinkPad 上，Gson 需要约 260 毫秒来序列化约 3MB 的 Gson，这是一个可观的约 10Mbps。

大部分时间用于将日期转换为字符串。将两个日期字段转换为“long”节省了大约 50 毫秒。

通过从树适配器（JsonSerializer/JsonDeserializer）迁移到新的流适配器类，我能够节省大约 10 毫秒TypeAdaper。设置它的代码如下所示：

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

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

    ...

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

我的场景和你的场景之间的主要区别在于我使用的是我自己的伪造 Key 类。但是，如果 Key 是您手动序列化每个案例时应该出现的瓶颈。

解决问题

最好的下一步是在Case序列化改进之前删除字段。您的某个字段可能包含需要很长时间才能序列化的内容：可能是一个非常长的字符串，需要过度转义？隔离问题后，向 Gson 项目报告错误，我们将很高兴地解决问题。除了包含重现问题的代码之外，您还应该包含代表性数据。

于 2012-05-22T14:26:36.773 回答
1

如何在 json 上使用平面缓冲区。

https://medium.freecodecamp.com/why-consider-flatbuffer-over-json-2e4aa8d4ed07#.d79exjq8n

于 2016-09-09T09:45:02.110 回答