|
|
|
|
移动端
创建专栏

MSON,让JSON序列化更快

本文介绍了一种高性能的JSON序列化工具MSON,以及它的产生原因和实现原理。目前我们已经有好多性能要求比较高的地方在使用,可以大幅的降低JSON的序列化时间。

作者:秦喆 芝任 天洲 赵鹏|2018-01-17 16:38

人工智能+区块链的发展趋势及应用调研报告


 问题

我们经常需要在主线程中读取一些配置文件或者缓存数据,最常用的结构化存储数据的方式就是将对象序列化为JSON字符串保存起来,这种方式特别简单而且可以和SharedPrefrence配合使用,因此应用广泛。但是目前用到的Gson在序列化JSON时很慢,在读取解析这些必要的配置文件时性能不佳,导致卡顿启动速度减慢等问题。

Gson的问题在哪里呢?笔者用AndroidStudio的profile工具分析了activity.onCreate方法的耗时情况。

如图1,可以发现Gson序列化占用了大部分的执行时间,从图2可以更直观地看到Gson.fromJson占用了61%的执行时间。分析Gson的源码可以发现,它在序列化时大量使用了反射,每一个field,每一个get、set都需要用反射,由此带来了性能问题。

如何优化

知道了性能的瓶颈之后,我们如何去修改呢?我能想到的方法就是尽量减少反射。

Android框架中由JSONObject来提供轻量级的JSON序列化工具,所以我选择用Android框架中的JSONObject来做序列化,然后手动复制到bean就可以去掉所有的反射。

我做了个简单的测试,分别用Gson和JSONObject的方式去序列化一个bean,看下各自速度如何。

使用JSONObject的实现方式如下:

  1. public class Bean { 
  2.  
  3.     public String key
  4.     public String title; 
  5.     public String[] values
  6.     public String defaultValue; 
  7.  
  8.     public static Bean fromJsonString(String json) { 
  9.         try { 
  10.             JSONObject jsonObject = new JSONObject(json); 
  11.             Bean bean = new Bean(); 
  12.             bean.key = jsonObject.optString("key"); 
  13.             bean.title = jsonObject.optString("title"); 
  14.             JSONArray jsonArray = jsonObject.optJSONArray("values"); 
  15.             if (jsonArray != null && jsonArray.length() > 0) { 
  16.                 int len = jsonArray.length(); 
  17.                 bean.values = new String[len]; 
  18.                 for (int i=0; i<len; ++i) { 
  19.                     bean.values[i] = jsonArray.getString(i); 
  20.                 } 
  21.             } 
  22.             bean.defaultValue = jsonObject.optString("defaultValue"); 
  23.  
  24.             return bean; 
  25.         } catch (JSONException e) { 
  26.             e.printStackTrace(); 
  27.         } 
  28.  
  29.         return null
  30.     } 
  31.  
  32.     public static String toJsonString(Bean bean) { 
  33.         if (bean == null) { 
  34.             return null
  35.         } 
  36.         JSONObject jsonObject = new JSONObject(); 
  37.         try { 
  38.             jsonObject.put("key", bean.key); 
  39.             jsonObject.put("title", bean.title); 
  40.             if (bean.values != null) { 
  41.                 JSONArray array = new JSONArray(); 
  42.                 for (String str:bean.values) { 
  43.                     array.put(str); 
  44.                 } 
  45.                 jsonObject.put("values", array); 
  46.             } 
  47.             jsonObject.put("defaultValue", bean.defaultValue); 
  48.         } catch (JSONException e) { 
  49.             e.printStackTrace(); 
  50.         } 
  51.  
  52.         return jsonObject.toString(); 
  53.     } 

测试代码:

  1. private void test() { 
  2.     String a = "{\"key\":\"123\", \"title\":\"asd\", \"values\":[\"a\", \"b\", \"c\", \"d\"], \"defaultValue\":\"a\"}"
  3.  
  4.     Gson Gson = new Gson(); 
  5.     Bean testBean = Gson.fromJson(a, new TypeToken<Bean>(){}.getType()); 
  6.  
  7.     long now = System.currentTimeMillis(); 
  8.     for (int i=0; i<1000; ++i) { 
  9.         Gson.fromJson(a, new TypeToken<Bean>(){}.getType()); 
  10.     } 
  11.     Log.d("time""Gson parse use time="+(System.currentTimeMillis() - now)); 
  12.  
  13.     now = System.currentTimeMillis(); 
  14.     for (int i=0; i<1000; ++i) { 
  15.         Bean.fromJsonString(a); 
  16.     } 
  17.     Log.d("time""jsonobject parse use time="+(System.currentTimeMillis() - now)); 
  18.  
  19.     now = System.currentTimeMillis(); 
  20.     for (int i=0; i<1000; ++i) { 
  21.         Gson.toJson(testBean); 
  22.     } 
  23.     Log.d("time""Gson tojson use time="+(System.currentTimeMillis() - now)); 
  24.  
  25.     now = System.currentTimeMillis(); 
  26.     for (int i=0; i<1000; ++i) { 
  27.         Bean.toJsonString(testBean); 
  28.     } 
  29.     Log.d("time""jsonobject tojson use time="+(System.currentTimeMillis() - now)); 

测试结果

执行1000次JSONObject,花费的时间是Gson的几十分之一。

工具

虽然JSONObject能够解决我们的问题,但在项目中有大量的存量代码都使用了Gson序列化,一处处去修改既耗费时间又容易出错,也不方便增加减少字段。

那么有没有一种方式在使用时和Gson一样简单且性能又特别好呢?

我们调研了Java的AnnotationProcessor(注解处理器),它能够在编译前对源码做处理。我们可以通过使用AnnotationProcessor为带有特定注解的bean自动生成相应的序列化和反序列化实现,用户只需要调用这些方法来完成序列化工作。

我们继承“AbstractProcessor”,在处理方法中找到有JsonType注解的bean来处理,代码如下:

  1. @Override 
  2. public boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) { 
  3.     Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(JsonType.class); 
  4.     for (Element element : elements) { 
  5.         if (element instanceof TypeElement) { 
  6.             processTypeElement((TypeElement) element); 
  7.         } 
  8.     } 
  9.     return false

然后生成对应的序列化方法,关键代码如下:

  1. JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(fullClassName); 
  2. ClassModel classModel = new ClassModel().setModifier("public final").setClassName(simpleClassName); 
  3. ...... 
  4. JavaFile javaFile = new JavaFile(); 
  5. javaFile.setPackageModel(new PackageModel().setPackageName(packageName)) 
  6.         .setImportModel(new ImportModel() 
  7.                 .addImport(elementClassName) 
  8.                 .addImport("com.meituan.android.MSON.IJsonObject"
  9.                 .addImport("com.meituan.android.MSON.IJsonArray"
  10.                 .addImport("com.meituan.android.MSON.exceptions.JsonParseException"
  11.                 .addImports(extension.getImportList()) 
  12.         ).setClassModel(classModel); 
  13.  
  14. List<? extends Element> enclosedElements = element.getEnclosedElements(); 
  15. for (Element e : enclosedElements) { 
  16.     if (e.getKind() == ElementKind.FIELD) { 
  17.         processFieldElement(e, extension, toJsonMethodBlock, fromJsonMethodBlock); 
  18.     } 
  19. try (Writer writer = sourceFile.openWriter()) { 
  20.     writer.write(javaFile.toSourceString()); 
  21.     writer.flush(); 
  22.     writer.close(); 

为了今后接入别的字符串和JSONObject的转换工具,我们封装了IJSONObject和IJsonArray,这样可以接入更高效的JSON解析和格式化工具。

继续优化

继续深入测试发现,当JSON数据量比较大时用JSONObject处理会比较慢,究其原因是JSONObject会一次性将字符串读进来解析成一个map,这样会有比较大的内存浪费和频繁内存创建。经过调研Gson内部的实现细节,发现Gson底层有流式的解析器而且可以按需解析,可以做到匹配上的字段才去解析。根据这个发现我们将我们IJSONObject和IJsonArray换成了Gson底层的流解析来进一步优化我们的速度。

代码如下:

  1. Friend object = new Friend(); 
  2. reader.beginObject(); 
  3. while (reader.hasNext()) { 
  4.     String field = reader.nextName(); 
  5.     if ("id".equals(field)) { 
  6.         object.id = reader.nextInt(); 
  7.     } else if ("name".equals(field)) { 
  8.         if (reader.peek() == JsonToken.NULL) { 
  9.             reader.nextNull(); 
  10.             object.name = null
  11.         } else { 
  12.             object.name = reader.nextString(); 
  13.         } 
  14.     } else { 
  15.         reader.skipValue(); 
  16.     } 
  17. reader.endObject(); 

代码中可以看到,Gson流解析过程中我们对于不认识的字段直接调用skipValue来节省不必要的时间浪费,而且是一个token接一个token读文本流这样内存中不会存一个大的JSON字符串。

兼容性

兼容性主要体现在能支持的数据类型上,目前MSON支持了基础数据类型,包装类型、枚举、数组、List、Set、Map、SparseArray以及各种嵌套类型(比如:Map<String, Map<String, List<String[]>>>)。

性能及兼容性对比

我们使用一个比较复杂的bean(包含了各种数据类型、嵌套类型)分别测试了Gson、fastjson和MSON的兼容性和性能。

测试用例如下:

  1. @JsonType 
  2. public class Bean { 
  3.     public Day day
  4.     public List<Day> days; 
  5.     public Day[] days1; 
  6.     @JsonField("filed_a"
  7.     public byte a; 
  8.     public char b; 
  9.     public short c; 
  10.     public int d; 
  11.     public long e; 
  12.     public float f; 
  13.     public double g; 
  14.     public boolean h; 
  15.  
  16.     @JsonField("filed_a1"
  17.     public byte[] a1; 
  18.     public char[] b1; 
  19.     public short[] c1; 
  20.     public int[] d1; 
  21.     public long[] e1; 
  22.     public float[] f1; 
  23.     public double[] g1; 
  24.     public boolean[] h1; 
  25.  
  26.     public Byte a2; 
  27.     public Character b2; 
  28.     public Short c2; 
  29.     public Integer d2; 
  30.     public Long e2; 
  31.     public Float f2; 
  32.     public Double g2; 
  33.     public Boolean h2; 
  34.     @JsonField("name"
  35.     public String i2; 
  36.  
  37.     public Byte[] a3; 
  38.     public Character[] b3; 
  39.     public Short[] c3; 
  40.     public Integer[] d3; 
  41.     public Long[] e3; 
  42.     public Float[] f3; 
  43.     public Double[] g3; 
  44.     public Boolean[] h3; 
  45.     public String[] i3; 
  46.  
  47.     @JsonIgnore 
  48.     public String i4; 
  49.     public transient String i5; 
  50.     public static String i6; 
  51.  
  52.     public List<String> k; 
  53.     public List<Integer> k1; 
  54.     public Collection<Integer> k2; 
  55.     public ArrayList<Integer> k3; 
  56.     public Set<Integer> k4; 
  57.     public HashSet<Integer> k5; 
  58.     // fastjson 序列化会崩溃所以忽略掉了,下同 
  59.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  60.     public List<int[]> k6; 
  61.     public List<String[]> k7; 
  62.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  63.     public List<List<Integer>> k8; 
  64.  
  65.     @JsonIgnore 
  66.     public List<Map<String, Integer>> k9; 
  67.     @JsonIgnore 
  68.     public Map<String, String> l; 
  69.     public Map<String, List<Integer>> l1; 
  70.     public Map<Long, List<Integer>> l2; 
  71.     public Map<Map<String, String>, String> l3; 
  72.     public Map<String, Map<String, List<String>>> l4; 
  73.  
  74.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)  
  75.     public SparseArray<SimpleBean2> m1; 
  76.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  77.     public SparseIntArray m2; 
  78.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  79.     public SparseLongArray m3; 
  80.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  81.     public SparseBooleanArray m4; 
  82.  
  83.     public SimpleBean2 bean; 
  84.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  85.     public SimpleBean2[] bean1; 
  86.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  87.     public List<SimpleBean2> bean2; 
  88.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  89.     public Set<SimpleBean2> bean3; 
  90.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  91.     public List<SimpleBean2[]> bean4; 
  92.     @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false
  93.     public Map<String, SimpleBean2> bean5; 

测试发现

Gson的兼容性最好,能兼容几乎所有的类型,MSON其次,fastjson对嵌套类型支持比较弱。

性能方面MSON最好,Gson和fastjson相当。

测试结果如下:

方法数

MSON本身方法数很少只有60个,在使用时会对每一个标注了JsonType的Bean生成2个方法,分别是:

  1. public String toJson(Bean bean) {...}              // 1 
  2. public Bean fromJson(String data) {...}            // 2 

另外MSON不需要对任何类做keep处理。

MSON使用方法

下面介绍MSON的使用方法,流程特别简单:

1. 在Bean上加注解

  1. @JsonType 
  2. public class Bean { 
  3.  
  4.     public String name
  5.     public int age; 
  6.     @JsonField("_desc"
  7.     public String description;  //使用JsonField 标注字段在json中的key 
  8.     public transient boolean state; //使用transient 不会被序列化 
  9.     @JsonIgnore 
  10.     public int state2; //使用JsonIgnore注解 不会被序列化 
  11.  

2. 在需要序列化的地方

  1. MSON.fromJson(json, clazz); // 反序列化 
  2. MSON.toJson(bean); // 序列化 

结语

本文介绍了一种高性能的JSON序列化工具MSON,以及它的产生原因和实现原理。目前我们已经有好多性能要求比较高的地方在使用,可以大幅的降低JSON的序列化时间。

【本文为51CTO专栏机构“美团点评技术团队”的原创稿件,转载请通过微信公众号联系机构获取授权】

戳这里,看该作者更多好文

【编辑推荐】

  1. java.lang.UnsupportedClassVersionError: org/json/JSONObject : Unsupported major.minor version 52.0
  2. MySQL5.7之Json Column和Generated Column
  3. 序列化: 一个老家伙的咸鱼翻身
  4. JSON简介及C代码展示JSON消息示例
  5. 将Intent序列化,像Uri一样传递Intent!!!
【责任编辑:武晓燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

热门职位+更多