參考：https://www.runoob.com/w3cnote/fastjson-intro.html
一、JSON類庫
Json類庫選擇：Java中並沒有內置JSON的解析，因此使用JSON需要借助第三方類庫。下面是幾個常用的 JSON 解析類庫：
Gson：谷歌開發的JSON庫，功能十分全面。
FastJson：阿里巴巴開發的JSON庫，性能十分優秀。
Jackson：社區十分活躍且更新速度很快。
二、FastJson簡介
Fastjson是一個 Java 庫，可以將 Java 對象轉換為 JSON 格式，當然它也可以將 JSON 字符串轉換為 Java 對象。Fastjson 可以操作任何 Java 對象，即使是一些預先存在的沒有源碼的對象。
源碼地址：https://github.com/alibaba/fastjson Fastjson
中文 Wiki：https://github.com/alibaba/fastjson/wiki/Quick-Start-CN
Fastjson特性
- 提供服務器端、安卓客戶端兩種解析工具，性能表現較好。
- 提供了 toJSONString() 和 parseObject() 方法來將 Java 對象與 JSON 相互轉換。調用toJSONString()方法即可將對象轉換成 JSON 字符串，parseObject() 方法則反過來將 JSON 字符串轉換成對象。
- 允許轉換預先存在的無法修改的對象（只有class、無源代碼）。
- Java泛型的廣泛支持。
- 允許對象的自定義表示、允許自定義序列化類。
- 支持任意復雜對象（具有深厚的繼承層次和廣泛使用的泛型類型）。
FastJson使用：
可以在 maven 中央倉庫中直接下載：http://repo1.maven.org/maven2/com/alibaba/fastjson/
或
通過Maven依賴使用：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
其中 1.2.47 是版本號，根據需要使用特定版本，建議使用最新版本。
三、Fasjson中的主要類定義
FastJson類庫中最基本的類和方法定義：
1、JSON
JSON類在com.alibaba.fastjson.JSON包中。
JSON類提供了多種 Java對象<->JSON字符串 直接互相轉換的方法。
JSON.parseObject()：從字符串解析 JSON 對象。
JSON.parseArray()：從字符串解析 JSON 數組。
JSON.toJSONString(obj/array)：將 JSON 對象或 JSON 數組轉化為字符串。
樣例：
//從字符串解析JSON對象
JSONObject obj = JSON.parseObject("{\"Test\":\"你好\"}");
//從字符串解析JSON數組
JSONArray arr = JSON.parseArray("[\"Test1\",\"Test2\"]\n");
//將JSON對象轉化為字符串
String objStr = JSON.toJSONString(obj);
//將JSON數組轉化為字符串
String arrStr = JSON.toJSONString(arr);
JSON類中主要常用方法定義
public abstract class JSON impletements JSONStreamAware, JSONAware {
....
//parseObject()方法
public static JSONObject parseObject(String text, Feature... features) {....}
public static JSONObject parseObject(String text) {....}
public static <T> T parseObject(String text, TypeReference<T> type, Feature... features) {....}
public static <T> T parseObject(String json, Class<T> clazz, Feature... features) {....}
public static <T> T parseObject(String text, Class<T> clazz, ParseProcess processor, Feature... features) {
....
}
public static <T> T parseObject(String json, Type type, Feature... features) {....}
public static <T> T parseObject(byte[] bytes, Type clazz, Feature... features) {....}
public static <T> T parseObject(char[] input, int length, Type clazz, Feature... features) {....}
....
//parseArray()方法
public static JSONArray parseArray(String text) {....}
public static <T> List<T> parseArray(String text, Class<T> clazz) {....}
public static List<Object> parseArray(String text, Type[] types) {....}
....
//toJSONString()方法
public String toJSONString() {...}
....
public static String toJSONString(Object object) {....}
public static String toJSONString(Object object, SerializerFeature... features) {....}
public static String toJSONString(Object object, int defaultFeatures, SerializerFeature... features) {
....
}
....
}
2、JSONObject
JSONObject類在com.alibaba.fastjson.JSONObject包中。
public class JSONObject extern JSON implements Map<String, Object>, Cloneable, Serializable, InvocationHandler {
....
//用於表示一個JSON對象的數據結構，是一個key和value的集合，Key是String類型、Value可能是基礎類型或其他JSON對象
private fianl Map<String, Object> map;
....
//判斷是否為對象，map為空，即沒有key和value
public boolean isEmpyt() {
....
}
//指定key獲取value。如果value對象為非JSONObject類型（String、Map等），本函數會把其轉換為JSONObject類型。
public JSONObject getJSONObject(String key) {
....
}
//指定key，對應value。如果value對象為非JSONArray類型（String、List等），本函數會把其轉換為JSONArray類型。
public JSONArray getJSONArray(String key) {
....
}
}
3、JSONArray
JSONArray類在com.alibaba.fastjson.JSONArray包中。
public class JSONArray extern JSON implements List, Cloneable, RadomAccess, Serializable {
....
private fianl List list;
....
//構造方法
public JSONArray() {this.list = new ArrayList(); }
public JSONArray(List list) {this.list = list; }
public JSONArray(int initialCapacity) {this.list = new ArrayList(this.list = new ArrayList();)
....
//指定索引，獲取JSONObject
public JSONObject getJSONObject(int index) {...}
....
//指定索引，轉換成Java自定義類型的實例
public T getObject(int index, Class clazz) {...}
....
//轉換成Java自定義類型的實例列表
public List toJavaList(Class clazz) {...}
}
四、JSON序列化：Java對象→JSON字符串
1、通過JSONField方式
樣例：
public class Person {
@JSONField(name = "AGE")
private int age;
@JSONField(name = "FULL NAME")
private String fullName;
@JSONField(name = "DATE OF BIRTH")
private Date dateOfBirth;
public Person(int age, String fullName, Date dateOfBirth) {
super();
this.age = age;
this.fullName= fullName;
this.dateOfBirth = dateOfBirth;
}
// 標准 getters & setters
}
使用JSON.toJSONString()將Java對象轉換換為JSON字符串：
private List listOfPersons = new ArrayList();
@Before
public void setUp() {
listOfPersons.add(new Person(15, "John Doe", new Date()));
listOfPersons.add(new Person(20, "Janette Doe", new Date()));
}
@Test
public void whenJavaList_thanConvertToJsonCorrect() {
String jsonOutput= JSON.toJSONString(listOfPersons);
}
輸出結果為：
[{"AGE":15, "DATE OF BIRTH":1468962431394, "FULL NAME":"John Doe" },
{"AGE":20, "DATE OF BIRTH":1468962431394, "FULL NAME":"Janette Doe" } ]
我們還可以自定義輸出，並控制字段的排序、日期顯示格式、序列化標記等。接下來我們更新bean並添加幾個字段：
@JSONField(name="AGE", serialize=false)
private int age;
@JSONField(name="LAST NAME", ordinal = 2)
private String lastName;
@JSONField(name="FIRST NAME", ordinal = 1)
private String firstName;
@JSONField(name="DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3)
private Date dateOfBirth;
以上代碼中我們列出了基本參數類別，並使用 @JSONField 注解，以便實現自定義轉換：
- format參數用於格式化Data的屬性。
- serialize參數指定字段不序列化。默認情況下，FastJson庫可以序列化Java bean實體，但可以使用serialize指定字段不序列化。
- ordinal參數指定字段的順序。
輸出結果為：
[ {
"FIRST NAME":"Doe",
"LAST NAME":"Jhon",
"DATE OF BIRTH":"19/07/2016"
}, {
"FIRST NAME":"Doe",
"LAST NAME":"Janette",
"DATE OF BIRTH":"19/07/2016"
} ]
2、通過JSONObject方式
使用JSONObject和JSONArray創建JSON對象。
JSONObject和JSONArray繼承了JSON，可以直接使用兩者對“JSON字符串”與“JSON對象” 及java Bean之間做轉換，不過為了避免混淆，我們還是建議使用JSON的toJSONString()方法。
使用繼承的toJSONString()方法樣例：
@Test
public void whenGenerateJson_thanGenerationCorrect() throws ParseException {
JSONArray jsonArray = new JSONArray();
for (int i = 0; i < 2; i++) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("AGE", 10);
jsonObject.put("FULL NAME", "Doe " + i);
jsonObject.put("DATE OF BIRTH", "2016/12/12 12:12:12");
jsonArray.add(jsonObject);
}
String jsonOutput = jsonArray.toJSONString(); //這里是展示使用JSONArray的toJSONString()用法。實際開發中仍然**建議使用String jsonOutput = JSON.toJSONString(jsonArray);**
}
輸出結果為：
[ { "AGE":"10", "DATE OF BIRTH":"2016/12/12 12:12:12", "FULL NAME":"Doe 0" }, { "AGE":"10", "DATE OF BIRTH":"2016/12/12 12:12:12", "FULL NAME":"Doe 1" } ]
3、@JSONField作用對象詳解
@JSONField 的作用對象:
- Field
- Setter和Getter方法
注意：FastJson 在進行操作時，是根據Getter和Setter 的方法進行的，並不是依據 Field 進行。
注意：若屬性是私有的，必須有set方法。否則無法反序列化。
JSONField定義：
package com.alibaba.fastjson.annotation;
public @interface JSONField {
// 配置序列化和反序列化的順序，1.1.42版本之后才支持 int ordinal() default 0;
// 指定字段的名稱
String name() default "";
// 指定字段的格式，對日期格式有用
String format() default "";
// 是否序列化
boolean serialize() default true;
// 是否反序列化
boolean deserialize() default true;
}
@JSONField 配置方式：
- 配置在 field 上
public class A {
@JSONField(name="ID")
private int id;
public int getId() {return id;}
public void setId(int value) {this.id = id;}
}
- 配置在 getter/setter 上
public class A {
private int id;
@JSONField(name="ID")
public int getId() {return id;}
@JSONField(name="ID")
public void setId(int value) {this.id = id;}
}
- 使用format配置日期格式化
public class A {
// 配置date序列化和反序列使用yyyyMMdd日期格式
@JSONField(format="yyyyMMdd")
public Date date;
}
- 使用serialize/deserialize指定字段不序列化/反序列化
public class A {
@JSONField(serialize=false)
public Date date;
}
public class A {
@JSONField(deserialize=false)
public Date date;
}
- 使用ordinal指定字段的順序
默認fastjson序列化一個java bean，是根據 fieldName 的字母序進行序列化的，你可以通過 ordinal 指定字段的順序。這個特性需1.1.42以上版本。
public static class VO {
@JSONField(ordinal = 3)
private int f0;
@JSONField(ordinal = 2)
private int f1;
@JSONField(ordinal = 1)
private int f2;
}
@JsonInclude注解
本注解表示對象轉json字符串時，為NULL的字段不參加序列化。
如：后端返回給前端JSON格式的對象數據中，當對象的字段為NULL時，該字段也會寫入JSON返回；而很多時候前端期望后端只返回對象中非null的字段數據。在Jackson框架中提供了 @JsonInclude 注解以實現該功能。
- 不返回null字段數據
在相關對象的類上添加 @JsonInclude 注解，設定值為 NON_NULL
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Student
{
private int id;
private String username;
private String sex;
private String address;
...
}
則HTTP Response返回的該類的對象的JSON數據如下所示，無為null的字段
{
"id": 0,
"username": "Kallen",
"sex": "female"
}
- 返回null字段數據
在相關對象的類上添加 @JsonInclude 注解，設定值為 ALWAYS
@JsonInclude(JsonInclude.Include.ALWAYS)
則HTTP Response返回的該類的對象的JSON數據如下所示，其中包含null的字段
{
"id": 0,
"username": "Kallen",
"sex": "female",
"address": null
}
@JsonInclue注解不設定值的情況下，默認使用 ALWAYS。
五、Json反序列化：JSON字符串->Java對象
1、JSON字符串轉換成JSONObject對象
實例：
public void testJson2() {
JSONObject object = JSONObject.parseObject("{\"boolean\":true,\"string\":\"string\",\"list\":[1,2,3],\"int\":2}");
//string
String s = object.getString("string");
System.out.println(s);
//int
int i = object.getIntValue("int");
System.out.println(i);
//boolean
boolean b = object.getBooleanValue("boolean");
System.out.println(b);
//list
List integers = JSON.parseArray(object.getJSONArray("list").toJSONString(), Integer.class);
integers.forEach(System.out::println);
//null
System.out.println(object.getString("null"));
}
在上例中，首先從 JSON 格式的字符串中構造一個 JSON 對象，之后依次讀取字符串、整數、布爾值以及數組。打印結果如下：
string 2 true 1 2 3 null
2、JSON字符串轉換成自定義JAVA對象
- 實例：
@Test
public void whenJson_thanConvertToObjectCorrect() {
Person person = new Person(20, "John", "Doe", new Date());
String jsonObject = JSON.toJSONString(person);
//Json字符串反序列化成Java對象。
Person newPerson = JSON.parseObject(jsonObject, Person.class);
assertEquals(newPerson.getAge(), 0); // 如果我們設置系列化為 false
assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName());
}
- 注意:反序列化時為對象時，必須要有默認無參的構造函數，否則會報異常:com.alibaba.fastjson.JSONException: default constructor not found.
注意：JSON反序列化時，同樣用到Java的@JSONField注解。@JSONField deserialize可選項可以指定字段不反序列化。
樣例：
@JSONField(name = "DATE OF BIRTH", deserialize=false)
private Date dateOfBirth;
2.也可使用toJavaObject()方法
（1）JSONObect的方法
public <T> T toJavaObject<Class<T> Clazz>；
（1）JSONArray的方法
public <T> List<T> toJavaList<Class<T> Clazz>；
六、序列化過程中使用過濾器
1、采用ContextValueFilter對value進行過濾
在某些場景下，對Value做過濾，需要獲得所屬JavaBean的信息，包括類型、字段、方法等。在fastjson-1.2.9中，提供了ContextValueFilter，類似於之前版本提供的ValueFilter，只是多了BeanContext參數可用。
@Test
public void givenContextFilter_whenJavaObject_thanJsonCorrect() {
ContextValueFilter valueFilter = new ContextValueFilter () {
public Object process(BeanContext context, Object object, String name, Object value) {
if (name.equals("DATE OF BIRTH")) {
return "NOT TO DISCLOSE";
}
if (value.equals("John")) {
return ((String) value).toUpperCase();
} else {
return null;
}
}
};
String jsonOutput = JSON.toJSONString(listOfPersons, valueFilter);
}
以上實例中我們隱藏了 DATE OF BIRTH 字段，並過濾名字不包含John的字段：
[ { "FULL NAME":"JOHN DOE", "DATE OF BIRTH":"NOT TO DISCLOSE" } ]
2、使用 NameFilter 和 SerializeConfig修改key
- NameFilter: 序列化時修改 Key。
- SerializeConfig：內部是個map容器主要功能是配置並記錄每種Java類型對應的序列化類。
@Test
public void givenSerializeConfig_whenJavaObject_thanJsonCorrect() {
NameFilter formatName = new NameFilter() {
public String process(Object object, String name, Object value) {
return name.toLowerCase().replace(" ", "_");
}
};
SerializeConfig.getGlobalInstance().addFilter(Person.class, formatName);
String jsonOutput = JSON.toJSONStringWithDateFormat(listOfPersons, "yyyy-MM-dd");
}
聲明了 formatName過濾器，使用NameFilter匿名類來處理字段名稱。
新創建的過濾器與 Person 類相關聯，然后添加到全局實例，它是 SerializeConfig 類中的靜態屬性。
注意我們使用的是 toJSONStringWithDateFormat() 而不是 toJSONString() ，它可以更快速的格式化日期。輸出結果：
[{"full_name":"John Doe", "date_of_birth":"2016-07-21" },
{"full_name":"Janette Doe", "date_of_birth":"2016-07-21" } ]