文章目錄

• • 誕生于JavaScript,json的前世今生
  • • json含義
    • json誕生
  • 搞清json兄弟姐妹，看清區別
  • • json VS xml
  • 小小翻譯官，json的應用
  • • 前端ajax+json異步傳輸：
    • 跨平臺webservice:
    • 非關系數據庫存儲(Nosql)
  • 拒絕四不像，json語法有要求
  • • json語法規則
    • json名稱/值
    • json對象
    • json數組
    • JavaScript對象 VS json對象 VS json字符串
    • 小結
  • 谷歌Gson，精簡而強大
  • • 序列化/反序列化介紹
    • Gson介紹
    • Gson實戰
  • 飛人fastjson，阿里的"黑科技"
  • • fastjson介紹
    • fastjson實戰
  • 備受開源認可，Jackson亦是真王者
  • • Jackson介紹
    • jackson實戰
    • Gson VS fastjson VS jackson
  • 小試牛刀
  • 本文總結

聲明

本文原創作者bigsai(同公眾號),本文以淺顯易懂的方式給大家講解自己所認知的json，如果有錯誤或者不準確地方還請大家給出指正，另外本文以關卡課程的方式在博學谷也是免費開放的，大家也可通過關卡方式學習。鏈接地址。

誕生于JavaScript,json的前世今生

json含義

在開始之前，問個問題，什么是json？

• a：我猜它應該是某一門高深的技術(語重心長)
• b：json這個詞為啥谷歌翻譯?是啥新詞語嘛？是不是搞錯了喲？(底氣十足)
  
• c：json這個我聽過，我只知道他是一種很輕量存儲結構，但具體真的不太懂(輕聲)

json它不是一個原有單詞，其實是4個單詞JavaScript Object Notation（JavaScript對象表示）的簡寫，是一種輕量級的文本數據交換格式，并且json獨立于語言(使用JavaScript語法描述對象)，很多編程語言都支持json。 json 已成為當前服務器與 web 應用之間數據傳輸的公認標準。

json誕生

問個問題，json是如何誕生的呢？

這個問題首先由于互聯網應用之間需要傳輸數據，且很多跨平臺的程序需要交互，只能采取純文本方式的交互，而xml當初就是一個選擇，但是xml規范越來越多也越來越復雜，解析效率也比較低，很多攻城獅看到xml頭都大了，可能搞了很久也搞不明白。

然后獨鐘于JavaScript的JavaScript大宗師(JavaScript之父評價)Douglas Crockford根據JavaScript的規范發明推廣了json，json格式簡單易用，且同樣可跨平臺傳出，得到廣泛的認可和傳播。就這樣，json就越來越流行了，現在已經成為主流技術之一。

(選擇題)章節練習：json是一種什么東西呢(B)？

• A.JavaScript對象
• B.輕量級文本數據交換格式
• C.一種語言
• D.一種框架

搞清json兄弟姐妹，看清區別

json VS xml

談起json，那xml肯定是少不了對比的東西啊，沒有對比就是沒有傷害，在和json履行相同職責的文本傳輸交換格式還有json的老大哥xml(可擴展標記語言)，在json橫空出世以前，咱們用的可都是xml進行文件數據傳輸。

首先咱們要從定義上來看看json和xml的區別：

JSON（JavaScript Object Notation）
一種輕量級的數據交換格式，具有良好的可讀和便于快速編寫的特性。可在不同平臺之間進行數據交換。其語言習慣具備類c的習慣體系(c,c++,java等)。
XML（Extensiable Markup Language，可擴展標記語言）
用于標記電子文件使其具有結構性的標記語言，可以用來標記數據、定義數據類型，是一種允許用戶對自己的標記語言進行定義的源語言。

json的橫空出世，是充分吸取借鑒了xml的優點，故json和xml有著一些相同的優點：

• 可讀性好，結構清晰
• 分層存儲(層次嵌套)
• 都可作為Ajax傳輸數據
• 都跨平臺，可作為數據傳輸格式

但json畢竟青出于藍而青于藍，肯定有著xml一些沒有的特點和優勢，例如：

• 數據格式簡單，易讀易寫，且數據都是壓縮的，文件較小，便于傳輸。
• json解析難度較低，而xml需要循環遍歷DOM進行解析，效率較低。
• 服務端和客戶端可以直接使用json，便于維護。而不同客戶端解析xml可能使用不同方法。
• json 已成為當前服務器與 web 應用之間數據傳輸的公認標準。

盡管如此，xml仍有它獨有應用領域：

• xml格式較為嚴謹，可讀性更強，更易于拓展，可以良好的做配置文件。
• 出現較早，在各個領域有廣泛的應用,具有普遍的流行性。

當然，不是所有的json都是"特侖蘇"，適合場景需要的才是最好的。但在web領域的數據傳輸，它就是王者！

(選擇題)小練習：下列哪一項是錯誤選項？(B)

• A.相同內容文件json通常要比xml更簡潔更小。
• B.json解析起來比xml復雜很多。
• C.json和xml都是一種跨平臺文本傳輸格式。
• D.json是JavaScript Object Notation單詞的簡寫。

小小翻譯官，json的應用

json之所以很流行，是因為json有著廣泛的應用領域。主要包括與ajax結合使用的統一平臺的前端傳輸；跨平臺的數據傳輸；非關系型數據庫的文檔存儲等。這些領域通過使用json使得應用效率大大提高。

前端ajax+json異步傳輸：

json本身就起源于JavaScript，JavaScript解析處理json有天然的優勢，而在Ajax異步加載的數據中，整體頁面已經加載過了，我們只需要在對應位置渲染真實的數據就行了，。而這部分的真實數據我們用json文本來存儲，使用JavaScript異步向服務端請求，請求成功之后JavaScript對其渲染填充就可以了。下圖就是對前后端交互傳統方式和ajax異步交互的簡要描述：

如果對AJAX也不熟悉？流程也看不懂，也不能明白異步傳輸的真諦在哪里，那好咱們以下圖這個例子來解釋一下，對于一個非常龐大的網頁部分，可以有各個模塊組成，其中評論模塊是我們非常小的模塊，但是評論可能涉及很多條可能涉及分頁，如果我們每次為了看下一頁的評論，點擊下一頁就向服務端請求整個頁面資源進行刷新，那樣就太浪費服務端資源和帶寬了(就評論的文本變了，就要把其他模塊全部渲染一遍？)

所以我們采取所謂AJAX異步更新這個東西，也就是通過JavaScript請求下一頁的評論相關數據(用json作為數據交互文本)，JavaScript得到這串json字符串中就有頁面需要的評論信息，然后我們強大到無所不能的JavaScript將這部分重現渲染到評論模塊的對應位置。

這個流程下來，我們不僅節約了帶寬，提高了響應速度，還提高了服務器相對負載能力(每次請求需要的資源更少)，提高了用戶的使用體驗，還提高了------（此處省略萬字）

跨平臺webservice:

前面提到的是前后端的交互，前提是后端同是一門編程語言、平臺，向前端提供服務。但隨著互聯網的發展，很多時候會遇到服務拆分、跨平臺等服務的需要。而跨語言跨平臺的最大障礙就是服務的交流問題。你總不至于用你電腦上的c++代碼直接調用我電腦上某個java函數吧?為了解決這種問題，這時候通過restful風格的接口和json作為文本傳輸的格式就能良好的解決服務通信問題。

例如某個公司業務太大，將服務分配給A團隊和B團隊。很多時候A可能需要進行調用B服務。如果A團隊全部是java，B團隊全部是php，互相喊著天下第一不肯相讓。這該怎么辦？那么通過json進行通信是一種非常好的方式。流程如圖簡要所示：

非關系數據庫存儲(Nosql)

隨著互聯網web2.0網站的興起，傳統關系數據庫在處理超大規模網站和高并發方面顯得有點力不從心。而非關系型的數據庫由于它本身的特點得到非常迅速的發展，非關系數據庫在大規模數據下也有非常良好的讀寫性能，且數據之間無關系，無形之間就在架構層面帶來了可拓展的能力。

而有很多基于文檔存儲的非關系數據庫采取json作為其存儲格式，其中比較著名的有：MongoDB、CouchDB、RavenDB等。存儲的內容是文檔型的，這樣也有機會對某些字段建立索引，實現關系數據庫的某些功能。

有些同學可能會問：既然json可以，那xml可以實現相似功能嘛？

答案是不可以，因為像xml類型的字段，不管是查詢還是更改效率都很一般，主要原因是是DB層對xml字段很難建高效索引，應用層又要做從字符流到dom的解析轉換。NoSQL以json方式存儲，提供了原生態的支持，在效率方面遠遠高于傳統關系型數據庫。

此外，Elasticsearch等搜索引擎還用json和java api 提供其所有特性和功能。json在開源中間件的應用也越來越多！

(多選題)小練習：json常用于以下那些領域？(ABC)

• 前端Ajax異步交互
• webservice提供接口
• 非關系數據庫數據存儲

拒絕四不像，json語法有要求

json語法規則

json語法是JavaScript語法的子集，而json一般也是用來傳輸對象和數組。也就是json語法是JavaScript語法的一部分(滿足特定語法的JavaScript語法)。

• 數據保存在名稱、值對中，數據由逗號分隔
• 花括號表示對象
• 中括號表示數組

json名稱/值

json 數據的書寫格式為："名稱":"值"。
對應JavaScript的概念就是：名稱="值"
但json的格式和JavaScript對象格式還是有所區別：

• JavaScript對象的名稱可以不加引號，也可以單引號，也可以雙引號，但json字符串的名稱只能加雙引號的字符表示。
• JavaScript對象的鍵值可以是除json值之外還可以是函數等其他類型數據，而json字符串的值對只能是數字、字符串(要雙引號)、邏輯值、對象(加大括號)、數組(中括號)、null。

json對象

json有兩種表示結構—對象和數組，通過著兩種表示結構可以表示更復雜的結構。對比java的話json數組和json對象就好比java的列表/數組(Object類型)和對象(Map)一樣的關系。并且很多情況其對象值可能相互嵌套多層，對對象中存在對象，對象中存在數組，數組中存在對象…下面這張圖能夠一定程度反應json對象和數組的關系：

json對象很容易理解，它代表一個實體，這個實體有一些其他的屬性，這些屬性可能是數字、字符串(要雙引號)、邏輯值、對象(加大括號)、數組(中括號)、null。如果從java語言來看他就是對應一個實體類或者一個Map，其中有一些用鍵值的方式描述名稱和值。

var a = {"name":"bigsai" , "sex":"man","school":{"name":"博學谷","localtion":"Bei Jing"}};

取值：可以通過(.)或者([])進行取值,例如a.name(a.sex)和a["name"](a["sex"]),代碼解釋如下：

對象套對象：可以通過(.)或者([])進行取值。代碼解釋如下：

遍歷：可以用 for - in 進行對象遍歷。代碼解釋如下：

修改：可以使用(.)或者([])進行修改對象的值。示例代碼如下：

刪除：可以通過delete關鍵詞刪除json對象屬性值。示例代碼如下：

完整代碼截圖為：

附上代碼：

var a = {"name":"bigsai" , "sex":"man","school":{"name":"博學谷","localtion":"Bei Jing"}}; a.name+" "+a["name"] a.school a["school"].namefor (key in a){//遍歷對象console.log(key+" "+a[key]);}a.name="saisai" a["sex"]="woman" a delete a["school"] a

json數組

學習完json對象，那么json數組的學習就容易的多了。json數組與json對象有一些區別，json數組用中括號表示([])，各個值用逗號(,)分隔，并且數組值需要是json合法數據類型(字符串, 數字, 對象, 數組, 布爾值或 null).

var names=["bigsai","bigpian","bigbig"];//json數組 var students=[{"name":"bigsai","high":180},{"name":"bigpian","high":165},{"name":"Yao Ming","high":226}];//對象套數組

取值：可以通過中括號([])進行取值，例如names[0]或names["0"]，示例代碼如下：

數組套對象：取值到對象后遵從對象的語法。示例代碼如下：

遍歷：可以用 for - in 或者for 對json數組進行遍歷。示例代碼如下：

修改：可以使用([])索引號進行修改數組。示例代碼如下：

刪除：可以通過delete關鍵詞刪除json數組中的項目。示例代碼如下：

完整json數組示例代碼如下：

附上源碼：

var names=["bigsai","bigpian","bigbig"];//json數組 var students=[{"name":"bigsai","high":180},{"name":"bigpian","high":165},{"name":"Yao Ming","high":226}];//對象套數組 names["0"]+" "+names[0]//json數組取值 students[2]["name"]+" 身高："+students[2].high//json數組套對象(對象套數組同理) for (i in names){ console.log(names[i]); }//for in 遍歷 for (i=0;i<names.length;i++){console.log(names[i]);} names[0]="bigsai666"; delete names[0]; names

JavaScript對象 VS json對象 VS json字符串

在JavaScript中談到json，很多人會對JavaScript對象、json對象、json字符串混淆和概念不清晰，我們可以舉個例子來一起看一下：

var a1={ name:"bigsai" , sex:"man" };//JavaScript對象 var a2={'name':'bigsai' , 'sex':'man'};//JavaScript對象 var a3={"name":"bigsai" , "sex":"man"};//滿足json格式的JavaScript對象 var a4='{"name":"bigsai" , "sex":"man"}';//json字符串

總的來說：

• JavaScript對象：除了字符串、數字、true、false、null和undefined之外，JavaScript中的值都是對象。

• json對象：這個說法其實不太準確，沒有單獨的json對象，我們常說的json對象它實質是滿足json格式要求的JavaScript對象。如上a3對象。

• json字符串，滿足json語法格式的字符串(json是一種數據格式)，有時也稱json串。

在這里多說幾句，你可能會對json對象還是有點不夠清晰，你可能在其他地方也會遇到json對象。首先，json是一種數據格式，而json有對象和數組兩種具體表現格式。

• 當你直接說json對象，json數組的時候。它其實就是直接談json的兩種表示結構。它主要體現的是結構。
• 在JavaScript中，我們通常說的json對象，json數組通常代指滿足json格式的JavaScript對象，JavaScript數組。
• 在java中我們有時也說json對象，json數組，這個其實就是第三方工具包基于json規范封裝的JSONObject、JSONArray類。

總的來說，我們通常說的json對象、json數組它實質是一種數據格式。但同在在不同語言中滿足這種格式要求的對象、數組我們會稱其為json對象、json數組。

(選擇題)小練習：下列哪一項是滿足json格式的JavaScript對象？(D)

• A. { name : “博學谷” , value : “very well” };
• B. { ‘name’ : “博學谷” , ‘value’ : “very well” };
• C. { name : “張三” , age : “18” };
• D. { “name” : “李四” , “age” : 25 };

小結

本章小結：大家可以發現json的語法規則還是相對簡單的，對于json語法格式，大家要謹記json的數據名稱只能是帶雙引號("")的字符串，而json對象的值要謹記有哪幾種滿足的類型。對于json對象和json數組來說，是json的兩種表示結構，而json的靈活性也允許兩種類型的相互嵌套，可以表示更為復雜的結構。

（單選題）既然大家和我一起學了json對象、數組以及一些基本語法，下面考考大家，json對象的值不可以是下面哪種類型呢？(D)

• 字符串
• 數字
• json對象/json數組
• 函數

谷歌Gson，精簡而強大

序列化/反序列化介紹

前面我們學習了json的一些概念和基礎語法，也知道了json起身于JavaScript，在很多語言如python中得到較好的支持，但也有很多語言從語言本身來說是不支持json的(就比如咱們強大的java)。這雖然是一大障礙但并不阻止我們在java這門語言中使用json。我們可以通過添加一些工具包使得java支持json處理。

這些工具包能夠將json字符串轉換成java對象，從而在Java中使用。反過來也可以將java對象轉換成json字符串，從而更廣泛地用在其他地方。將Java對象到Json字符串的過程我們稱為Serialization序列化，將Json字符串轉換成Java對象的過程我們稱為Deserialization反序列化。

如果理解起來容易混淆，那么可以借助下面這張圖進行結合記憶：咱們從java角度來看，java對象需要從一個整體對象拆分成一個個碎片按序列往json字符串中寫入，這就是一個序列化過程。而json字符串的一個個碎片反過來重新組裝成一個完整的java對象這個過程就是反序列化。

對于json本身來說是不復雜的，但是在java中如果程序員直接操作json字符串那是一件非常麻煩和復雜的事情，不少優秀的程序員/團隊/公司努力研究，將他們經驗和智慧開源出來供大家使用，在其中，Gson/fastjson/Jackson要更流行一些。咱們一個個了解一下。

Gson介紹

在學習之前，你知道什么是Gson嗎？
Gson是谷歌開源的一個Java庫，可用于將Java對象轉換為(序列化)其JSON表示形式。它還可以用于將JSON字符串轉換為(反序列化)等效的Java對象。Gson可以處理任意Java對象，包括沒有源代碼的現有對象。下圖為Gson在github主頁一些信息。

每種json工具包都有它自己的優點和長處，對于Gson來說，有以下幾點特點：

• 提供簡單的toJson()和fromJson()方法，將Java對象轉換成json字符串，反之亦然
• 允許將現有的不可修改對象與JSON相互轉換
• Java泛型的廣泛支持
• 允許對象的自定義表示
• 支持任意復雜的對象（具有深層次的繼承層次結構、泛型等）

Gson實戰

下面和大家一起動手進行Gson實戰，Gson的功能比較強大，在這里呢和大家一起實現一些基礎和常用的使用。

首先創建一個java項目(Maven),要引入Gson的Maven依賴或jar包，其Maven依賴為：

<dependency><groupId>com.google.code.gson</groupId><artifactId>gson</artifactId><version>2.8.6</version> </dependency>

有了Gson的依賴之后，那么實現Java對象與Json的轉化也就很簡單啦，大體就是分為兩步啦:

• 首先創建Gson對象，這里可以直接new 或者使用GsonBuilder進行創建，如果使用直接new的方式創建Gson對象是使用默認的配置；而使用GsonBuilder首先要創建GsonBuilder，然后GsonBuilder調用一些配置方法，然后調用create()方法構建Gson對象。
• 然后通過Gson對象的toJson(),fromJson()方法進行序列化和反序列化操作。

javaBean與json字符串互相轉換：
首先創建一個student對象

public class student {private String name;private int age;private String sex;public student(String name, int age, String sex) {//構造方法this.name = name;this.age = age;this.sex = sex;}@Overridepublic String toString() {//重寫toString方法return "student{" +"name='" + name + '\'' +", age=" + age +", sex='" + sex + '\'' +'}';}public String getName() {//獲取name字符串return name;}public void setName(String name) {//設置對象namethis.name = name;}public int getAge() {//獲取年齡intreturn age;}public void setAge(int age) {//設置年齡值this.age = age;}public String getSex() {//獲取性別return sex;}public void setSex(String sex) {//設置性別this.sex = sex;} }

其次，在測試中進行JavaBean(student)與json字符串的轉換。主要通過toJson()和fromJson()進行序列化和反序列化操作。toJson，直譯過來就是“到達json”，所以是將java對象轉成json字符串，也就是序列化。fromJson，直譯過來就是“來自json”，所以是將json字符串轉化為java對象，也就是反序列化。

//Gson gson= new GsonBuilder().create();//可以自定義一些配置Gson gson=new Gson();//創建json對象 //java對象 to jsonstudent stu=new student("Ben",22,"man");String stustr=gson.toJson(stu,student.class);//json轉為stringSystem.out.println("student對象為"+stu.toString());System.out.println("轉化為json字符串："+stustr);//json to java對象///滿足條件的json字符串{"name":"tony","age":32,"sex":"woman"}String jsonstr="{\"name\":\"tony\"," +"\"age\":32," +"\"sex\":\"woman\"}";student jsonstrobject=gson.fromJson(jsonstr,student.class);//轉換為student對象System.out.println("json字符串為"+jsonstr);System.out.println("轉化為student對象為："+jsonstrobject.toString());

執行的結果為：

java集合與json字符串互相轉化：
在實際開發中，我們很可能遇到的并不是javaBean與json字符串的直接轉化，而是集合之類的轉化工作，java集合種類繁多。在此，我們實現Map、List、String數組的序列化和反序列化操作。
在進行序列化操作時，我們首先創建Map<String,String>,List<Object>,String[]對象然后填充一定數據以便進行序列化和反序列化操作。

Gson gson=new Gson();//創建json對象 //MapMap<String,String>map=new HashMap<>();//Mapmap.put("博學谷","666");map.put("小老弟","要加油");//ListList<Object>list=new ArrayList<>();//List類型list.add("hello");list.add("world");list.add(map);//String[]String []str={"Hello","World"};//StringString mapTojsonStr=gson.toJson(map);//{"小老弟":"要加油","博學谷":"666"}String listTojsonStr=gson.toJson(list);//["hello","world",{"小老弟":"要加油","博學谷":"666"}]String strTojsonStr=gson.toJson(str);//["Hello","World"]System.out.println("Map轉為json:"+mapTojsonStr);System.out.println("List轉為json:"+listTojsonStr);System.out.println("String[]轉為json:"+strTojsonStr);

執行的結果為：

我們將這些字符串復制到新的代碼域進行反序列化操作，在反序列化時候，我們會用到fromJson()這個函數時，有兩種我們常用的構造方式fromJson(String json, Class<T> classOfT)和fromJson(String json, Type typeOfT)，如果遇到泛型等類型時候需要借助 TypeToken來獲取對象類型。

Gson gson=new Gson();//創建json對象String mapTojsonStr="{\"小老弟\":\"要加油\",\"博學谷\":\"666\"}";//{"小老弟":"要加油","博學谷":"666"}String listTojsonStr="[\"hello\",\"world\",{\"小老弟\":\"要加油\",\"博學谷\":\"666\"}]";//["hello","world",{"小老弟":"要加油","博學谷":"666"}]String strTojsonStr="[\"Hello\",\"World\"]";//["Hello","World"]//方式一方便簡潔(這里避免沖突注釋掉)//Map<String,String>map1=gson.fromJson(mapTojsonStr,Map.class);//方式二可以獲取泛型等數據類型Map<String,String>map1=gson.fromJson(mapTojsonStr,new TypeToken<Map<String,String>>(){}.getType());List<Object>list=gson.fromJson(listTojsonStr,List.class);Map<String,String>map2=(Map<String,String>)list.get(2);String str[]=gson.fromJson(strTojsonStr,String[].class);System.out.println("json轉Map:"+map1.toString());System.out.println("json轉List"+list.toString());System.out.println("map1和map2是否相等:"+map2.equals(map2));//相等 System.out.println("String[]:"+ Arrays.toString(str));

輸出結果為：

上面只是介紹了java對象與json字符串的轉換，實際上Gson不僅入手容易，還有其他非常強大的功能，在使用Gson開發中除了java對象和json字符串的轉換，我們經常也會對JsonObject直接進行操作(類似JavaScript中操作json串一樣)，這里你需要了解學習Gson封裝的JsonEelement，JsonObject，JsonArray，JsonPrimitive,JsonNull等數據類型。

不同的數據類型有各自的使用場景，下面給大家介紹下各個數據類型之間的區別與聯系：

• JsonElement：表示Json元素的類。 它可以是JsonObject，JsonArray，JsonPrimitive或JsonNull。這個你可以理解一下java中List(Arraylist,LinkedList)，Map(HashMap.TreeMap,ConcurrentHashMap)等聯系。也可以理解為Object的類與其他類的關系。
• JsonObject：表示Json中對象類型的類。 對象由名稱-值對組成，其中名稱是字符串，而值是任何其他類型的JsonElement。
• JsonArray: 表示Json中數組類型的類。 數組是JsonElement的列表，每個JsonElement的類型可以不同。 這是一個有序列表，意味著保留添加元素的順序。
• JsonPrimitive：表示Json基本值的類。 基本值可以是String，Java基本類型或Java基本類型的包裝類。
• JsonNull：表示Json空值的類。

對于這些數據類型，你可能會問：為啥json字符串已經可以和java對象互相轉了，還需要這些數據類型呢？
答案是這些數據類型讓java中多一種可以處理json格式數據的方式。一方面讓java處理json格式數據更加靈活，另一方面在某些場景下這樣直接操作JsonObject、JsonArray等能夠簡化工作流程。

其實這些數據類型就是相當于用java的數據結構構造一個json的數據結構和方法(java本身不直接支持json)，讓我們能夠直接使用和操作json。

從上圖可以看得出，上面這些數據結構也是根據java的一些數據結構作為存儲，然后寫一些操作函數，封裝一些方法。當然，JsonObject也可以通過Gson的toJson()和fromJson()方法靈活轉成字符串和java對象。

有很多時候我們后臺處理接受到的是一個json字符串，可能其內部結構也很復雜，如果我們將其轉成java對象可能要編寫java對應的實體，但是如果直接操作json對象可能就省下一些操作和流程，如果只需增刪改其中很小的一部分，那么這種選擇也是一種不錯的方案。當然具體的使用方法和方案還需要根據具體的業務來判斷！

(多選)既然學習了Gson，那么就來考考大家到底有沒有真的掌握Gson的關鍵函數,仔細思考哦，這題有點狠，一錯俱錯呦：(AD)

• A.函數 toJson() 是將對象轉成json字符串。
• B.函數 toJson() 是將json字符串轉成對象。
• C.函數fromJson() 是將對象轉成json字符串。
• D.函數fromJson() 是將json字符串轉成對象。

飛人fastjson，阿里的"黑科技"

fastjson介紹

除了谷歌的Gson，咱們國內也有一款非常強大的java序列化工具包—fastjson。下圖為fastjson在github的主頁：

學習fastjson之前同樣問：什么是fastjson？

• fastjson是阿里巴巴的開源JSON解析庫，它可以解析JSON格式的字符串，支持將Java Bean序列化為JSON字符串，也可以從JSON字符串反序列化到JavaBean。

除了是國內阿里開源的，fastjson還有優異的性能，fastjson的優點如下：

• 速度快：fastjson相對其他JSON庫的特點是快，從2011年fastjson發布1.1.x版本之后，其性能從未被其他Java實現的JSON庫超越。
• 使用廣泛、測試完備。在阿里內部有廣泛的應用。
• 使用簡單、功能完備。支持泛型、復雜類型等。
  

fastjson實戰

下面帶大家實戰fastjson，同樣首先我們需要引入依賴，下載jar包引入或者maven的依賴。

<dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.70</version> </dependency>

fastjson與Gson雖然大體相似但有所區別，fastjson自己也有實現的JSONObject，JSONArray類，前面在Gson中介紹過此類的作用我們在進行轉換時候就把JSONObject加入進行轉換。在fastjson主要提供以下三個類：
（1）JSON：fastJson的解析器，用于JSON格式字符串與JSON對象及javaBean之間的轉換。
（2）JSONObject：fastJson提供的json對象。
（3）JSONArray：fastJson提供json數組對象。

json字符串、JSONObject及JavaBean之間的相互轉換
首先，我們同樣定義一個student類(同Gson的student類)

public class student {private String name;private int age;private String sex;public student(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}//get set方法 }

在測試代碼中，我們分別編寫一些代碼實現三者的相互轉換，但JSONObject、JSONArrray、JSON以及fastjson仍然有很多方法功能在這里就無法進行很詳細的展示了：

//對象轉json字符串，JSONObject student student1=new student("xiaoming",5,"man"); String jsonstr1= JSON.toJSONString(student1);//對象轉json字符串 JSONObject jsonObject1=(JSONObject) JSON.toJSON(student1);//對象轉JSONObject System.out.println(jsonObject1.toString()); System.out.println(jsonstr1+"\n"); //json字符串轉java對象，JSONObject String jsonstr2="{\"age\":5,\"name\":\"xiaoming\",\"sex\":\"man\"}"; JSONObject jsonObject2=JSON.parseObject(jsonstr2);//json字符串轉JSONObject對象 student student2 = JSON.parseObject(jsonstr2,student.class);//json字符串轉java對象 System.out.println(jsonObject2.toString()); System.out.println(student2.toString()+"\n");//JSONObject 轉java對象，json字符串 JSONObject jsonObject3=jsonObject2; jsonObject3.put("age",18);//修改年齡 student student3=jsonObject3.toJavaObject(student.class);//JSONObject轉java對象 String jsonstr3=jsonObject3.toJSONString();//JSONObject轉json字符串 String name=jsonObject3.getString("name");//JSONObject取值 int age=jsonObject3.getInteger("age"); String sex=jsonObject3.getString("sex"); System.out.println("姓名"+name+" 年齡"+age+" 性別"+sex); System.out.println(student3.toString()); System.out.println(jsonstr3+"\n");

對應輸出的結果與預期一致：

json字符串、JSONObject及Java集合相互轉換
上面進行了基于javabean的一些轉換和操作，下面我們進行對java集合的一些轉化實戰。看看fastjson又是以什么樣的參數進行的。java的Map是常用集合之一，咱們先看看Map的相關轉化：

//map的相關轉化 Map<String,String>map1=new HashMap<>(); map1.put("name","xiaoming");map1.put("sex","woman"); String jsonstr=JSON.toJSONString(map1);//Map轉json字符串 JSONObject jsonObject=(JSONObject) JSON.toJSON(map1);//Map轉json對象System.out.println(jsonstr); System.out.println(jsonObject.toString()); //Map<String,String>map2=JSON.parseObject(jsonstr,Map.class);//方式一 Map<String,String>map2=JSON.parseObject(jsonstr,new TypeReference<Map<String, String>>(){});//方式二json字符串轉Map Map<String,String>map3=jsonObject.toJavaObject( new TypeReference<Map<String, String>>(){});//JSONObject System.out.println(map2.toString()); System.out.println(map3.toString());

控制臺的輸出為：

此外，List同樣也是java中使用較多的集合之一，咱們可以看下它的相關轉化：

//List相關轉化 List<Map<String,String>>list1=new ArrayList<>();//集合 Map<String,String>map1=new HashMap<>(); map1.put("name","map1"); Map<String,String>map2=new HashMap<>(); map1.put("name","map2");map2.put("sex","man"); list1.add(map1);list1.add(map2); String jsonstr=JSON.toJSONString(list1);//list轉json字符串 JSONArray jsonArray =(JSONArray) JSON.toJSON(list1);//list轉jsonArray JSONObject jsonObject=jsonArray.getJSONObject(0); System.out.println(jsonstr); System.out.println(jsonArray+" "+jsonArray.get(0));//json 字符串轉list List<Map<String,String>>list2=JSON.parseObject(jsonstr,new TypeReference<ArrayList<Map<String,String>>>(){}); //List<student>list3=JSON.parseArray("",student.class);//普通list的轉換方式 System.out.println(list2.get(0).equals(map1)+" "+list2.get(1).equals(map2));//如果相等則證明成功序列化 System.out.println(list2.toString());

得到輸出結果為：

不難看的出，fastjson在入門還是非常簡單的。并且和Gson有很多相似之處，在Api的設計方面，Gson需要一個Gson對象來進行相關操作，而fastjson的JSON、JSONObject、JSONArray定義了很多靜態的方法可以直接使用。同時兩者的反序列化的TypeToken(Gson)和TypeReference(fastjson)有異曲同工之妙。

這兩者在開發過程中使用很多，各有優劣，并且這里只是里面很小的一部分內容，要想深入學習還需要了解官方全面API才行(Gson官方API，fastjson官方文檔)。但是對于fastjson來說，有些地方可能存在一些漏洞和不穩定因素，但是阿里很快就進行修復。所以在實際使用中要考慮fastjson的安全性。

(習題)介紹完咱們國內開源的科技—fastjson,那么我來看看對fastjson掌握程度如何，考考大家：下面哪個不是fastjson的類(D)

• A.JSON
• B.JSONObject
• C.JSONArray
• D.JsonElement

備受開源認可，Jackson亦是真王者

Jackson介紹

最后咱們介紹的就是當前更為成熟一點的jackson。jackson 是一個能夠將java對象序列化為json字符串，也能夠將json字符串反序列化為java對象的框架。下圖為jackson在github主頁情況：

其實jackson的應用非常廣泛，在這里我們簡單了解以下jackson然后對比分析三個json工具包的異同，對于jackson來說，擁有以下幾點優勢：

• 出師較早，國際流行度較高，且社區學習內容較為豐富。
• 安全穩定，是很多開源框架的內置序列化框架(例如Springmvc)。
• 解析大的json文件效率較高，占用內存較少，性能比較好。
• 擁有靈活的API，可以很容易的拓展和定制。

jackson實戰

下面帶大家實戰jackson，在Gson和fastjson使用時只需引用一個jar，而jackson卻不是將所有全部集成到一個jar內，而是分成了多個不同的模塊(不同模塊具有不同功能)，咱們首先引入jackson的依賴：

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core --> <dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-core</artifactId><version>2.11.0</version> </dependency> <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind --> <dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId><version>2.11.0</version> </dependency> <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations --> <dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-annotations</artifactId><version>2.11.0</version> </dependency>

有了jackson依賴之后，我們就可以進行實戰了，在jackson中有三種方式操作json：

• 流式API - 使用 Stream(流) 的方式對 Json 的每一個組成部分進行最細粒度的控制，JsonParser 讀取數據，JsonGenerator 寫入數據。(json streaming 流式計算,開銷最低,讀寫最快)
• 樹模型 - 將 JSON 文件在內存里以樹的形式表示，通過 JsonNode 處理單個Json節點，類似于 XML 的 DOM 解析器。（數模型Json文件在內存里以樹形式表示 ObjectMapper構建JsonNode 節點樹 最靈活)
• databind 模塊 - ObjectMapper 讀/寫 JSON ，是 序列化與反序列化 json 最方便的方式。 (本篇實戰采用的方法)

javaBean與json字符串相互轉換
對于javaBean，我們創建student類(注意使用jackson的類必須有空參構造器)：

public class student {private String name;private int age;private String sex;public student(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}public student(){}//空參構造器//get set方法 toString方法 }

在測試代碼中，首先創建一個ObjectMapper對象，序列化和反序列化都需要它。然后根據writeValueAsString()這個函數就可以把java對象轉成json字符串(序列化)。而json字符串通過readValue()就可以將json字符串轉化為java對象(反序列化)。代碼的展示如下：

//創建 ObjectMapper對象 ObjectMapper mapper=new ObjectMapper(); //序列化的實體類 student stubigsai=new student("bigsai",6,"man"); //writeValueAsString()方法進行序列化 String stubigsaistr=mapper.writeValueAsString(stubigsai); System.out.println(stubigsaistr+"\n");//反序列化的json字符串 String stuxiaohongstr="{\"name\":\"xiaohong\",\"age\":8,\"sex\":\"woman\"}"; //readValue()方法進行反序列化 student stuxiaohong= mapper.readValue(stuxiaohongstr,student.class); System.out.println(stuxiaohong.toString());

對于上述代碼執行結果為：

java集合與json字符串相互轉換
除了javaBean和json字符串轉換外，java集合和json字符串的轉換也很簡單，我們這里就只演示java的Map與json字符串相互轉化了，其流程與上述的javaBean和json互轉有點類似。需要注意的是從json轉換為Map對象(或其他泛型對象)的時候，由于Java的類型擦除，有些無法直接正確轉換的類型需要我們手動用new TypeReference給出，實例代碼如下：

//創建 ObjectMapper實體類 ObjectMapper mapper=new ObjectMapper(); //需要序列化的Map和List Map<String,Object>map1=new HashMap<>(); map1.put("博學谷","666");map1.put("bigsai",666);//注意兩個666類型不同 map1.put("string",new String[]{"bigsai", "博學谷"}); //序列化結果 String map1str=mapper.writeValueAsString(map1); System.out.println(map1str+"\n");//方式一反序列化結果 Map<String,Object>m1=mapper.readValue(map1str,Map.class); //方式二TypeReference指定反序列化類型(適合泛型和復雜類型) Map<String,Object>m2=mapper.readValue(map1str, new TypeReference<Map<String, Object>>() {}); System.out.println(m1.toString()); System.out.println(m2.toString());

執行結果為：

看完實例，你是不是發現：哇，原來三者有很相似的之處啊，是的，一個優秀的開源框架不光光要考慮其功能、性能，其易用性、對用戶友好程度、官方文檔等也是非常重要的指標！當然，這里僅僅是jackson功能的九牛一毛，更詳細深入的學習需要到jackson官方文檔去查閱。

Gson VS fastjson VS jackson

現在三種java的序列化/反序列化json框架都已經介紹啦。三者都是非常優秀的框架，這是毋庸置疑的，但是一對比，它就有一些傷害啊(嚶嚶嚶)。

名稱GsonfastjsonJackson

社區生態	較好	一般	較好
易用性	易用	易用	一般
小文件速度	最快	較快	較慢
大文件速度	較慢	較快	較快
穩定性	穩定	一般	穩定
安裝包大小	非常小	較小	一般

綜上所述來說：
Gson：輕便簡潔，適合中小json文件的解析。在大json文件上效率略差，且其功能比較全面，生態較好。
jackson：處理大文件速度快一些，且比fastjson穩定一些。生態較好。
fastjson：速度較快，但經常爆出安全問題。生態一般，主要國內使用。

對選取哪個json框架主要根據自己的需要，如果是測試或者比較簡單個人使用，推薦Gson和fastjson上手比較容易。如果是需要上線，那么fastjson得慎用，可能某些數據會序列化失敗。

在介紹完的最后，偷偷贊揚一下咱們fastjson主要貢獻者溫少，不僅是fastjson開源者溫少也是另一開源框架主要貢獻者—druid(阿里數據庫連接池)，所以這位作者大大是非常努力，將自己奉獻給了開源的事業中，服務更多的人，點贊！！！ 希望未來的我們，也能像溫少那樣有所作為！加油！

在這里，本篇對json得介紹、json語法使用以及Gson/fastjson/jackson的一些實戰的介紹就此已經完畢了，json很容易，但json也可能很復雜，這要取決你具體業務的使用和需求，希望在日后的日子里，能夠對json的理解和應用能夠有更深一步的認知！加油，我們下次再見！

(單選)既然對比完Gson,fastjson,Jackson,那么小老弟妹們，俺來考考你對三者認識咋樣，那么問題來了，你給我看看下面那個是錯的呢?(B)

• A.Gson體積較小，但功能豐富強大，社區生態完整。處理小文件效率較高。
• B.fastjson速度較快，在國內外都比較流行，且社區生態較好。
• C.jackson廣泛應用于開源框架，穩定且效率較高，流行度和認可度最高。
• D.Gson是谷歌開源的，fastjson是阿里開源的，Jackson是fastXML團隊開源的。

小試牛刀

上面講了那么多，對于我們來說掌握java中操作json很重要，那么咱們動手進行一個轉換小案例。這里咱們要求用Gson，fastjson將下面對象進行轉化：

javaBean轉json字符串

假設我們有個teacher 類有name和age兩個屬性。

public class teacher {private String name;private int age;//省略get set 以及構造函數 }

首先我們有一個對象

teacher teachersai=new teacher("bigsai",22);

大家想一下這個對象的json格式的字符串會是什么樣的呢？

沒錯，答案就是這樣的：

{"name":"bigsai","age":22}

如果是Gson，我們是這樣操作的：

Gson gson=new Gson(); String teacherstr=gson.toJson(teachersai); System.out.println(teacherstr);//{"name":"bigsai","age":22}

而如果是fastjson，它又會是怎樣的呢？

String teacherstr=JSON.toJSONString(teachersai); System.out.println(teacherstr);//{"name":"bigsai","age":22}

這樣就完成java對象轉成json字符串啦，是不是非常簡單，因為fastjson將JSON中的很多方法寫成靜態static所以我們連這個對象都不需要創建。

json字符串轉javaBean

上面咱們輕輕松松的就可以將javaBean轉成json字符串，下面如果咱們有這么一個字符串需要轉成java的teacher對象，需要怎么搞呢？

String teacherpian="{\"name\":\"bigpian\",\"age\":21}";//{"name":"bigpian","age":21}

那么創建完Gson對象只需一行代碼就搞定：

Gson gson=new Gson(); teacher teacherp=gson.fromJson(teacherpian,teacher.class);

同理，咱們fastjson也是一行代碼搞定：

teacher teacherp=JSON.parseObject(teacherpian,teacher.class);

是不是很容易呢？當然如果細心好學的你肯定會發現還有其他的寫法啦，修行靠個人啦，更多的用法肯定還需要自己去挖掘啦！

本文總結

輕松愉快的json介紹課程到這里就結束了，通過本節課程，你了解了json的概念，分清了json和xml的異同點，也知道了json在web領域和非關系數據庫的那些應用。通過系列介紹、比較、結合實際場景相信你對json的認識肯定都是非常清晰。

緊接著文章又介紹了json的語法規則以及在java中操作json的實戰操作，學習和比較了Gson、fastjson、jackson的應用以及他們之間的區別點，相信你也掌握了在java語言中json的實戰能力，且能夠根據自己需求靈活使用哪種框架，并深入的研究下去。

json是web技術進步與發展的產物，它是一種數據交換格式。它幾乎是前后端程序員不可避免的技術點，希望大家在日后能夠多多回顧課程，結合其他教材文本等，**將json 從立地到成佛！**加油，我們下次再會！

創作不易，還請關注個公眾號支持下，微信公眾號：bigsai，一個有趣的程序員~

總結

以上是生活随笔為你收集整理的json从立地到成佛的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。