json parse rendimiento entre jackson y gson

Question

Después de buscar en google, encontré que jackson tiene mejor rendimiento que gson, planeo reemplazar gson con jackson en mi proyecto, pero tengo un resultado diferente cuando corro el código de prueba.

private static final Type PHOTOLINKS_TYPE_GSON = new TypeToken<List<Photo>>() {}.getType(); 
private static final Type PHOTOCAPTIONS_TYPE_GSON = new TypeToken<List<String>>() {}.getType(); 
Gson gson = new Gson(); 
private void testGson(String photoJson, String captionJson) { 
    GSON_MON.start(); 
    List<Photo> photos = gson.fromJson(photoJson, PHOTOLINKS_TYPE_GSON); 
    List<String> photoCaptions = gson.fromJson(captionJson, PHOTOCAPTIONS_TYPE_GSON); 
    GSON_MON.stop(); 
} 

TypeReference<List<Photo>> PHOTOLINKS_TYPE_JACKSON = new TypeReference<List<Photo>>(){}; 
TypeReference<List<String>> PHOTOCAPTIONS_TYPE_JACKSON = new TypeReference<List<String>>(){}; 
ObjectMapper mapper = new ObjectMapper(); 
private void testJackson(String photoJson, String captionJson) { 
    JACKSON_MON.start(); 
    try { 
     List<Photo> photos = mapper.readValue(photoJson, PHOTOLINKS_TYPE_JACKSON); 
     List<String> photoCaptions = mapper.readValue(captionJson, PHOTOCAPTIONS_TYPE_JACKSON); 
    } catch (JsonParseException e) { 
     e.printStackTrace(); 
    } catch (JsonMappingException e) { 
     e.printStackTrace(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 

    JACKSON_MON.stop(); 
} 

Photo es una clase normal:

@JsonIgnoreProperties(ignoreUnknown = true) 
private static class Photo implements Serializable { 
private static final long serialVersionUID = 5645393489907650496L; 

public String small; 
public String middle; 
public String orign; 
public String caption; 
public String ow; 
public String oh; 
} 

y el JSON foto es algo así como: [{ "id": "1318403074887", "orign": "xxx.jpg"," ow ": 427," pequeño ":" xxx.jpg "," medio ":" xxx.jpg "," oh ": 640}, {" id ":" 1318403076793 "," orign ":" xxx.jpg " , "ow": 640, "pequeño": "xxx.jpg", "medio": "xxx.jpg", "oh": 480}, {"id": "1318403092168", "orign": "xxx. jpg "," ow ": 425," pequeño ":" xxx.jpg "," medio ":" xxx.jpg "," oh ": 640}]

uso JAMon para monitorear el rendimiento, a continuación se muestra el resultado:

• Label Jamón = Jackson, UNITS = MS .: (LastValue = 18,0, Hits = 30,0, Media = 18,4, Total = 552,0, Min = 13,0, Max = 37,0, Active = 0,0, activa AVG = 1,0, Max Active = 1.0)
• JAMon Label = gson, Unidades = ms .: (LastValue = 4.0, Hits = 30.0, Avg = 2.1666666666666665, Total = 65.0, Min = 0.0, Max = 4.0, Activo = 0.0, Avg Active = 1.0, Max activo = 1.0)
• JAMon Label = jackson, Unidades = ms .: (LastValue = 20.0, Hits = 30.0, Avg = 15.166666666666666, Total = 455.0, Min = 12.0, Max = 25.0, Activo = 0.0, Promedio Activo = 1.0, Máx Activo = 1.0)
• JAMon Label = gson, Unidades = ms .: (LastValue = 4.0, Hits = 30.0, Avg = 2.2, Total = 66.0, Min = 0.0, Máx. = 9.0, Activo = 0 . 0, Promedio activo = 1.0, Activo máximo = 1.0)
• JAMon Label = jackson, Unidades = ms .: (LastValue = 19.0, Hits = 30.0, Avg = 16.433333333333334, Total = 493.0, Min = 11.0, Max = 51.0, Activo = 0.0, Promedio activo = 1.0, Activo máximo = 1.0)
• JAMon Label = gson, Unidades = ms .: (LastValue = 2.0, Hits = 30.0, Avg = 1.9, Total = 57.0, Min = 0.0, Max = 6.0, Active = 0.0, media activa = 1,0, Max activa = 1,0)

parece GSON es más rápido que Jackson, el tiempo promedio de GSON es de aproximadamente 2 ms, mientras que Jackson es de aproximadamente 16 ms, lo hace hago error cuando usando jackson?

Answer 1

Puede ser un problema simple con la supervisión del rendimiento: parece que no está "calentando" la JVM ejecutando pruebas durante el tiempo suficiente para permitirle compilar el código de bytes, etc. Por lo general, las pruebas deben realizarse por lo menos de 5 a 10 segundos antes de tomar mediciones.

Así que quizás intente hacer eso primero, vea cómo cambian los números. Apuesto a que los números para ambos aumentarán, debería tomar una fracción de milisegundo para objetos pequeños.