前言

了解一下日常開發(fā)中關(guān)于 Json 解析的一些非常規(guī)用法，以及使用 fastjson 的一些總結(jié)。

Json 解析

常規(guī)使用

一般情況 Json 的使用都是非常簡單的。 我們會根據(jù)上游定義的 Json 數(shù)據(jù)格式，由下游定義相應(yīng)的解析模型。比如像下面這個簡單的 Json 字符串。

{
    "name":"mike",
    "address":"beijing"
}

一般會定義如下的數(shù)據(jù)類（以 Kotlin 為例）

data class KotlinPeople(val name: String? = "", val address: String? = "")

具體使用也是非常簡單了，無論是借助 fastjson 、gson 或者是原生的 JsonObject 都可以非常方便的完成數(shù)據(jù)的序列化和反序列操作，比如以 fastjson 為例。

• Json 字符串轉(zhuǎn) 對象

val people = JSONObject.parseObject(json, KotlinPeople::class.java)

• 對象轉(zhuǎn) Json 字符串

val jsonStr = JSONObject.toJSONString(people)

無論原始的 Json 數(shù)據(jù)格式多么的復(fù)雜，包含原始數(shù)據(jù)類型、List、數(shù)組還是他類型，只要需要解析的屬性的 key 是確定的，那么就可以定義出相應(yīng)的數(shù)據(jù)模型來解析。 因為在定義任何一個數(shù)據(jù)模型是時，對于其中的每一個字段（或者叫做屬性、類成員），唯一需要確定的就是變量的類型和變量名的名稱，比如面對下面這個略顯復(fù)雜的 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"
    }
  ]
}

我們依舊可以定義出如下的數(shù)據(jù)模型

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 數(shù)據(jù)中，key 值無法確定的情況。也就是說，我們需要解析的字段名是不確定的?；蛘哒f，Json 數(shù)據(jù)中字段名和字段值重合的情況。

當 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 里具體是什么，我們也無需關(guān)心）或者是其他任何數(shù)據(jù)，這里就比較有意思了。

• 首先，這是一個標準的 Json；
• 其次，這個場景并不是胡編亂造，實際業(yè)務(wù)開發(fā)中真的會遇到；這個 Json 這么定義也沒有問題，字段本身就代表了他的值，同時這個值和后面的列表有映射關(guān)系。單獨拆開定義字段會打破這種映射關(guān)系。
• 最后，這個 Json 中 key 的值是不確定的。

既然返回的屬性名是無法確定的，那么怎么定義 Json 對應(yīng)的數(shù)據(jù)類型中的變量名呢 ？

public class Foo {
   public List<Item> ??? 

   public class Item {
       public String name;
       public String address;
   }
}

上面 ??? 這里應(yīng)該怎么定義呢？ 畢竟總不能窮舉所有日期吧？ 再說也窮舉不過來呀，時間是無限的呀。

這里就需要轉(zhuǎn)換一下思路了，我們從本質(zhì)出發(fā)，這里整個 Json 其實是一個 Map 。既然是一個 Map ，那我們就把他當做一個 Map 去解析好了。

        val map = JSONObject.parseObject(specialJson, Map::class.java)
        // 看看返回的類型
        Log.e(TAG, map.javaClass.name)

E/JsonUtil: java.util.HashMap

• 從日志可以看到，fastjson 返回的結(jié)果就是一個 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) {
            // 這里的強轉(zhuǎn)，就是人類意志的勝利
            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 字符串中的數(shù)據(jù)了?？梢钥吹剑瑢τ谏嫌畏祷氐?Map 這種類型的數(shù)據(jù)，由于其本身靈活的特性，我們需要按具體的類型做具體拆解，沒有通用的方法。

fastjson 你真的學(xué)會了嗎？

作為常用的 Json 序列化框架 ，這里總結(jié)一下使用 fastjson 遇到一些坑和收獲。

Json 數(shù)據(jù)格式化成便于閱讀的格式

日常開發(fā)中上游給我們的 Json 數(shù)據(jù)往往是很豐富的，并且由于 json 的特性，在一大段字符串中要找到我們關(guān)系的字段是有點困難的，因此我們往往把 Json 字符串貼到各類 Json解析助手之類的網(wǎng)站或工具里，進行格式化。其實，不用那么麻煩，fastjson 自身提供了可以格式化打印 Json 的方法。

    /**
     * 這里的參數(shù)是 Any ,因此只要是一個合法的 Json, 無論是字符串還是數(shù)據(jù)模型都可以打印
     */
    fun printBeautyJson(json: Any): String {
        return JSON.toJSONString(
            json,
            SerializerFeature.PrettyFormat,
            SerializerFeature.SortField,
            SerializerFeature.WriteDateUseDateFormat,
            SerializerFeature.WriteMapNullValue,
        )
    }

這里格式化打印一下剛才的 map printBeautyJson(map)

format_json.png

從截圖可以看到，已經(jīng)實現(xiàn)了 Json 的格式化輸出。SerializerFeature 還有很多其他很多實用的功能，可以按需要進行配置。

實用 JSONField 注意事項。

JSONField 是一個定義在 fastjson 內(nèi)的注解，其中最常用的兩個值是 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 操作，在優(yōu)化性能的場景，我們就可以基于實際業(yè)務(wù)場景和需求出發(fā)，減少非必要的序列和反序列操作，尤其是對一些比較打的對象。需要注意的是，deserialize 這個值只有把注解打在方法上時才是有效的（這點可以從其源碼看到）。

默認構(gòu)造函數(shù)不可缺

最后再說一個使用 fastjson 最最常見的問題，關(guān)于默認構(gòu)造函數(shù)的問題。

我們知道一個普通的 Java 類，如果沒有定義構(gòu)造函數(shù)的話，編譯器會幫我們自定生成一個構(gòu)造函數(shù)。但是如果我們自己定義了構(gòu)造函數(shù)，那么默認的構(gòu)造函數(shù)就沒了。

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
至于具體原因，看一下源碼也很容易理解了。這個時候，就只能把默認的構(gòu)造加上了。

而在使用 Kotlin 的場景，也是存在同樣的問題。

data class KotlinPeople(val name: String? = "", val address: String? = "")

現(xiàn)在大家都習(xí)慣使用 data class 定義數(shù)據(jù)類。雖然這樣定義的類型，從反編譯的結(jié)果看似乎是存在默認構(gòu)造函數(shù)的，但依舊會報錯。

decode.png

可以看到是有存在構(gòu)造函數(shù)的，但是依舊會產(chǎn)生問題。對于 Kotlin 的場景，我們用兩種解決辦法。

• 不使用 data class ,而是用普通的類型定義。這里需要注意的是，使用 data class 即便是手動添加默認構(gòu)造函數(shù)也是無用的。

data class KotlinPeople(val name: String? = "", val address: String? = "")  {
    constructor() : this("","")
}

這樣依舊不解決問題。

• 添加 kotlin-reflect 依賴

api "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"

to be continued ...

總結(jié)

本文從 Json 解析常規(guī)用法出發(fā)，解讀了對 Map 這種 Json 數(shù)據(jù)類型的解析。從中可以學(xué)習(xí)到，有時候我們在面臨一些問題是會一籌莫展，會出現(xiàn)非常規(guī)的場景。這個時候，就需要我們從問題的本質(zhì)出發(fā)，看透問題的根源，一層層抽絲剝縷的去解決。

問題總是會不斷出現(xiàn)的，重要的是在我們解決完問題之后不僅要學(xué)會解決方法，更要學(xué)會解決問題的思路。