Fastjson介紹

時間 2019-11-11

標籤 fastjson 介紹欄目 JSON 简体版

原文原文鏈接

簡單介紹

Fastjson是一個Java語言編寫的高性能功能無缺的JSON庫。javascript

高性能

fastjson採用首創的算法，將parse的速度提高到極致，超過所有json庫，包含之前號稱最快的jackson。並且還超越了google的二進制協議protocol buf。java

支持標準

Fastjson全然支持http://json.org的標準，也是官方站點收錄的參考實現之中的一個。

功能強大

支持各類JDK類型。包含基本類型、JavaBean、Collection、Map、Enum、泛型等。
支持循環引用

無依賴

不需要例外額外的jar，能夠直接跑在JDK上。

支持範圍廣

支持JDK 五、JDK 六、Android、阿里雲手機等環境。

開源

Apache License 2.0
代碼託管在github.org上，項目地址是 https://github.com/AlibabaTech/fastjson

測試充分

fastjson有超過1500個testcase，每次構建都會跑一遍，豐富的測試場景保證了功能穩定。

得到fastjson

下載

http://code.alibabatech.com/mvn/releases/com/alibaba/fastjson/git

maven

假設你使用了Maven，maven repository配置例如如下：github

 
           <repository> 
          
           <id>opensesame</id> 
          
           <name>Alibaba OpenSource Repsoitory</name> 
          
           <url>http: 
           //code.alibabatech.com/mvn/releases/</url> 
          
           <snapshots> 
          
           <enabled> 
           false 
           </enabled> 
          
           </snapshots> 
          
           </repository>

pom.xml文件裏增長依賴依賴：算法

 
           <dependency> 
          
           <groupId>com.alibaba</groupId> 
          
           <artifactId>fastjson</artifactId> 
          
           <version> 
           1.1 
           . 
           14 
           </version> 
          
           </dependency>

序列化

一個JSON庫涉及的最基本功能就是序列化和反序列化。Fastjson支持java bean的直接序列化。你可以使用com.alibaba.fastjson.JSON這個類進行序列化和反序列化。sql

基本序列化

序列化就是把JavaBean對象轉化成JSON格式的文本。json

 
           Object o = ...; 
          
           String text = JSON.toJSONString(o);

在這個樣例中，調用JSON.toJSONString方法，把對象o轉化爲JSON格式的文本。瀏覽器

使用單引號

標準的JSON是使用雙引號的，javascript支持使用單引號格式的json文本，fastjson也支持這個特性，打開SerializerFeature.UseSingleQuotes這個特性就可以了了，好比：網絡

 
           Object o = ...; 
          
           String text = JSON.toJSONString(o, SerializerFeature.UseSingleQuotes);

fastjson序列化時可以選擇的SerializerFeature有十幾個，你可以依照本身的需要去選擇使用。iphone

日期格式化

fastjson直接支持日期類型數據的格式化，包含java.util.Date、java.sql.Date、java.sql.Timestamp、java.sql.Time。

缺省狀況下，fastjson將Date類型序列化爲long，這個使得序列化和反序列化的過程不會致使時區問題。如：
好比：

 
           long 
            millis = 1324138987429L; 
          
           Date date =  
           new 
            Date(millis);         
          
           System.out.println(JSON.toJSONString(date));

輸出的結果是

 
           1324138987429 
          

fastjson還提供了基於格式化輸出的SerializerFeature，好比：

 
           JSON.toJSONString(date, SerializerFeature.WriteDateUseDateFormat); 
          

輸出的結果爲：

 
           "2011-12-18 00:23:07" 
          

你可以指定輸出日期的格式，比方改動爲輸出毫秒：

 
           JSON.toJSONStringWithDateFormat(date,  
           "yyyy-MM-dd HH:mm:ss.SSS" 
           );

輸出的結果爲:

 
           "2011-12-18 00:23:07.429" 
          

使用WriteClassName特性

fastjson支持序列化時寫入類型信息，從而使得反序列化時不至於類型信息丟失。好比：

 
           Color color = Color.RED; 
          
           String text = JSON.toJSONString(color, SerializerFeature.WriteClassName); 
          
           System.out.println(text);

輸出結果：

 
      
       
         
           { 
           "@type" 
           : 
           "java.awt.Color" 
           , 
           "r" 
           : 
           255 
           , 
           "g" 
           : 
           0 
           , 
           "b" 
           : 
           0 
           , 
           "alpha" 
           : 
           255 
           } 
          
 
       
 
      
    

由於序列化帶了類型信息，使得反序列化時能夠本身主動進行類型識別，好比：

 
           String text = ...;  
           // {"@type":"java.awt.Color","r":255,"g":0,"b":0,"alpha":255} 
          
           Color color = (Color) JSON.parse(text);

瀏覽器和設備兼容

fastjson缺省的序列化內容，是對序列化結果緊湊作了優化配置，使得序列化以後長度更小，但是這樣的優化配置是對一些瀏覽器和設備不兼容的。比方說在iphone上兼容emoji（繪文字）。

 
           JSON.toJSONString(o, SerializerFeature.BrowserCompatible); 
          

循環引用

很是多場景中，咱們需要序列化的對象中存在循環引用，在不少的json庫中，這會致使stackoverflow。在功能強大的fastjson中，你不需要操心這個問題。好比：

 
           A a =  
           new 
            A(); 
          
           B b =  
           new 
            B(a); 
          
           a.setB(b); 
          
           String text = JSON.toJSONString(a);  
           // {"b":{"a":{"$ref":".."}}} 
          
           A a1 = JSON.parseObject(text, A. 
           class 
           ); 
          
           Assert.assertTrue(a1 == a1.getB().getA());

引用是經過"$ref"來表示的

引用	描寫敘述
"$ref":".."	上一級
"$ref":"@"	當前對象，也就是自引用
"$ref":"$"	根對象
"$ref":"$.children.0"	基於路徑的引用，至關於 root.getChildren().get(0)

使用@JSONField Annotation

在某些場景，你可能需要定製序列化輸出，比方說，但願序列化採用以後採用"ID"，而不是"id"，你可以使用@JSONField這個Annotation。

 
           public 
            class 
            User { 
          
           @JSONField 
           (name= 
           "ID" 
           ) 
          
           public 
            int 
            getId() { ... } 
          
           } 
          
           User user = ...; 
          
           JSON.toJSONString(user);  
           // {"ID":234}

從json-lib中升級

假設你已經使用了json-lib，並且痛恨他蝸牛般的速度和羅嗦的API，建議你升級爲fastjson，fastjson可以全然兼容json-lib的序列化格式。

 
           import 
            com.alibaba.fastjson.JSON; 
          
           import 
            com.alibaba.fastjson.serializer.JSONLibDataFormatSerializer; 
          
           import 
            com.alibaba.fastjson.serializer.JSONSerializerMap; 
          
           import 
            com.alibaba.fastjson.serializer.SerializerFeature; 
          
           private 
            static 
            final 
            SerializeConfig   config; 
          
           static 
            { 
          
           config =  
           new 
            SerializeConfig(); 
          
           config.put(java.util.Date. 
           class 
           ,  
           new 
            JSONLibDataFormatSerializer());  
           // 使用和json-lib兼容的日期輸出格式 
          
           config.put(java.sql.Date. 
           class 
           ,  
           new 
            JSONLibDataFormatSerializer());  
           // 使用和json-lib兼容的日期輸出格式 
          
           } 
          
           private 
            static 
            final 
            SerializerFeature[] features = { SerializerFeature.WriteMapNullValue,  
           // 輸出空置字段 
          
           SerializerFeature.WriteNullListAsEmpty,  
           // list字段假設爲null，輸出爲[]，而不是null 
          
           SerializerFeature.WriteNullNumberAsZero,  
           // 數值字段假設爲null，輸出爲0，而不是null 
          
           SerializerFeature.WriteNullBooleanAsFalse,  
           // Boolean字段假設爲null，輸出爲false，而不是null 
          
           SerializerFeature.WriteNullStringAsEmpty  
           // 字符類型字段假設爲null，輸出爲""，而不是null 
          
           }; 
          
           // 序列化爲和JSON-LIB兼容的字符串 
          
           public 
            static 
            String toCompatibleJSONString(Object object) { 
          
           return 
            JSON.toJSONString(object, config, features); 
          
           }

經過上面代碼中的toCompatibleJSONString方法，你就可以實現全然兼容json-lib了。

反序列化

反序列化就是把JSON格式的文本轉化爲Java Bean對象。

指定Class信息反序列化

經過指定類型信息，可以很是方便的將"JSON文本"反序列化爲"Java Bean"對象，好比：

 
           String text = ...;  
           // {"r":255,"g":0,"b":0,"alpha":255} 
          
           Color color = JSON.parseObject(text, Color. 
           class 
           );

類型集合的反序列化

這個接口相似於parseObject

 
           String text = ...;  
           // [{ ... }, { ... }] 
          
           List<User> users = JSON.parseArray(text, User. 
           class 
           );

泛型的反序列化

假設你需要返回一個帶泛型的對象，好比List<User>、Map<String, User>，你可以使用TypeReference來傳入類型信息。

 
           String text = ...;  
           // {"name":{"name":"ljw",age:18}} 
          
           Map<String, User> userMap = JSON.parseObject(text,  
           new 
            TypeReference<Map<String, User>>() {});

組合類型集合的反序列化

比方在網絡協議中，經常會存在這種組合:

 
           [{ 
           /*header*/}, {/*body*/ 
           }]

fastjson對這樣的結構的反序列化有專門支持。

 
           String text = ...;  
           // [{/* header */}, {/* body */}] 
          
           Type[] types =  
           new 
            Type[] {Header. 
           class 
           , Body. 
           class 
           }; 
          
           List<Object> list = JSON.parseArray(text, types); 
          
           Header header = (Header) list.get( 
           0 
           ); 
          
           Body body = (Body) list.get( 
           1 
           );

使用@JSONCreator來指定構造函數來建立對象

假設你的JavaBean沒有缺省構造函數，可以使用@JSONCreator來指定構造函數

 
           public 
            static 
            class 
            Entity { 
          
           private 
            final 
            int    
            id; 
          
           private 
            final 
            String name; 
          
           @JSONCreator 
          
           public 
            Entity( 
           @JSONField 
           (name =  
           "id" 
           )  
           int 
            id,  
           @JSONField 
           (name =  
           "name" 
           ) String name){ 
          
           this 
           .id = id; 
          
           this 
           .name = name; 
          
           } 
          
           public 
            int 
            getId() {  
           return 
            id; } 
          
           public 
            String getName() {  
           return 
            name; } 
          
           }

把JSON文本反序列化爲一個原型接口

 
           public 
            static 
            interface 
            Bean { 
          
           int 
            getId(); 
          
           void 
            setId( 
           int 
            value); 
          
           String getName(); 
          
           void 
            setName(String value); 
          
           } 
          
           String text =  
           "{\"id\":123, \"name\":\"chris\"}" 
           ; 
          
           Bean bean = JSON.parseObject(text, Bean. 
           class 
           ); 
          
           // 按接口調用 
          
           Assert.assertEquals( 
           123 
           , bean.getId()); 
          
           Assert.assertEquals( 
           "chris" 
           , bean.getName()); 
          
           bean.setId( 
           234 
           ); 
          
           Assert.assertEquals( 
           234 
           , bean.getId()); 
          
           出自： 
          
           http://code.alibabatech.com/wiki/pages/viewpage.action?pageId=2424946

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。