参考：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"]
");
//将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" } ]