前言
了解一下日常开发中关于 Json 解析的一些非常规用法，以及使用 fastjson 的一些总结。
Json 解析
常规使用
一般情况 Json 的使用都是非常简单的。 我们会根据上游定义的 Json 数据格式，由下游定义相应的解析模型。比如像下面这个简单的 Json 字符串。
{
"name":"mike",
"address":"beijing"
}
一般会定义如下的数据类（以 Kotlin 为例）
data class KotlinPeople(val name: String? = "", val address: String? = "")
具体使用也是非常简单了，无论是借助 fastjson 、gson 或者是原生的 JsonObject 都可以非常方便的完成数据的序列化和反序列操作，比如以 fastjson 为例。
- Json 字符串转 对象
val people = JSONObject.parseObject(json, KotlinPeople::class.java)
- 对象转 Json 字符串
val jsonStr = JSONObject.toJSONString(people)
无论原始的 Json 数据格式多么的复杂，包含原始数据类型、List、数组还是他类型，只要需要解析的属性的 key 是确定的，那么就可以定义出相应的数据模型来解析。 因为在定义任何一个数据模型是时，对于其中的每一个字段（或者叫做属性、类成员），唯一需要确定的就是变量的类型和变量名的名称，比如面对下面这个略显复杂的 Json :
{
"token": "1234",
"key": "mute",
"simple": {
"age": 11
},
"sites": [
{
"id": "1",
"name": "菜鸟教程",
"url": "www.runoob.com"
},
{
"id": "2",
"name": "菜鸟工具",
"url": "c.runoob.com"
},
{
"id": "3",
"name": "Google",
"url": "www.google.com"
}
]
}
我们依旧可以定义出如下的数据模型
public class SiteWrapper {
public String token;
public String key;
public Simple simple;
public List<Site> sites;
public class Simeple {
public String age;
}
public static class Site {
public String id;
public String name;
public String url;
public Site() {
}
public Site(String id, String name, String url) {
this.id = id;
this.name = name;
this.url = url;
}
}
}
但有时候我们会遇到 Json 数据中，key 值无法确定的情况。也就是说，我们需要解析的字段名是不确定的。或者说，Json 数据中字段名和字段值重合的情况。
当 Json 遇到 Map
{
"2022-02-01": [
{
"name": "mike",
"address": "北京"
},
{
"name": "mike1",
"address": "北京1"
},
{
"name": "mike2",
"address": "北京2"
}
],
"2022-02-02": [
{
"name": "lucy",
"address": "南京"
},
{
"name": "lucy1",
"address": "南京1"
}
],
"2022-02-03": [
{
"name": "lily",
"address": "西安"
},
{
"name": "lily1",
"address": "西安1"
},
{
"name": "lily2",
"address": "西安2"
}
],
"2022-02-04": [
{
"name": "tom",
"address": "tokyo"
},
{
"name": "tom1",
"address": "tokyo1"
},
{
"name": "tom2",
"address": "tokyo2"
}
]
}
比如上面这个 Json ,按照日期返回一个 List（至于 List 里具体是什么，我们也无需关心）或者是其他任何数据，这里就比较有意思了。
- 首先，这是一个标准的 Json；
- 其次，这个场景并不是胡编乱造，实际业务开发中真的会遇到；这个 Json 这么定义也没有问题，字段本身就代表了他的值，同时这个值和后面的列表有映射关系。单独拆开定义字段会打破这种映射关系。
- 最后，这个 Json 中 key 的值是不确定的。
既然返回的属性名是无法确定的，那么怎么定义 Json 对应的数据类型中的变量名呢 ？
public class Foo {
public List<Item> ???
public class Item {
public String name;
public String address;
}
}
上面 ??? 这里应该怎么定义呢？ 毕竟总不能穷举所有日期吧？ 再说也穷举不过来呀，时间是无限的呀。
这里就需要转换一下思路了，我们从本质出发，这里整个 Json 其实是一个 Map 。既然是一个 Map ，那我们就把他当做一个 Map 去解析好了。
val map = JSONObject.parseObject(specialJson, Map::class.java)
// 看看返回的类型
Log.e(TAG, map.javaClass.name)
E/JsonUtil: java.util.HashMap
- 从日志可以看到，fastjson 返回的结果就是一个 HashMap
- 我们在解析阶段无法提供更多的信息，比如不能这样
JSONObject.parseObject(specialJson, Map<String,Any>::class.java)试图提供 Map 的 key 及 value 的类型，这种写法会报错的。
因此，fastjson 在解析的时候不知道具体该怎么办了，只知道这是个把原始 Json 字符串解析为一个 Map 。剩下的就该靠我们自己了. fastjson 不知道具体类型，我们自己是知道的呀。因此，就需要遍历 map 自己去处理了。
fun parseSpecialJson(context: Context) {
val specialJson = getJsonString()
val map = JSONObject.parseObject(specialJson, Map::class.java)
for (key in map.keys) {
// 这里的强转，就是人类意志的胜利
val item = map[key] as JSONArray
val list = convertJSONArrayToTypeList(item, Item::class.java)
Log.d(TAG, "parseSpecialJson() called key = $key, list = $list")
}
}
private fun <T> convertJSONArrayToTypeList(jsonArray: JSONArray, clazz: Class<T>): List<T> {
if (jsonArray.isEmpty()) return emptyList()
val result = ArrayList<T>(jsonArray.size)
jsonArray.forEach {
if (it is String || it is Boolean || it is Number) {
val element = it as T
result.add(element)
} else {
val t = JSONObject.toJavaObject(it as JSONObject, clazz)
result.add(t)
}
}
return result
}
D/JsonUtil: parseSpecialJson() called key = 2022-02-04, list = [Item{name='tom', address='tokyo'}, Item{name='tom1', address='tokyo1'}, Item{name='tom2', address='tokyo2'}]
D/JsonUtil: parseSpecialJson() called key = 2022-02-01, list = [Item{name='mike', address='北京'}, Item{name='mike1', address='北京1'}, Item{name='mike2', address='北京2'}]
D/JsonUtil: parseSpecialJson() called key = 2022-02-03, list = [Item{name='lily', address='西安'}, Item{name='lily1', address='西安1'}, Item{name='lily2', address='西安2'}]
D/JsonUtil: parseSpecialJson() called key = 2022-02-02, list = [Item{name='lucy', address='南京'}, Item{name='lucy1', address='南京1'}]
到这里，我们就可以获取到原始 Json 字符串中的数据了。可以看到，对于上游返回的 Map 这种类型的数据，由于其本身灵活的特性，我们需要按具体的类型做具体拆解，没有通用的方法。
fastjson 你真的学会了吗？
作为常用的 Json 序列化框架 ，这里总结一下使用 fastjson 遇到一些坑和收获。
Json 数据格式化成便于阅读的格式
日常开发中上游给我们的 Json 数据往往是很丰富的，并且由于 json 的特性，在一大段字符串中要找到我们关系的字段是有点困难的，因此我们往往把 Json 字符串贴到各类 Json解析助手之类的网站或工具里，进行格式化。其实，不用那么麻烦，fastjson 自身提供了可以格式化打印 Json 的方法。
/**
* 这里的参数是 Any ,因此只要是一个合法的 Json, 无论是字符串还是数据模型都可以打印
*/
fun printBeautyJson(json: Any): String {
return JSON.toJSONString(
json,
SerializerFeature.PrettyFormat,
SerializerFeature.SortField,
SerializerFeature.WriteDateUseDateFormat,
SerializerFeature.WriteMapNullValue,
)
}
这里格式化打印一下刚才的 map printBeautyJson(map)
从截图可以看到，已经实现了 Json 的格式化输出。SerializerFeature 还有很多其他很多实用的功能，可以按需要进行配置。
实用 JSONField 注意事项。
JSONField 是一个定义在 fastjson 内的注解，其中最常用的两个值是 serialize 和 deserialize ，都是 boolean 类型，用户决定对特定字段进行序列化和反序列化。
public class SiteWrapper {
private List<Site> sites;
@JSONField(serialize = false)
private String token;
public List<Site> getSites() {
return sites;
}
@JSONField(deserialize = false)
public void setSites(List<Site> sites) {
this.sites = sites;
}
public String getToken() {
return token;
}
// @JSONField(deserialize = true)
public void setToken(String token) {
this.token = token;
}
}
序列化毕竟是一个 IO 操作，在优化性能的场景，我们就可以基于实际业务场景和需求出发，减少非必要的序列和反序列操作，尤其是对一些比较打的对象。需要注意的是，deserialize 这个值只有把注解打在方法上时才是有效的（这点可以从其源码看到）。
默认构造函数不可缺
最后再说一个使用 fastjson 最最常见的问题，关于默认构造函数的问题。
我们知道一个普通的 Java 类，如果没有定义构造函数的话，编译器会帮我们自定生成一个构造函数。但是如果我们自己定义了构造函数，那么默认的构造函数就没了。
public class JavaPeople {
public String name;
public String address;
public JavaPeople(String name, String address) {
this.name = name;
this.address = address;
}
}
这个时候如果我们直接解析 Json 解析，会抛出异常。com.alibaba.fastjson.JSONException: default constructor not found
至于具体原因，看一下源码也很容易理解了。这个时候，就只能把默认的构造加上了。
而在使用 Kotlin 的场景，也是存在同样的问题。
data class KotlinPeople(val name: String? = "", val address: String? = "")
现在大家都习惯使用 data class 定义数据类。虽然这样定义的类型，从反编译的结果看似乎是存在默认构造函数的，但依旧会报错。
可以看到是有存在构造函数的，但是依旧会产生问题。对于 Kotlin 的场景，我们用两种解决办法。
- 不使用 data class ,而是用普通的类型定义。这里需要注意的是，使用 data class 即便是手动添加默认构造函数也是无用的。
data class KotlinPeople(val name: String? = "", val address: String? = "") {
constructor() : this("","")
}
这样依旧不解决问题。
- 添加 kotlin-reflect 依赖
api "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
to be continued ...
总结
本文从 Json 解析常规用法出发，解读了对 Map 这种 Json 数据类型的解析。从中可以学习到，有时候我们在面临一些问题是会一筹莫展，会出现非常规的场景。这个时候，就需要我们从问题的本质出发，看透问题的根源，一层层抽丝剥缕的去解决。
问题总是会不断出现的，重要的是在我们解决完问题之后不仅要学会解决方法，更要学会解决问题的思路。
