当 JSON 遇到 Map

“我报名参加金石计划1期挑战——瓜分10万奖池，这是我的第5篇文章，点击查看活动详情”

前言

了解一下日常开发中关于 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 数据类型的解析。从中可以学习到，有时候我们在面临一些问题是会一筹莫展，会出现非常规的场景。这个时候，就需要我们从问题的本质出发，看透问题的根源，一层层抽丝剥缕的去解决。

问题总是会不断出现的，重要的是在我们解决完问题之后不仅要学会解决方法，更要学会解决问题的思路。