Alibaba FastJson 常用方法使用指南
2021-09-15 15:20:03

String text = JSON.toJSONString(obj); //序列化
VO vo = JSON.parseObject("{...}", VO.class); //反序列化

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.54</version>
</dependency>

JSONObject jsonObj = JSON.parseObject(jsonStr);

JSONArray jsonArr = JSON.parseArray(jsonStr);

Model model = JSON.parseObject(jsonStr, Model.class);

String jsonStr = JSON.toJSONString(object);

@JSONField(ordinal=1)//配置序列化的字段順序（1.1.42版本之后才支持）

@JSONField(serialize=false) //是否參與序列化：該字段不輸出  但是如果加了final，這個字段就無法被過濾

@JSONField(derialize=false) //是否參與反序列化：該字段不輸出  但是如果加了final，這個字段就無法被過濾 

@JSONField(format="yyyy-MM-dd HH:mm:ss") //日期按照指定格式序列化

@JSONField(name="別名");//使用字段別名

@JSONField(serialzeFeatures={SerialzeFeatures屬性});//序列化規(guī)則

@JSONField(parseFeatures={Features屬性});//反序列化規(guī)則

public enum SerializerFeature {
    /**
     * 輸出key時是否使用雙引號,默認為true
     */
    QuoteFieldNames,
    /**
     * 使用單引號而不是雙引號,默認為false
     */
    UseSingleQuotes,
    /**
     * 是否輸出值為null的字段,默認為false
     */
    WriteMapNullValue,
    /**
     * 用枚舉toString()值輸出
     */
    WriteEnumUsingToString,
    /**
     * 用枚舉name()輸出
     */
    WriteEnumUsingName,
    /**
     * Date使用ISO8601格式輸出，默認為false
     */
    UseISO8601DateFormat,
    /**
     * @since 1.1
     * List字段如果為null,輸出為[],而非null
     */
    WriteNullListAsEmpty,
    /**
     * @since 1.1
     * 字符類型字段如果為null,輸出為"",而非null
     */
    WriteNullStringAsEmpty,
    /**
     * @since 1.1
     * 數(shù)值字段如果為null,輸出為0,而非null
     */
    WriteNullNumberAsZero,
    /**
     * @since 1.1
     * Boolean字段如果為null,輸出為false,而非null
     */
    WriteNullBooleanAsFalse,
    /**
     * @since 1.1
     * 如果是true，類中的Get方法對應的Field是transient，序列化時將會被忽略。默認為true
     */
    SkipTransientField,
    /**
     * @since 1.1
     * 按字段名稱排序后輸出。默認為false
     */
    SortField,
    /**
     * @since 1.1.1
     * 把	做轉(zhuǎn)義輸出，默認為false(不推薦，已刪除)
     */
    @Deprecated
    WriteTabAsSpecial,
    /**
     * @since 1.1.2
     * 結(jié)果是否格式化,默認為false
     */
    PrettyFormat,
    /**
     * @since 1.1.2
     * 序列化時寫入類型信息，默認為false。反序列化時需用到
     */
    WriteClassName,
    /**
     * @since 1.1.6
     * 消除對同一對象循環(huán)引用的問題，默認為false
     */
    DisableCircularReferenceDetect,
    /**
     * @since 1.1.9
     * 對斜杠"/"進行轉(zhuǎn)義
     */
    WriteSlashAsSpecial,
    /**
     * @since 1.1.10
     * 將中文都會序列化為uXXXX格式，字節(jié)數(shù)會多一些，但是能兼容IE 6，默認為false
     */
    BrowserCompatible,
    /**
     * @since 1.1.14
     * 全局修改日期格式,默認為false。JSON.DEFFAULT_DATE_FORMAT = “yyyy-MM-dd”;JSON.toJSONString(obj, SerializerFeature.WriteDateUseDateFormat);
     */
    WriteDateUseDateFormat,
    /**
     * @since 1.1.15
     */
    NotWriteRootClassName,
    /**
     * @since 1.1.19
     * 一個對象的字符串屬性中如果有特殊字符如雙引號，將會在轉(zhuǎn)成json時帶有反斜杠轉(zhuǎn)移符。如果不需要轉(zhuǎn)義，可以使用這個屬性。默認為false
     */
    DisableCheckSpecialChar,
    /**
     * @since 1.1.35
     * 將對象轉(zhuǎn)為array輸出
     */
    BeanToArray,
    /**
     * @since 1.1.37
     */
    WriteNonStringKeyAsString,   
    /**
     * @since 1.1.42
     */
    NotWriteDefaultValue,    
    /**
     * @since 1.2.6
     */
    BrowserSecure,    
    /**
     * @since 1.2.7
     */
    IgnoreNonFieldGetter,   
    /**
     * @since 1.2.9
     */
    WriteNonStringValueAsString,    
    /**
     * @since 1.2.11
     */
    IgnoreErrorGetter;

}

public enum Feature {
    /**
     * 這個特性，決定了解析器是否將自動關閉那些不屬于parser自己的輸入源。 
     * 如果禁止，則調(diào)用應用不得不分別去關閉那些被用來創(chuàng)建parser的基礎輸入流InputStream和reader；
     * 如果允許，parser只要自己需要獲取closed方法（當遇到輸入流結(jié)束，或者parser自己調(diào)用 JsonParder#close方法），就會處理流關閉。
     * 注意：這個屬性默認是true，即允許自動關閉流
     */
    AutoCloseSource,
    /**
     * 該特性決定parser將是否允許解析使用Java/C++ 樣式的注釋（包括'/'+'*' 和'//' 變量）。 
     * 由于JSON標準說明書上面沒有提到注釋是否是合法的組成，所以這是一個非標準的特性；盡管如此，這個特性還是被廣泛地使用。
     * 注意：該屬性默認是false，因此必須顯式允許，即通過JsonParser.Feature.ALLOW_COMMENTS 配置為true。
     */
    AllowComment,
    /**
     * 這個特性決定parser是否將允許使用非雙引號屬性名字， （這種形式在Javascript中被允許，但是JSON標準說明書中沒有）。
     * 注意：由于JSON標準上需要為屬性名稱使用雙引號，所以這也是一個非標準特性，默認是false的。
     * 同樣，需要設置JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES為true，打開該特性。
     */
    AllowUnQuotedFieldNames,
    /**
     * 該特性決定parser是否允許單引號來包住屬性名稱和字符串值。
     * 注意：默認下，該屬性也是關閉的。需要設置JsonParser.Feature.ALLOW_SINGLE_QUOTES為true
     */
    AllowSingleQuotes,
    /**
     * 該特性決定JSON對象屬性名稱是否可以被String#intern 規(guī)范化表示。如果允許，則JSON所有的屬性名將會 intern() ；
     * 如果不設置，則不會規(guī)范化，默認下，該屬性是開放的。此外，必須設置CANONICALIZE_FIELD_NAMES為true
     * 關于intern方法作用：當調(diào)用 intern 方法時，如果池已經(jīng)包含一個等于此 String 對象的字符串 （該對象由 equals(Object) 方法確定），則返回池中的字符串。
     * 否則，將此 String 對象添加到池中， 并且返回此 String 對象的引用。
     */
    InternFieldNames,
    /**
     * 這個設置為true則遇到字符串符合ISO8601格式的日期時，會直接轉(zhuǎn)換成日期類。
     */
    AllowISO8601DateFormat,
    /**
     * 允許多重逗號,如果設為true,則遇到多個逗號會直接跳過。
     * {"a":1,,,"b":2}
     */
    AllowArbitraryCommas,
    /**
     * 這個設置為true則用BigDecimal類來裝載數(shù)字，否則用的是double；
     */
    UseBigDecimal,  
    /**
     * @since 1.1.2 
     * 忽略不匹配
     */
    IgnoreNotMatch,
    /**
     * @since 1.1.3
     * 如果你用fastjson序列化的文本，輸出的結(jié)果是按照fieldName排序輸出的，parser時也能利用這個順序進行優(yōu)化讀取。這種情況下，parser能夠獲得非常好的性能
     */
    SortFeidFastMatch,  
    /**
     * @since 1.1.3
     * 禁用ASM
     */
    DisableASM, 
    /**
     * @since 1.1.7
     * 禁用循環(huán)引用檢測
     */
    DisableCircularReferenceDetect,    
    /**
     * @since 1.1.10
     * 對于沒有值的字符串屬性設置為空串
     */
    InitStringFieldAsEmpty,   
    /**
     * @since 1.1.35
     * 支持數(shù)組to對象
     */
    SupportArrayToBean,   
    /**
     * @since 1.2.3
     * 屬性保持原來的順序
     */
    OrderedField,  
    /**
     * @since 1.2.5
     * 禁用特殊字符檢查
     */
    DisableSpecialKeyDetect,
    
    /**
     * @since 1.2.9
     * 使用對象數(shù)組
     */
    UseObjectArray;

}

class User {
    
    //指定序列化字段順序，字段名稱
    @JSONField(ordinal=4,name="ID")
    private Integer id;
    
    //指定序列化字段順序，不參加序列化
    @JSONField(ordinal=3,serialize=false)
    private String name; 
    
    //指定序列化字段順序，不參加反序列化
    @JSONField(ordinal=2,deserialize=false)
    private Integer age;
    
    //指定序列化字段順序，日期格式
    @JSONField(ordinal=1,format="yyyy-MM-dd")
    private Date creattime;
    
    //指定序列化規(guī)則，字段為null的時候依然參加序列化
    @JSONField(serialzeFeatures=SerializerFeature.WriteMapNullValue)
    private String phone;
  
    public Integer getId() {return id;}
    public Date getCreattime() {return creattime;}
    public void setId(Integer id) {this.id = id;}
    public void setCreattime(Date creattime) {this.creattime = creattime;}
    public String getName() {return name;}  
    public void setName(String name) {this.name = name;}  
    public Integer getAge() {return age;}  
    public void setAge(Integer age) {this.age = age;}
    public String getPhone() {return phone;}
    public void setPhone(String phone) {this.phone = phone;}

    @Override
    public String toString() {
        return "id="+id+"; name="+name+"; age="+age+"; createtime="+creattime;
    }
    
};

User user = new User();
user.setId(123456);
user.setName("wangbo");
user.setAge(28);
user.setCreattime(new Date());
        
String userStr = JSON.toJSONString(user);
System.out.println(userStr);
        
User user2 = JSON.parseObject(userStr, User.class);
System.out.println(user2);

{"phone":null,"creattime":"2018-12-04","age":28,"ID":123456}

id=123456; name=null; age=null; createtime=Tue Dec 04 00:00:00 CST 2018

public class JSONPath {
    
    //求值，靜態(tài)方法
    public static Object eval(Object rootObject, String path);

    //計算size，Map非空元素個數(shù)，對象非空元素個數(shù)，Collection的Size，數(shù)組的長度。其他無法求值返回-1
    public static int size(Object rootObject, String path);

    //是否包含，path中是否存在對象
    public static boolean contains(Object rootObject, String path);

    //是否包含，path中是否存在指定值，如果是集合或者數(shù)組，在集合中查找value是否存在
    public static boolean containsValue(Object rootObject, String path, Object value);

    //在數(shù)組或者集合中添加元素
    public static void arrayAdd(Object rootObject, String path, Object... values);

    //修改制定路徑的值，如果修改成功，返回true，否則返回false
    public static boolean set(Object rootObject, String path, Object value);

}

$.store.book[0].title

$['store']['book'][0]['title']

package com.wangbo.fastjson;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONPath;

public class Test {
    
    public static void main(String[] args) {
        String jsonStr = "{
" +
                "    "store": {
" +
                "        "bicycle": {
" +
                "            "color": "red",
" +
                "            "price": 19.95
" +
                "        },
" +
                "        "book": [
" +
                "            {
" +
                "                "author": "劉慈欣",
" +
                "                "price": 8.95,
" +
                "                "category": "科幻",
" +
                "                "title": "三體"
" +
                "            },
" +
                "            {
" +
                "                "author": "itguang",
" +
                "                "price": 12.99,
" +
                "                "category": "編程語言",
" +
                "                "title": "go語言實戰(zhàn)"
" +
                "            }
" +
                "        ]
" +
                "    }
" +
                "}";

        JSONObject jsonObject = JSON.parseObject(jsonStr);

        System.out.println(jsonObject.toString());

        //得到所有的書
        List<Book> books = (List<Book>) JSONPath.eval(jsonObject, "$.store.book");
        System.out.println("books=" + books);

        //得到所有的書名
        List<String> titles = (List<String>) JSONPath.eval(jsonObject, "$.store.book.title");
        System.out.println("titles=" + titles);

        //第一本書title
        String title = (String) JSONPath.read(jsonStr, "$.store.book[0].title");
        System.out.println("title=" + title);

        //price大于10元的book
        List<Book> list = (List<Book>) JSONPath.read(jsonStr, "$.store.book[price > 10]");
        System.out.println("price大于10元的book="+ list);

        //price大于10元的title
        List<String> list2 =(List<String>) JSONPath.read(jsonStr, "$.store.book[price > 10].title");
        System.out.println("price大于10元的title=" + list2);

        //category(類別)為科幻的book
        List<Book> list3 = (List<Book>) JSONPath.read(jsonStr,"$.store.book[category = '科幻']");
        System.out.println("category(類別)為科幻的book=" + list3);

        //bicycle的所有屬性值
        Collection<String> values = (Collection<String>) JSONPath.eval(jsonObject, "$.store.bicycle.*");
        System.out.println("bicycle的所有屬性值={}" + values);

        //bicycle的color和price屬性值
        List<String> read =(List<String>) JSONPath.read(jsonStr, "$.store.bicycle['color','price']");
        System.out.println("bicycle的color和price屬性值=" + read);

    }

}

{"store":{"bicycle":{"color":"red","price":19.95},"book":[{"author":"劉慈欣","price":8.95,"category":"科幻","title":"三體"},{"author":"itguang","price":12.99,"category":"編程語言","title":"go語言實戰(zhàn)"}]}}
books=[{"author":"劉慈欣","price":8.95,"category":"科幻","title":"三體"},{"author":"itguang","price":12.99,"category":"編程語言","title":"go語言實戰(zhàn)"}]
titles=["三體","go語言實戰(zhàn)"]
title=三體
price大于10元的book=[{"author":"itguang","price":12.99,"category":"編程語言","title":"go語言實戰(zhàn)"}]
price大于10元的title=["go語言實戰(zhàn)"]
category(類別)為科幻的book=[{"author":"劉慈欣","price":8.95,"category":"科幻","title":"三體"}]
bicycle的所有屬性值={}[red, 19.95]
bicycle的color和price屬性值=[red, 19.95]