如何保持json序列化的順序性?


  說到json,相信沒有人會陌生,我們天天都在用。那么,我們來討論個問題,json有序嗎?是誰來決定的呢?如何保持?

  說到底,json是框架還是啥?實際上它只是一個數據格式,一個規范標准,它永遠不會限制實現方的任何操作,即不會自行去保證什么順序性之類的。json的格式僅由寫入數據的一方決定其長像如何。而數據讀取一方,則按照json的協議標准進行解析,即可理解原數據的含義。json擁有較為豐富的數據格式,所以對當前應用還是比較友好的。

  那么,我們如何處理json的順序性呢?

 

1. 保持json有序的思路

  首先,我們要澄清有序性的概念:從某種程度上,我們可以把json看作是一個個的kv組成的數據,從這個層面上來講,我們可以把有序性定義為json的key保持有序,先假設為字典序吧,那么就說這個json數據是有序的。

  其次,因為json的數據支持嵌套,所以,我們應該需要保持每一層的數據都有序,才是完整有序的。

  ok, 理解完有序的概念,下面我們來看看如何實現有序?

  json本身是不可能保持有序了,所以,當我們自行寫入json數據時,只需要按照 abcde... 這種key順序寫入數據,那么得到的最終json就是有序的。

  但我們一般都是使用對象進行程序變換的,所以,就應該要從對象中取出有序的key, 然后序列化為json.

  這里保持有序,至少有兩個層面的有序:1. kv形式的key的有序; 2. 列表形式的數據有序; 還有其他可能非常復雜的有序性需求,比如按照某字段有序,倒序。。。

  所以,想保持json有序很簡單,保證有序寫入就可以了。(貌似等於沒有說哦)

 

2. 保持json有序的應用場景舉例

  為什么要保持json有序呢?json相當於kv數據,一般情況下我們是不需要保證有序的,但有些特殊情況下也許有用。比如我有兩份json數據,我想比較它們是否是相等的時候!

  比如第一份數據是 {"a":1, "b":2}, 第二份數據是 {"b":2, "a":1}, 那么你說這兩份數據是否是相等的呢?相等或不相等依據是啥?

  如果對於固定數據結構的json, 那么也許我們可以直接取出每個key的值,然后進行比較,全部相等則相等成立,否則不相等。

  但對於json本身就是各種不確定的數據組成,如果我們限制死必須取某些key, 那么這個通用性就很差了。所以,我們要想比較兩個json是否相等,還應該要有另外的依據。

  另外,當我們將有序json寫入文件之后,當key的數據非常多時,有序實際上可以輔助我們快速找到對應的key所在的位置。這是有序性帶來的好處,快速查找!

  比如下面的例子,對比兩個結果集是否相等,你覺得結果當如何呢?

    @Test
    public void testJsonObjectOrder() {
        String res1, res2;
        List<Map<String, Object>> nList;
        Map<String, Object> data = new HashMap<>();
        data.put("d", "cd");
        data.put("a", 1);
        data.put("b", 0.45);
        data.put("total", 333);
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String, Object> item1 = new HashMap<>();
        item1.put("aa", 1);
        item1.put("ee", 5);
        item1.put("bb", 6);
        item1.put("nn", null);
        list.add(item1);
        Map<String, Object> item2 = new HashMap<>();
        item2.put("xxx", "000");
        item2.put("q", 2);
        item2.put("a", "aa");
        list.add(item2);
        data.put("sub", list);


        Map<String, Object> nData = new HashMap<>(data);
        nData.put("c", null);
        nData.put("abc", null);

        res1 = JSONObject.toJSONString(data);
        res2 = JSONObject.parseObject(JSONObject.toJSONString(nData)).toJSONString();
        Assert.assertEquals("序列化結果不相等default", res1, res2);

        res2 = JSONObject.toJSONString(JSONObject.parseObject(
                JSONObject.toJSONString(nData, SerializerFeature.SortField)),
                SerializerFeature.SortField);
        Assert.assertEquals("序列化結果不相等sort", res1, res2);

        nList = new ArrayList<>();
        nList.add(item2);
        nList.add(item1);
        nData.put("sub", nList);
        res2 = JSONObject.parseObject(JSONObject.toJSONString(nData)).toJSONString();
        Assert.assertEquals("序列化結果不相等array", res1, res2);

    }

  以上是fastjson庫進行json序列化的處理方式,json的數據結構大部分使用可以用map進行等價,除了純數組的結構以外。以上測試中,除了最后一個array的位置調換,導致的結果不一樣之外,總體還是相等的。糾其原因,是因為原始數據結構是一致的,而fastjson從一定程度上維持了這個有序性。

  

3. fastjson維護json的有序性的實現

  很顯然,讓我們自行寫json的工具類,還是有一定的難度的,至少要想高效完整地寫json是困難的。所以,一般我們都是借助一些現有的開源類庫。

  上一節中說到,fastjson維護了json一定的順序性,但是並非完整維護了順序性,它的順序性要體現在,相同的數據結構序列化的json,總能得到相同的反向的相同數據結構的數據。比如,ArrayList 的順序性被維護,map的順序性被維護。

  但是很明顯,這些順序性是根據數據結構的特性而定的,而非所謂的字典序,那么,如果我們想維護一個保持字典序的json如何處理呢?看看下面的實現:

public class JsonObjectTest {

    @Test
    public void testJsonObjectOrder() {
        String res1, res2;
        List<Map<String, Object>> nList;
        Map<String, Object> data = new HashMap<>();
        data.put("d", "cd");
        data.put("a", 1);
        data.put("b", 0.45);
        data.put("total", 333);
        List<Map<String, Object>> list = new ArrayList<>();
        Map<String, Object> item1 = new HashMap<>();
        item1.put("aa", 1);
        item1.put("ee", 5);
        item1.put("bb", 6);
        item1.put("nn", null);
        list.add(item1);
        Map<String, Object> item2 = new HashMap<>();
        item2.put("xxx", "000");
        item2.put("q", 2);
        item2.put("a", "aa");
        list.add(item2);
        data.put("sub", list);


        Map<String, Object> nData = new HashMap<>(data);
        nData.put("c", null);
        nData.put("abc", null);

        res1 = JSONObject.toJSONString(data);
        res2 = JSONObject.parseObject(JSONObject.toJSONString(nData)).toJSONString();
        Assert.assertEquals("序列化結果不相等default", res1, res2);

        res2 = JSONObject.toJSONString(JSONObject.parseObject(
                JSONObject.toJSONString(nData, SerializerFeature.SortField)),
                SerializerFeature.SortField);
        Assert.assertEquals("序列化結果不相等sort", res1, res2);

        res2 = JSONObject.toJSONString(JSONObject.parseObject(
                JSONObject.toJSONString(nData, SerializerFeature.WriteMapNullValue)),
                SerializerFeature.WriteMapNullValue);
        Assert.assertEquals("序列化結果不相等null", res1, res2);

        nList = new ArrayList<>();
        nList.add(item2);
        nList.add(item1);
        nData.put("sub", nList);
        res2 = JSONObject.parseObject(JSONObject.toJSONString(nData)).toJSONString();
        Assert.assertEquals("序列化結果不相等array", res1, res2);

        nList = new ArrayList<>();
        nList.add(item2);
        nList.add(item1);
        nData.put("sub", nList);
        res1 = transformDataToJSONAsOrderWay(data);
        res2 = transformDataToJSONAsOrderWay(nData);
        Assert.assertEquals("序列化結果不相等array-s", res1, res2);



    }

    /**
     * 將原始數據轉換為有序的集合
     */
    private String transformDataToJSONAsOrderWay(Map<String, Object> data) {
        TreeMap<String, Object> transformedData = new TreeMap<>();
        for (Map.Entry<String, Object> entry : data.entrySet()) {
            if(entry.getValue() == null) {
                continue;
            }
            if(entry.getValue() instanceof List) {
                TreeMap<String, Integer> tmpMap = new TreeMap<>();
                List value = (List) entry.getValue();
                for (int i = 0; i < (value).size(); i++) {
                    Object it1 = value.get(i);
                    // 假設只支持二維數組嵌套
                    tmpMap.put(transformDataToJSONAsOrderWay((Map<String, Object>) it1), i);
                }
                List<Object> orderedList = new ArrayList<>(tmpMap.size());
                for (Integer listNo : tmpMap.values()) {
                    orderedList.add(value.get(listNo));
                }
                transformedData.put(entry.getKey(), orderedList);
                continue;
            }
            transformedData.put(entry.getKey(), entry.getValue());
        }
        return JSONObject.toJSONString(transformedData);
    }
}

  以上就是完整的基於fastjson實現的json字典序維持的實現了,其實就是 transformDataToJSONAsOrderWay() 方法,其原理也簡單,因fastjson的有序性,依賴於輸入的數據結構,那么只要維護好輸入結構的字典序就好了。TreeMap 是以字典序排序key的一種數據結構,符合這需求,另外,將list這種數據結構,轉化為kv這種數據結構,將整個item作為key排序后,再將其放入對應位置,從而保證了整體的順序性。但這種list的順序性,不一定是大家所理解的字典序,但一定可以保證得到相同的順序。

  另外,fastjson中還考慮了對於null值的處理,比如json中有null值的數據與沒有null值的數據,你說是相等呢還是不相等呢?

 

4. hashmap數據結構的順序迭代原理

  map是一種kv型的數據結構存儲,一般可以認為其是無序的。但我們可以額外的維護一些屬性,以保證它能夠以某種順序輸出數據,順序性主要體現在進行迭代時,如使用 keyset(), values(), entrySet() 等方法。針對額外維護順序性的數據結構而言,其迭代自然是基於其額外字段。但針對無序的hashmap這種數據結構而言,我們知道其底層數據是根據hash值亂序存儲的。簡單來說就是根據一個hash值,然后求余定位到一個數組下標中。即對hashmap所分配的數組對象的下標,有可能有值,有可能沒有值,那么在做迭代的時候如何做呢?多次做迭代的順序一致嗎?一個最簡單的思路自然是依次遍歷數據的每個元素,直到數據的最大值。這樣,肯定是可以保證多次遍歷的順序性的。那么,hashmap是否是這樣實現的呢?

    // java.util.HashMap#forEach
    @Override
    public void forEach(BiConsumer<? super K, ? super V> action) {
        Node<K,V>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            // 1. 迭代所有數組元素
            // 2. 迭代hash沖突時的鏈表
            for (int i = 0; i < tab.length; ++i) {
                for (Node<K,V> e = tab[i]; e != null; e = e.next)
                    action.accept(e.key, e.value);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }
        // java.util.HashMap.EntrySet#forEach
        public final void forEach(Consumer<? super Map.Entry<K,V>> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next)
                        action.accept(e);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
        // keySet(), 換成了取key的處理
        // java.util.HashMap.KeySet#forEach
        public final void forEach(Consumer<? super K> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next)
                        action.accept(e.key);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }
        // values() 換成了取value的處理
        // java.util.HashMap.Values#forEach
        public final void forEach(Consumer<? super V> action) {
            Node<K,V>[] tab;
            if (action == null)
                throw new NullPointerException();
            if (size > 0 && (tab = table) != null) {
                int mc = modCount;
                for (int i = 0; i < tab.length; ++i) {
                    for (Node<K,V> e = tab[i]; e != null; e = e.next)
                        action.accept(e.value);
                }
                if (modCount != mc)
                    throw new ConcurrentModificationException();
            }
        }

  TreeMap基於key做排序處理,最符合有序性要求,其迭代實現如下:

    // java.util.TreeMap#forEach
    @Override
    public void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        int expectedModCount = modCount;
        // 從最小的key開始取,進行二叉樹的中序遍歷
        // 因該二叉樹在插入時維護了有序性,進行遍歷時也就有了順序了
        for (Entry<K, V> e = getFirstEntry(); e != null; e = successor(e)) {
            action.accept(e.key, e.value);

            if (expectedModCount != modCount) {
                throw new ConcurrentModificationException();
            }
        }
    }
    
    /**
     * Returns the successor of the specified Entry, or null if no such.
     */
    static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
        if (t == null)
            return null;
        else if (t.right != null) {
            Entry<K,V> p = t.right;
            while (p.left != null)
                p = p.left;
            return p;
        } else {
            Entry<K,V> p = t.parent;
            Entry<K,V> ch = t;
            while (p != null && ch == p.right) {
                ch = p;
                p = p.parent;
            }
            return p;
        }
    }

  LinkedHashMap是按照插入的順序排列的一種map, 它與ArrayList這種有序性有相似性,但相對難以理解一些。因為list這種數據結構,你說先插入哪個元素,后插入哪個元素,是顯而易見的。然而像map這種數據結構,你很想像它是先插入某元素,再插入另一個元素的,這是一種先入為主的概念導致的。但它並不影響我們理解map有序性的實現,LinkedHashMap的迭代實現如下:

    // java.util.LinkedHashMap#forEach
    public void forEach(BiConsumer<? super K, ? super V> action) {
        if (action == null)
            throw new NullPointerException();
        int mc = modCount;
        // 僅通過維護插入時的鏈表,即可實現有序迭代
        for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after)
            action.accept(e.key, e.value);
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }

  ok, 到此我們分析了多個類型的map的有序性的實現。從內部解釋了為什么我們使用TreeMap數據結構時,就可以使json保持字典序了。因為fastjson在寫json數據時,針對map的寫入,就是通過entrySet()迭代元素進行寫入的了。

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM