Android json 解析，你不知道的事

最新推荐文章于 2022-09-02 16:37:38 发布
最新推荐文章于 2022-09-02 16:37:38 发布
阅读量335 收藏 1
点赞数
分类专栏： Android 文章标签： android json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxloveooo/article/details/104920723
版权

我们一般写 json 解析，一般都是使用比较成熟的第三方库gson、fastjson、jackson等。

但是你知道吗？

这些库在使用的时候，bean对象不能混淆，而且底层是通过反射来对每个属性就行赋值，那么在性能损耗上就会大大增加。

1. 反序列化

让我们来看看实际的例子：

1.1 定义 json

定义一个 json,就是普通的一个对象

const val json = """
{
    "id": 912345678902,
    "text": "@android_newb just use android.util.JsonReader!",
    "geo": [
      50.454722,
      -104.606667
    ],
    "user": {
      "name": "jesse",
      "followers_count": 2
    }
}"""

1.2 创建模型对象类

data class ModelUser(var name: String? = "", var followers_count: Int? = 0)

data class Model(
    var id: Long? = 0,
    var text: String? = "",
    var geo: List<Double>? = null,
    var user: ModelUser? = null
)

1.3 gson 解析

我们使用 gson 来解析对象，代码如下

fun testGson() {
    val beginTime = System.nanoTime()
    val gson = Gson()
    val models = gson.fromJson<Model>(json, Model::class.java)
    Log.d("zyh", "gson消耗：" + (System.nanoTime() - beginTime) / 1000 + "微秒")
    Log.d("zyh", models.toString())
}

结果如下：

gson消耗：28643微秒
Model(id=912345678902, text=@android_newb just use android.util.JsonReader!, geo=[50.454722, -104.606667], user=ModelUser(name=jesse, followers_count=2))

我们记住这个数字 28643微秒。

因为没有对比就没有伤害。

1.4 JSONObject 解析

使用原生的 jsonObject 解析

fun testJsonObject() {
    val beginTime = System.nanoTime()
    val jsonObject = JSONObject(json)
    val model = Model()
    model.id = jsonObject.optLong("id")
    model.text = jsonObject.optString("text")
    val array = jsonObject.optJSONArray("geo")
    val arraylist = arrayListOf<Double>()
    for (item in 0 until array.length()) {
        arraylist.add(array[item] as Double)
    }
    model.geo = arraylist
    val user = ModelUser()
    val userObject = jsonObject.optJSONObject("user")
    user.name = userObject.optString("name")
    user.followers_count = userObject.optInt("followers_count")
    model.user = user
    Log.d("zyh", "testJsonObject消耗：" + (System.nanoTime() - beginTime) / 1000 + "微秒")
    Log.d("zyh", model.toString())
}

结果如下：

testJsonObject消耗：865微秒
Model(id=912345678902, text=@android_newb just use android.util.JsonReader!, geo=[50.454722, -104.606667], user=ModelUser(name=jesse, followers_count=2))

和使用 gson 解析相比，结果差了 33 倍。那么现在你觉得使用第三方开源库还快吗？

1.6 JsonReader 解析

如果你的数据量 json 特别的大的时候，由于 JSONObject 是把所有的 json 全加载到内存中的，会造成内存的暴涨，这时候可以使用进阶类 JsonReader 类，通过流的方式，读取一段解析一段。这样内存就不会暴涨，保证运行的稳定性。

使用 JsonReader 解析的代码如下：

fun testJsonReader() {
    val beginTime = System.nanoTime()
    val inputStream = ByteArrayInputStream(json.toByteArray())
    //通过流来完成 jsonReader 的创建
    val jsonReader = JsonReader(InputStreamReader(inputStream, "UTF-8"))
    jsonReader.beginObject()
    val model = Model()
    while (jsonReader.hasNext()) {
        when (jsonReader.nextName()) {
            "id" -> {
                model.id = jsonReader.nextLong()
            }
            "text" -> {
                model.text = jsonReader.nextString()
            }
            "geo" -> {
                if (jsonReader.peek() != JsonToken.NULL) {
                    val doubles = arrayListOf<Double>()
                    jsonReader.beginArray()
                    while (jsonReader.hasNext()) {
                        doubles.add(jsonReader.nextDouble())
                    }
                    jsonReader.endArray()
                    model.geo = doubles
                } else {
                    jsonReader.skipValue()
                }
            }
            "user" -> {
                if (jsonReader.peek() != JsonToken.NULL) {
                    val modelUser = ModelUser()
                    jsonReader.beginObject()
                    while (jsonReader.hasNext()) {
                        when (jsonReader.nextName()) {
                            "name" -> {
                                modelUser.name = jsonReader.nextString()
                            }
                            "followers_count" -> {
                                modelUser.followers_count = jsonReader.nextInt()
                            }
                            else -> {
                                jsonReader.skipValue()
                            }
                        }
                    }
                    jsonReader.endObject()
                    model.user = modelUser
                } else {
                    jsonReader.skipValue()
                }
            }
            else -> {
                jsonReader.skipValue()
            }
        }
    }
    jsonReader.endObject()
    Log.d("zyh", "testJsonReader消耗：" + (System.nanoTime() - beginTime) / 1000 + "微秒")
    //打印输出
    Log.d("zyh", model.toString())
}

结果：

testJsonReader消耗：1871微秒
Model(id=912345678902, text=@android_newb just use android.util.JsonReader!, geo=[50.454722, -104.606667], user=ModelUser(name=jesse, followers_count=2))

消耗的时间和使用 JSONObject 对比来说，大了 2.1倍，但是还是比使用第三库小太多了。

1.7 总结对比

解析方式消耗时间(一加 3t)821消耗时间(一加 7pro)855
Gson28643微秒8227微秒
JsonObject865微秒154微秒
JsonReader1871微秒431微秒

2. 序列化

让我们来看一下 序列化 的时间对比

2.1 gson 序列化

fun testCreateGson(model: Model) {
    val beginTime = System.nanoTime()
    val models = Gson().toJson(model)
    Log.d("zyh", "gson消耗：" + (System.nanoTime() - beginTime) / 1000 + "微秒")
    Log.d("zyh", models.toString())
}

结果如下：

16873微秒
{"geo":[50.454722,-104.606667],"id":912345678902,"text":"@android_newb just use android.util.JsonReader!","user":{"followers_count":2,"name":"jesse"}}

2.2 JSONObject 序列化

fun testCreateJson(model: Model) {
    val beginTime = System.nanoTime()
    val jsonObject = JSONObject()
    jsonObject.put("id", model.id)
    jsonObject.put("text", model.text)

    val jsonArray = JSONArray()
    for (item in model.geo!!.indices) {
        jsonArray.put(model.geo!![item])
    }
    jsonObject.put("geo", jsonArray)

    val jsonUser = JSONObject()
    jsonUser.put("name", model.user?.name)
    jsonUser.put("followers_count", model.user?.followers_count)
    jsonObject.put("user", jsonUser)

    Log.d("zyh", "testJsonObject消耗：" + (System.nanoTime() - beginTime) / 1000 + "微秒")
    Log.d("zyh", jsonObject.toString())
}

结果如下

160微秒
{"id":912345678902,"text":"@android_newb just use android.util.JsonReader!","geo":[50.454722,-104.606667],"user":{"name":"jesse","followers_count":2}}

JSONObject 比 gson 快 105 倍以上。

2.3 总结对比

序列化方式消耗时间（一加 3t）821消耗时间（一加 7pro）855
Gson16874微秒3248微秒
JsonObject160微秒29微秒

3. 解决方案

那么在开发中应该如何来加速 json 的解析，减少 json 解析对代码的影响呢？

  • MSON，让JSON序列化更快–美团
  • 阿里的JsonLube
  • moshi 的Codegen

3.1 MSON

官方介绍，但是此方案经过这么长时间了，也没有开源。

根据描述的知，此方案是通过 APT 的方式，在编译的时候动态的生成具体的JSONObject 的序列化和反序列话的代码。

在使用的时候，通过 MSON 类，来解析。

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

3.2 JsonLube

源码地址

此方案是阿里开源的方案，也是通过 APT 的方式，在编译的时候动态的生成具体的JSONObject 的序列化和反序列话的代码。

通过注解的方式，在想要生成的类的地方，加上 @FromJson 和 @ToJson 的注解。

@FromJson
@ToJson
public class Teacher {
	private String name;
  private int age;
  public List<Student> students;  //支持bean的嵌套
  //...get/set 方法
}

public class Student {
	public String name;
	public int age;
	public int sex;
}

这样就可以在编译的时候生成下面的类。

image-20200304174641133

生成解析类

@ProguardKeep
public final class Teacher_JsonLubeParser implements Serializable {
    public Teacher_JsonLubeParser() {
    }

    public static Teacher parse(JSONObject data) {
        if (data == null) {
            return null;
        } else {
            Teacher bean = new Teacher();
            bean.name = data.optString("name", bean.name);
            bean.age = data.optInt("age", bean.age);
            JSONArray studentsJsonArray = data.optJSONArray("students");
            if (studentsJsonArray != null) {
                int len = studentsJsonArray.length();
                ArrayList<Student> studentsList = new ArrayList(len);

                for(int i = 0; i < len; ++i) {
                    Student item = Student_JsonLubeParser.parse(studentsJsonArray.optJSONObject(i));
                    studentsList.add(item);
                }

                bean.students = studentsList;
            }

            bean.bestStudent = Student_JsonLubeParser.parse(data.optJSONObject("bestStudent"));
            bean.setSex(data.optInt("sex", bean.getSex()));
            return bean;
        }
    }
}

生成序列化的类

@ProguardKeep
public final class Teacher_JsonLubeSerializer implements Serializable {
    public Teacher_JsonLubeSerializer() {
    }

    public static JSONObject serialize(Teacher bean) throws JSONException {
        if (bean == null) {
            return null;
        } else {
            JSONObject data = new JSONObject();
            data.put("name", bean.name);
            data.put("age", bean.age);
            if (bean.students != null) {
                JSONArray studentsJsonArray = new JSONArray();
                Iterator var3 = bean.students.iterator();

                while(var3.hasNext()) {
                    Student item = (Student)var3.next();
                    if (item != null) {
                        studentsJsonArray.put(Student_JsonLubeSerializer.serialize(item));
                    }
                }

                data.put("students", studentsJsonArray);
            }

            data.put("bestStudent", Student_JsonLubeSerializer.serialize(bean.bestStudent));
            data.put("sex", bean.getSex());
            return data;
        }
    }
}

3.3 moshi

源码地址

moshi 支持 kotlin 的 Codegen ,仅支持 kotlin 。

需要在使用的地方加上注解 @JsonClass(generateAdapter = true) 。

@JsonClass(generateAdapter = true)
data class ConfigBean(var isGood: Boolean ,var title: String ,var type: CustomType)

通过编译，自动生成的 kotlin 的 fromJson 和 toJson.

override fun fromJson(reader: JsonReader): ConfigBean {
    var isGood: Boolean? = null
    var title: String? = null
    var type: CustomType? = null
    reader.beginObject()
    while (reader.hasNext()) {
        when (reader.selectName(options)) {
            0 -> isGood = booleanAdapter.fromJson(reader) 
            1 -> title = stringAdapter.fromJson(reader) 
            2 -> type = customTypeAdapter.fromJson(reader)
            -1 -> {
                reader.skipName()
                reader.skipValue()
            }
        }
    }
    reader.endObject()
    var result = ConfigBean(isGood = isGood ,title = title ,type = type
    return result
}

override fun toJson(writer: JsonWriter, value: ConfigBean?) {
    writer.beginObject()
    writer.name("isGood")
    booleanAdapter.toJson(writer, value.isGood)
    writer.name("title")
    stringAdapter.toJson(writer, value.title)
    writer.name("type")
    customTypeAdapter.toJson(writer, value.type)
    writer.endObject()
}

4. 进阶

参考上面的解决方案，我们可以得知，现在有两种方式来解决

两种解决方案：

  1. 新项目直接在原有的bean 中创建tojson 和 fromjson 方法，继承 IJSON 接口这样就可以通过 JSON解析类来统一进行转换，这种情况下不需要混淆。
  2. 老项目中有很多 bean ,这样的情况下，我们可以通过JsonLube或者moshi来解决，然后增加混淆。

4.1 新项目

编写 idea 或者 Android studio 的插件，使用插件来自动生成 toJson 和 fromJson 方法，或者手写toJson和fromJson方法，这样的话在混淆的时候，不需要 keep 住模型类，所有代码都可以混淆。不过手写解析工作量太大，且容易出错。

public interface ITestJson {
    Object fromJson(String json) throws Exception;
    String toJson() throws Exception;
}
public class MOSN {
    public static <T extends ITestJson> T fromJson(String json, Class<T> clazz) throws Exception {
        ITestJson iTestJson = clazz.newInstance();
        return (T) iTestJson.fromJson(json);
    }
    public static String toJson(ITestJson iTestJson) throws Exception {
        return iTestJson.toJson();
    }
}
//具体使用
TestPerson testPerson = MOSN.fromJson("", TestPerson.class);
String json = MOSN.toJson(testPerson);

public class TestPerson implements ITestJson {

    @JsonName("name")
    private String name;
    @JsonName("age")
    private int age;

    public TestPerson fromJson(String json) throws Exception {
        JSONObject jsonObject = new JSONObject(json);
        name = jsonObject.optString("name");
        age = jsonObject.optInt("age");
        return this;
    }

    public String toJson() throws Exception {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", name);
        jsonObject.put("age", age);
        return jsonObject.toString();
    }
}

4.2 老项目

通过JsonLube或者moshi来解决，但是存在一些问题。

  • 生成的类不能混淆，因为要通过模型类找到具体的生成类。
  • 模型类也不能混淆，因为要使用 get/set 方法。

由于代码中使用了反射，所以不能混淆序列化和反序列话的方法名和类名。

解决不能混淆方法名的问题，因为这个类中只有一个方法，所以我们可以通过getDeclaredMethods()来获取这个类的所有方法。

public static <T> T fromJson(JSONObject json, Class<T> clazz) throws JsonLubeParseException {
    String parserClassName = getParserClassName(clazz);
    try {
        //因为生成的 bean 对象中 只有一个方法
        Class<?> parserClass = Class.forName(parserClassName);
        Method method = parserClass.getDeclaredMethods()[0];//获取类的方法，不包括父类的方法
        return (T) method.invoke(null, json);
//            Method parseMethod = parserClass.getMethod("parse", JSONObject.class);
//            return (T) parseMethod.invoke(null, json);
    } catch (Exception e) {
        throw new JsonLubeParseException(e);
    }
}

解决不能混淆类的名称，因为是通过拼接的方式得到具体的类名，所有混淆之后，就不能通过这种方式来找到具体的类。那么怎么解决这个问题呢？

private static String getParserClassName(Class<?> beanClass) {
    String name = beanClass.getCanonicalName();
    return name + "_JsonLubeParser";
}

现在我还没有想到具体的解决方案，如果你有好的解决方案，可以留言告诉我~

如果你喜欢我的文章，可以关注我的掘金、公众号、博客、简书或者Github！

简书: https://www.jianshu.com/u/a2591ab8eed2

GitHub: https://github.com/bugyun

Blog: https://ruoyun.vip

掘金: https://juejin.im/user/56cbef3b816dfa0059e330a8/posts

CSDN: https://blog.csdn.net/zxloveooo

欢迎关注微信公众号

image

若云_bai
关注
专栏目录
Android 之 json数据的解析（jsonReader）
baidu_28924013的博客
11-27 702
json数据的解析相对而言，还是比较容易的，实现的代码也十分简单。这里用的是jsonReade方法来进行json数据解析。   1.在解析之前，大家需要知道什么是json数据。   json数据存储的对象是无序的“名称/值”对的集合。和其他的数据存储方式相比，json数据的可读性，可扩展性，编码难度，解码难度都有一定的优势。在json数据中，   对于一个对象： （1）一个对象以“{
Android Json解析
Ke1vin的博客
02-16 512
package com.example.json; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import org.json
android中JSON数据的读写方法
03-27
NULL 博文链接：https://wiseideal.iteye.com/blog/1173616
android jsonreader
vincent_hika的专栏
04-23 674
在Android 3.0 honeycomb开始提供了新的JSON解析类 - android.util.JsonReader，下面Android123以下面的JSON为例子 [    {      "id": 912345678901,      "text": "How do I read JSON on Android?",      "geo": null,
Android读写JSON格式的数据之JsonWriter和JsonReader
weixin_33991418的博客
02-21 139
近期的好几个月都没有搞Android编程了，逐渐的都忘却了一些东西。近期打算找一份Android的工作，要继续拾起曾经的东西。公司月初搬家之后就一直没有网络，直到今日公司才有网络接入，各部门才開始办公。不说这些了，以下開始今天的正文。 JSON格式的数据通经常使用于网络传输。尤其是在移动设备上与服务端进行数据交互。JSON与XML比較有明显的优势。XML格式的数据非常臃肿，传递少量的数据...
Android开发--Json数据的解析
移动开发记录
01-31 138
在执行解析数据之前，需要将一个类库应用到你的程序中，下载的地址是： http://code.google.com/p/google-gson/ 下载解压之后你需要将蓝色标记的文件放入到你的程序之中应用 首先，我们需要知道什么是Json数据: JSON的定义： 一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式 ，...
android 解析json
米歌留白
01-05 572
在上一篇文章中介绍了如何从服务器端获取数据，对于服务器来说，返回的数据一般包括html、json和xml，在本篇中我们将介绍怎么处理服务器返回的json格式的数据。
android JSON解析数据 android解析天气预报
08-30
Log.e("Error", "JSON解析错误: " + e.getMessage()); } } ``` 为了实际操作，你需要在`MainActivity`中设置网络请求并处理响应。Volley库提供了`JsonObjectRequest`类来发送JSON对象请求。在`onCreate`方法中，...
android 动态解析获取json数据的键值对
04-13
这个"android 动态解析获取json数据的键值对"的项目就是针对这种情况的一个实例，主要展示了如何在Eclipse环境下，不预先创建JSON键值对应的实体类，而是动态地解析JSON并将其内容显示在列表上。 首先，我们要理解...
android原生JSON解析实例
08-28
Android 原生 JSON 解析实例 Android 原生 JSON 解析实例是一种常用的数据解析方法，在 Android 开发中经常会遇到需要解析 JSON 数据的情况。下面通过实例来详细分析 Android 原生 JSON 解析的过程。 JSONObject ...
深入浅析Android JSON解析
01-04
首先看JSON的语法和结构，这样我们才知道怎么去解析它。JSON语法时JavaScript对象表示语法的子集。 JSON的值可以是： 数字（整数或者浮点数） 字符串（在双引号内） 逻辑值(true 或 false) 数组(使用方括号[]包围) ...
android解析json简书,Android 之 json数据的解析（jsonReader）
weixin_42201721的博客
05-27 668
json数据的解析相对而言，还是比较容易的，实现的代码也十分简单。这里用的是jsonReade方法来进行json数据解析。1.在解析之前，大家需要知道什么是json数据。json数据存储的对象是无序的“名称/值”对的集合。和其他的数据存储方式相比，json数据的可读性，可扩展性，编码难度，解码难度都有一定的优势。在json数据中，对于一个对象：(1)一个对象以“{”(左括号)开始，“}”(右括号)...
json 的解析-使用Android中的JSONObject和JSONArray解析json数据,gson中的JsonReader解析json数据...
weixin_34309435的博客
06-10 118
关于Json：http://www.json.org/ Json解析库gson: http://code.google.com/p/google-gson/ 1.使用Android中的JSONObject和JSONArray解析json数据   String strJson = "{\"students\":[{\"name\":\"Jack\",\"age\":12}...
Android JSON 解析(二) JSONReader 和 JSONWriter
kassadin 的专栏
11-30 2935
在 Android 3.0 API 11 的更新中，android.util 包下增加了 JSONReader 和 JSONWriter 等新的 json 解析类库，官方文档上已经将用法讲的差不多了，本文算是对官方文档的一个精简整理。 JSONReader JSONReader 从名字就可以知道是来读取 json 字符串的，下面来看看具体怎么解析 JSON 解析 JSON 处理
android用jsonReader来解析json
baidu_nod的专栏
08-04 3154
对于这个json: { "id" : "3232", "data" : [{ "data1" : "555", "data2" : "3243" }, { "data1" : "888", "data2" : "777" }] } 我们可以这样来解析: import java.io.IOException; impor
android json 教程 pdf,android用jsonReader来解析json，jsonreaderjson
weixin_36142226的博客
05-27 207
android用jsonReader来解析json，jsonreaderjson对于这个json:{"id" : "3232","data" : [{"data1" : "555","data2" : "3243"},{"data1" : "888","data2" : "777"}]}我们可以这样来解析:import java.io.IOException;import java.io.Inpu...
[转]Java Code Examples for android.util.JsonReader
weixin_30235225的博客
03-17 73
【转】Java Code Examples for android.util.JsonReader The following are top voted examples for showing how to useandroid.util.JsonReader. These examples are extracted from open source projects. You can ...
Android的JSON解析（上）
qq_46906413的博客
09-02 8268
Android里面一个很重要的方面就是接受后端接口数据，解析JSON字符串。已经解析数据了，那么依赖和网络权限应该都已经开了，我们直入主题。没有去单独写接口，下面我们以okhttp的同步请求进行讲解。写完了想了想还是把依赖和权限操作加在后面 🥭🥭网络权限 觉得有用的可以给个三连，关注一波！！！带你了解更多的Android小知识.........
Android JSON解析实战： JSONObject与JSONStringer解析
Android SDK从2.3版本开始内置了JSON解析库，位于`org.json`包下，提供了几个核心类来处理JSON数据： 1. JSONObject: 这是JSON解析的核心类，它代表一个JSON对象。一个JSONObject由一对大括号包围，里面包含键值对...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值