Jackson 使用自定义反序列化器进行反序列化会导致大量 GC 调用并花费更长的时间

Question

为了解决我在in this thread 讨论的类型不匹配问题，我创建了自定义Deserializers 并将它们添加到ObjectMapper。但是，性能会因此而显着下降。

使用默认反序列化器，我在logcat 中获得 1-2 次垃圾收集调用，而使用自定义反序列化器至少有 7-8 次 GC 调用，因此处理时间也显着增加。

我的反序列化器：

public class Deserializer<T> {

public JsonDeserializer<T> getDeserializer(final Class<T> cls) {
  return new JsonDeserializer<T> (){

     @Override
     public T deserialize(JsonParser jp, DeserializationContext arg1) throws IOException, JsonProcessingException {
        JsonNode node = jp.readValueAsTree();
        if (node.isObject()) {
          return new ObjectMapper().convertValue(node, cls);
        }
        return null;
     }
 };
}
} 

我正在使用它来添加到 Mapper

public class DeserializerAttachedMapper<T> {

   public ObjectMapper getMapperAttachedWith(final Class<T> cls , JsonDeserializer<T> deserializer) {
      ObjectMapper mapper = new ObjectMapper();
      SimpleModule module = new SimpleModule(deserializer.toString(), new Version(1, 0, 0, null, null, null));
      module.addDeserializer(cls, deserializer);
      mapper.registerModule(module);
      return mapper;
   }
}

编辑：添加额外数据

我的 JSON 相当大，但不是很大： 我已经粘贴了it here

如果我使用此代码，现在解析相同的 JSON：

   String response = ConnectionManager.doGet(mAuthType, url, authToken);
    FLog.d("location object response" + response);
  //        SimpleModule module = new SimpleModule("UserModule", new Version(1, 0, 0, null, null, null));
  //        JsonDeserializer<User> userDeserializer = new Deserializer<User>().getDeserializer(User.class);     
  //        module.addDeserializer(User.class, userDeserializer);

    ObjectMapper mapper = new ObjectMapper();
  //        mapper.registerModule(module);
    JsonNode tree = mapper.readTree(response);
    Integer code = Integer.parseInt(tree.get("code").asText().trim());

    if(Constants.API_RESPONSE_SUCCESS_CODE == code) {
        ExploreLocationObject locationObject = mapper.convertValue(tree.path("response").get("locationObject"), ExploreLocationObject.class);
        FLog.d("locationObject" + locationObject);
        FLog.d("locationObject events" + locationObject.getEvents().size());
        return locationObject;
    }       
    return null;    

那我的logcat是like this

但如果我将此代码用于相同的 JSON

        String response = ConnectionManager.doGet(mAuthType, url, authToken);
    FLog.d("location object response" + response);
    SimpleModule module = new SimpleModule("UserModule", new Version(1, 0, 0, null, null, null));
    JsonDeserializer<User> userDeserializer = new Deserializer<User>().getDeserializer(User.class);

    module.addDeserializer(User.class, userDeserializer);
    ObjectMapper mapper = new ObjectMapper();
    mapper.registerModule(module);
    JsonNode tree = mapper.readTree(response);
    Integer code = Integer.parseInt(tree.get("code").asText().trim());

    if(Constants.API_RESPONSE_SUCCESS_CODE == code) {
        ExploreLocationObject locationObject = mapper.convertValue(tree.path("response").get("locationObject"), ExploreLocationObject.class);
        FLog.d("locationObject" + locationObject);
        FLog.d("locationObject events" + locationObject.getEvents().size());
        return locationObject;
    }       
    return null;        

那我的logcat是like this

Answer 1

物体有多大？代码基本上构建了一个树模型（某种 dom 树），这将占用原始文档的 3 到 5 倍的内存。所以我假设你的输入是一个巨大的 JSON 文档。

您绝对可以使用 Streaming API 编写更高效的版本。比如：

JsonParser jp = mapper.getJsonFactory().createJsonParser(input);
JsonToken t = jp.nextToken();
if (t == JsonToken.START_OBJECT) {
   return mapper.readValue(jp, classToBindTo);
}
return null;

也可以通过数据绑定（如JsonDeserializer）来实现这一点，但仅仅因为你想委托给“默认”反序列化器，它变得有点复杂。 为此，您需要实现BeanDeserializerModifier，并在调用“modifyDeserializer”时替换标准反序列化器：您自己的代码可以保留对原始反序列化器的引用并委托给它，而不是使用中间树模型。

Answer 2

如果您不依赖于 jackson，您也可以尝试 Genson http://code.google.com/p/genson/。 在您的情况下，有两个主要优点：您不会失去性能，它应该更容易实现。如果属性事件不是以大写字母开头，则使用 @JsonProperty("Event") 对其进行注释（其他以大写字母开头的属性也是如此）。 使用以下代码，您应该完成：

Genson genson = new Genson.Builder()
            .withDeserializerFactory(new EventDeserializerFactory()).create();

YourRootClass[] bean = genson.deserialize(json, YourRootClass[].class);

class EventDeserializerFactory implements Factory<Deserializer<Event>> {

    public Deserializer<Event> create(Type type, Genson genson) {
        return new EventDeserializer(genson.getBeanDescriptorFactory().provide(Event.class,
                genson));
    }

}

class EventDeserializer implements Deserializer<Event> {
    private final Deserializer<Event> standardEventDeserializer;

    public EventDeserializer(Deserializer<Event> standardEventDeserializer) {
        this.standardEventDeserializer = standardEventDeserializer;
    }

    public Event deserialize(ObjectReader reader, Context ctx) throws TransformationException,
            IOException {
        if (ValueType.ARRAY == reader.getValueType()) {
            reader.beginArray().endArray();
            return null;
        }
        return standardEventDeserializer.deserialize(reader, ctx);
    }
}