Mson,让JSON序列化更快

本文由秦喆 芝任 天洲 赵鹏四位作者共同完成。

问题

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

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

图 1

图 2

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

如何优化

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

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

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

使用JSONObject的实现方式如下:

public class Bean {    public String key;    public String title;    public String[] values;    public String defaultValue;    public static Bean fromJsonString(String json) {        try {
            JSONObject jsonObject = new JSONObject(json);
            Bean bean = new Bean();
            bean.key = jsonObject.optString("key");
            bean.title = jsonObject.optString("title");
            JSONArray jsonArray = jsonObject.optJSONArray("values");            if (jsonArray != null && jsonArray.length() > 0) {                int len = jsonArray.length();
                bean.values = new String[len];                for (int i=0; i<len; ++i) {
                    bean.values[i] = jsonArray.getString(i);
                }
            }
            bean.defaultValue = jsonObject.optString("defaultValue");            return bean;
        } catch (JSONException e) {
            e.printStackTrace();
        }        return null;
    }    public static String toJsonString(Bean bean) {        if (bean == null) {            return null;
        }
        JSONObject jsonObject = new JSONObject();        try {
            jsonObject.put("key", bean.key);
            jsonObject.put("title", bean.title);            if (bean.values != null) {
                JSONArray array = new JSONArray();                for (String str:bean.values) {
                    array.put(str);
                }
                jsonObject.put("values", array);
            }
            jsonObject.put("defaultValue", bean.defaultValue);
        } catch (JSONException e) {
            e.printStackTrace();
        }        return jsonObject.toString();
    }
}

测试代码:

private void test() {
    String a = "{\"key\":\"123\", \"title\":\"asd\", \"values\":[\"a\", \"b\", \"c\", \"d\"], \"defaultValue\":\"a\"}";

    Gson Gson = new Gson();
    Bean testBean = Gson.fromJson(a, new TypeToken<Bean>(){}.getType());    long now = System.currentTimeMillis();    for (int i=0; i<1000; ++i) {
        Gson.fromJson(a, new TypeToken<Bean>(){}.getType());
    }
    Log.d("time", "Gson parse use time="+(System.currentTimeMillis() - now));

    now = System.currentTimeMillis();    for (int i=0; i<1000; ++i) {
        Bean.fromJsonString(a);
    }
    Log.d("time", "jsonobject parse use time="+(System.currentTimeMillis() - now));

    now = System.currentTimeMillis();    for (int i=0; i<1000; ++i) {
        Gson.toJson(testBean);
    }
    Log.d("time", "Gson tojson use time="+(System.currentTimeMillis() - now));

    now = System.currentTimeMillis();    for (int i=0; i<1000; ++i) {
        Bean.toJsonString(testBean);
    }
    Log.d("time", "jsonobject tojson use time="+(System.currentTimeMillis() - now));
}

测试结果

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

工具

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

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

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

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

@Overridepublic boolean process(Set<? extends TypeElement> set, RoundEnvironment roundEnvironment) {
    Set<? extends Element> elements = roundEnvironment.getElementsAnnotatedWith(JsonType.class);    for (Element element : elements) {        if (element instanceof TypeElement) {
            processTypeElement((TypeElement) element);
        }
    }    return false;
}

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

JavaFileObject sourceFile = processingEnv.getFiler().createSourceFile(fullClassName);
ClassModel classModel = new ClassModel().setModifier("public final").setClassName(simpleClassName);
......
JavaFile javaFile = new JavaFile();
javaFile.setPackageModel(new PackageModel().setPackageName(packageName))
        .setImportModel(new ImportModel()
                .addImport(elementClassName)
                .addImport("com.meituan.android.Mson.IJsonObject")
                .addImport("com.meituan.android.Mson.IJsonArray")
                .addImport("com.meituan.android.Mson.exceptions.JsonParseException")
                .addImports(extension.getImportList())
        ).setClassModel(classModel);

List<? extends Element> enclosedElements = element.getEnclosedElements();for (Element e : enclosedElements) {    if (e.getKind() == ElementKind.FIELD) {
        processFieldElement(e, extension, toJsonMethodBlock, fromJsonMethodBlock);
    }
}try (Writer writer = sourceFile.openWriter()) {
    writer.write(javaFile.toSourceString());
    writer.flush();
    writer.close();
}

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

继续优化

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

代码如下:

Friend object = new Friend();
reader.beginObject();while (reader.hasNext()) {
    String field = reader.nextName();    if ("id".equals(field)) {
        object.id = reader.nextInt();
    } else if ("name".equals(field)) {        if (reader.peek() == JsonToken.NULL) {
            reader.nextNull();
            object.name = null;
        } else {
            object.name = reader.nextString();
        }
    } else {
        reader.skipValue();
    }
}
reader.endObject();

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

兼容性

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

性能及兼容性对比

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

测试用例如下:

@JsonTypepublic class Bean {    public Day day;    public List<Day> days;    public Day[] days1;    @JsonField("filed_a")    public byte a;    public char b;    public short c;    public int d;    public long e;    public float f;    public double g;    public boolean h;    @JsonField("filed_a1")    public byte[] a1;    public char[] b1;    public short[] c1;    public int[] d1;    public long[] e1;    public float[] f1;    public double[] g1;    public boolean[] h1;    public Byte a2;    public Character b2;    public Short c2;    public Integer d2;    public Long e2;    public Float f2;    public Double g2;    public Boolean h2;    @JsonField("name")    public String i2;    public Byte[] a3;    public Character[] b3;    public Short[] c3;    public Integer[] d3;    public Long[] e3;    public Float[] f3;    public Double[] g3;    public Boolean[] h3;    public String[] i3;    @JsonIgnore
    public String i4;    public transient String i5;    public static String i6;    public List<String> k;    public List<Integer> k1;    public Collection<Integer> k2;    public ArrayList<Integer> k3;    public Set<Integer> k4;    public HashSet<Integer> k5;    // fastjson 序列化会崩溃所以忽略掉了,下同
    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public List<int[]> k6;    public List<String[]> k7;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public List<List<Integer>> k8;    @JsonIgnore
    public List<Map<String, Integer>> k9;    @JsonIgnore
    public Map<String, String> l;    public Map<String, List<Integer>> l1;    public Map<Long, List<Integer>> l2;    public Map<Map<String, String>, String> l3;    public Map<String, Map<String, List<String>>> l4;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false) 
    public SparseArray<SimpleBean2> m1;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public SparseIntArray m2;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public SparseLongArray m3;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public SparseBooleanArray m4;    public SimpleBean2 bean;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public SimpleBean2[] bean1;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public List<SimpleBean2> bean2;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public Set<SimpleBean2> bean3;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public List<SimpleBean2[]> bean4;    @com.alibaba.fastjson.annotation.JSONField(serialize = false, deserialize = false)    public Map<String, SimpleBean2> bean5;
}

测试发现

  1. Gson的兼容性最好,能兼容几乎所有的类型,Mson其次,fastjson对嵌套类型支持比较弱。
  2. 性能方面Mson最好,Gson和fastjson相当。

测试结果如下:

方法数

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

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

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

Mson使用方法

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

1. 在Bean上加注解

@JsonTypepublic class Bean {    public String name;    public int age;    @JsonField("_desc")    public String description;  //使用JsonField 标注字段在json中的key
    public transient boolean state; //使用transient 不会被序列化
    @JsonIgnore
    public int state2; //使用JsonIgnore注解 不会被序列化}

2. 在需要序列化的地方:

Mson.fromJson(json, clazz); // 反序列化Mson.toJson(bean); // 序列化

结语

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

原文发布于微信公众号 - 美团点评技术团队(meituantech)

原文发表时间:2018-01-05

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏angularejs学习篇

angularjs学习第一天笔记

    您好,我是一名后端开发工程师,由于工作需要,现在系统的从0开始学习前端js框架之angular,每天把学习的一些心得分享出来,如果有什么说的不对的地方,...

662
来自专栏大内老A

一个关于解决序列化问题的编程技巧

在前一篇文章中我曾经说过,现在正在做一个小小的框架以实现采用统一的API实现对上下文(Context)信息的统一管理。这个框架同时支持Web和GUI应用,并支持...

1985
来自专栏angularejs学习篇

angularjs学习第一天笔记

    您好,我是一名后端开发工程师,由于工作需要,现在系统的从0开始学习前端js框架之angular,每天把学习的一些心得分享出来,如果有什么说的不对的地方,...

1011
来自专栏函数式编程语言及工具

Scalaz(53)- scalaz-stream: 程序运算器-application scenario

    从上面多篇的讨论中我们了解到scalaz-stream代表一串连续无穷的数据或者程序。对这个数据流的处理过程就是一个状态机器(state machine...

1789
来自专栏AhDung

【SQL】CLR聚合函数什么鬼

之前写过一个合并字符串的CLR聚合函数,基本是照抄MS的示例,外加了一些处理,已经投入使用很长时间,没什么问题也就没怎么研究,近日想改造一下,遇到一些问题,遂捣...

882
来自专栏偏前端工程师的驿站

(cljs/run-at (JSVM. :all) "一次说白DataType、Record和Protocol")

前言  在项目中我们一般会为实际问题域定义领域数据模型,譬如开发VDOM时自然而言就会定义个VNode数据类型,用于打包存储、操作相关数据。clj/cljs不单...

1828
来自专栏软件工程师成长笔记

Json字符串转JsonObject例子

Gson是Google发布的一个开源Java类库,能够很方便的在Java对象和JSON字符串之间进行序列化和反序列化。

1393
来自专栏逸鹏说道

C# 温故而知新:Stream篇(—)

目录: 什么是Stream? 什么是字节序列? Stream的构造函数 Stream的重要属性及方法 Stream的示例 Stream异步读写 Stream ...

3359
来自专栏点滴积累

geotrellis使用(三十)使用geotrellis读取PostGIS空间数据

前言 最近事情很多,各种你想不到的事情——such as singing and dancing——再加上最近又研究docker上瘾,所以geotrellis看...

3877
来自专栏技术点滴

从实现装饰者模式中思考C++指针和引用的选择

从实现装饰者模式中思考C++指针和引用的选择 最近在看设计模式的内容,偶然间手痒就写了一个“装饰者”模式的一个实例。该实例来源于风雪涟漪的博客,我对它做了简化。...

22910

扫码关注云+社区